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\\textcolor{note_fontcolor}\\ignorespaces%\n";
 564                 else
 565                         ods << "      \\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 << "    \\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 << "\\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 = (params_.main_font_encoding() == "default"
 787                 || params_.main_font_encoding() == "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 namespace {
 831
 832 void addSnippet(std::list<TexString> & list, TexString ts, bool allow_dupes)
 833 {
 834         if (allow_dupes ||
 835             // test the absense of duplicates, i.e. elements with same str
 836             none_of(list.begin(), list.end(), [&](TexString const & ts2){
 837                             return ts.str == ts2.str;
 838                     })
 839             )
 840                 list.push_back(move(ts));
 841 }
 842
 843
 844 TexString getSnippets(std::list<TexString> const & list)
 845 {
 846         otexstringstream snip;
 847         for (TexString const & ts : list)
 848                 snip << TexString(ts) << '\n';
 849         return snip.release();
 850 }
 851
 852 } // namespace
 853
 854
 855 void LaTeXFeatures::addPreambleSnippet(TexString snippet, bool allow_dupes)
 856 {
 857         addSnippet(preamble_snippets_, move(snippet), allow_dupes);
 858 }
 859
 860
 861 void LaTeXFeatures::addPreambleSnippet(docstring const & snippet, bool allow_dupes)
 862 {
 863         addSnippet(preamble_snippets_, TexString(snippet), allow_dupes);
 864 }
 865
 866
 867 void LaTeXFeatures::addCSSSnippet(std::string const & snippet)
 868 {
 869         addSnippet(css_snippets_, TexString(from_ascii(snippet)), false);
 870 }
 871
 872
 873 TexString LaTeXFeatures::getPreambleSnippets() const
 874 {
 875         return getSnippets(preamble_snippets_);
 876 }
 877
 878
 879 docstring LaTeXFeatures::getCSSSnippets() const
 880 {
 881         return getSnippets(css_snippets_).str;
 882 }
 883
 884
 885
 886 void LaTeXFeatures::useFloat(string const & name, bool subfloat)
 887 {
 888         if (!usedFloats_[name])
 889                 usedFloats_[name] = subfloat;
 890         if (subfloat)
 891                 require("subfig");
 892         // We only need float.sty if we use non builtin floats, or if we
 893         // use the "H" modifier. This includes modified table and
 894         // figure floats. (Lgb)
 895         Floating const & fl = params_.documentClass().floats().getType(name);
 896         if (!fl.floattype().empty()) {
 897                 if (fl.usesFloatPkg())
 898                         require("float");
 899                 if (!fl.required().empty()) {
 900                         vector<string> reqs = getVectorFromString(fl.required());
 901                         for (auto const & req : reqs)
 902                                 require(req);
 903                 }
 904         }
 905 }
 906
 907
 908 void LaTeXFeatures::useLanguage(Language const * lang)
 909 {
 910         if (!lang->babel().empty() || !lang->polyglossia().empty())
 911                 UsedLanguages_.insert(lang);
 912         if (!lang->required().empty())
 913                 require(lang->required());
 914         // currently only supported for Babel
 915         if (!lang->provides().empty() && useBabel())
 916                 provide(lang->provides());
 917         // CJK languages do not have a babel name.
 918         // They use the CJK package
 919         if (lang->encoding()->package() == Encoding::CJK)
 920                 require("CJK");
 921         // japanese babel language is special (tied to the pLaTeX engine).
 922         if (lang->encoding()->package() == Encoding::japanese)
 923                 require("japanese");
 924 }
 925
 926
 927 void LaTeXFeatures::includeFile(docstring const & key, string const & name)
 928 {
 929         IncludedFiles_[key] = name;
 930 }
 931
 932
 933 bool LaTeXFeatures::hasLanguages() const
 934 {
 935         return !UsedLanguages_.empty();
 936 }
 937
 938
 939 bool LaTeXFeatures::hasOnlyPolyglossiaLanguages() const
 940 {
 941         // first the main language
 942         if (params_.language->polyglossia().empty())
 943                 return false;
 944         // now the secondary languages
 945         for (auto const & lang : UsedLanguages_)
 946         {
 947                 if (lang->polyglossia().empty())
 948                         return false;
 949         }
 950         return true;
 951 }
 952
 953
 954 bool LaTeXFeatures::hasPolyglossiaExclusiveLanguages() const
 955 {
 956         // first the main language
 957         if (params_.language->isPolyglossiaExclusive())
 958                 return true;
 959         // now the secondary languages
 960         for (auto const & lang : UsedLanguages_)
 961         {
 962                 if (lang->isPolyglossiaExclusive())
 963                         return true;
 964         }
 965         return false;
 966 }
 967
 968
 969 vector<string> LaTeXFeatures::getPolyglossiaExclusiveLanguages() const
 970 {
 971         vector<string> result;
 972         // first the main language
 973         if (params_.language->isPolyglossiaExclusive())
 974                 result.push_back(params_.language->display());
 975         // now the secondary languages
 976         for (auto const & lang : UsedLanguages_)
 977         {
 978                 if (lang->isPolyglossiaExclusive())
 979                         result.push_back(lang->display());
 980         }
 981         return result;
 982 }
 983
 984
 985 vector<string> LaTeXFeatures::getBabelExclusiveLanguages() const
 986 {
 987         vector<string> result;
 988         // first the main language
 989         if (params_.language->isBabelExclusive())
 990                 result.push_back(params_.language->display());
 991         // now the secondary languages
 992         for (auto const & lang : UsedLanguages_)
 993         {
 994                 if (lang->isBabelExclusive())
 995                         result.push_back(lang->display());
 996         }
 997         return result;
 998 }
 999
1000
1001 string LaTeXFeatures::getBabelLanguages() const
1002 {
1003         vector<string> blangs;
1004         for (auto const & lang : UsedLanguages_) {
1005                 if (!lang->babel().empty())
1006                         blangs.push_back(lang->babel());
1007         }
1008
1009         // Sort alphabetically to assure consistent order
1010         // (the order itself does not matter apart from
1011         // some exceptions, e.g. hebrew must come after
1012         // arabic and farsi)
1013         sort(blangs.begin(), blangs.end());
1014
1015         return getStringFromVector(blangs);
1016 }
1017
1018
1019 set<string> LaTeXFeatures::getPolyglossiaLanguages() const
1020 {
1021         set<string> langs;
1022
1023         for (auto const & lang : UsedLanguages_)
1024                 // We do not need the variants here
1025                 langs.insert(lang->polyglossia());
1026         return langs;
1027 }
1028
1029
1030 string LaTeXFeatures::getActiveChars() const
1031 {
1032         string res;
1033         // first the main language
1034         res += params_.language->activeChars();
1035         // now the secondary languages
1036         for (auto const & lang : UsedLanguages_)
1037                 res += (lang->activeChars());
1038         return res;
1039 }
1040
1041
1042 set<string> LaTeXFeatures::getEncodingSet(string const & doc_encoding) const
1043 {
1044         // This does only find encodings of languages supported by babel, but
1045         // that does not matter since we don't have a language with an
1046         // encoding supported by inputenc but without babel support.
1047         set<string> encs;
1048         for (auto const & lang : UsedLanguages_)
1049                 if (lang->encoding()->latexName() != doc_encoding &&
1050                     lang->encoding()->package() == Encoding::inputenc)
1051                         encs.insert(lang->encoding()->latexName());
1052         return encs;
1053 }
1054
1055
1056 void LaTeXFeatures::getFontEncodings(vector<string> & encs, bool const onlylangs) const
1057 {
1058         if (!onlylangs) {
1059                 // these must be loaded if glyphs of this script are used
1060                 // unless a language providing them is used in the document
1061                 if (mustProvide("textgreek")
1062                     && find(encs.begin(), encs.end(), "LGR") == encs.end())
1063                         encs.insert(encs.begin(), "LGR");
1064                 if ((mustProvide("textcyrillic") || mustProvide("textschwa"))
1065                     && find(encs.begin(), encs.end(), "T2A") == encs.end())
1066                         encs.insert(encs.begin(), "T2A");
1067         }
1068
1069         for (auto const & lang : UsedLanguages_)
1070         {
1071                 vector<string> extraencs =
1072                         getVectorFromString(lang->fontenc(buffer().masterParams()));
1073                 for (auto const & extra : extraencs) {
1074                         if (extra != "none" && find(encs.begin(), encs.end(), extra) == encs.end())
1075                                 encs.insert(encs.begin(), extra);
1076                 }
1077         }
1078 }
1079
1080
1081 bool LaTeXFeatures::hasRTLLanguage() const
1082 {
1083         if (params_.language->rightToLeft())
1084                 return true;
1085         for (auto const & lang : UsedLanguages_)
1086                 if (lang->rightToLeft())
1087                         return true;
1088         return false;
1089 }
1090
1091
1092 namespace {
1093
1094 char const * simplefeatures[] = {
1095 // note that the package order here will be the same in the LaTeX-output
1096         "array",
1097         "verbatim",
1098         "cprotect",
1099         "longtable",
1100         "latexsym",
1101         "pifont",
1102         // subfig is handled in BufferParams.cpp
1103         "varioref",
1104         "prettyref",
1105         "refstyle",
1106         /*For a successful cooperation of the `wrapfig' package with the
1107           `float' package you should load the `wrapfig' package *after*
1108           the `float' package. See the caption package documentation
1109           for explanation.*/
1110         "float",
1111         "wrapfig",
1112         "booktabs",
1113         "fancybox",
1114         "calc",
1115         "units",
1116         "framed",
1117         "soul",
1118         "dingbat",
1119         "bbding",
1120         "ifsym",
1121         "txfonts",
1122         "pxfonts",
1123         "mathdesign",
1124         "mathrsfs",
1125         "mathabx",
1126         "mathtools",
1127         // "cancel",
1128         "ascii",
1129         "url",
1130         "csquotes",
1131         "enumitem",
1132         "endnotes",
1133         "enotez",
1134         "hhline",
1135         "ifthen",
1136         // listings is handled in BufferParams.cpp
1137         "bm",
1138         "pdfpages",
1139         "amscd",
1140         "slashed",
1141         "multicol",
1142         "multirow",
1143         "tfrupee",
1144         "shapepar",
1145         "rsphrase",
1146         "hpstatement",
1147         "algorithm2e",
1148         "sectionbox",
1149         "tcolorbox",
1150         "pdfcomment",
1151         "fixme",
1152         "todonotes",
1153         "forest",
1154         "varwidth",
1155         "afterpage",
1156         "tabularx",
1157         "tikz",
1158         "xltabular",
1159         "chessboard",
1160         "xskak",
1161         "pict2e",
1162         "drs",
1163         "environ",
1164         "dsfont"
1165 };
1166
1167 char const * bibliofeatures[] = {
1168         // Known bibliography packages (will be loaded before natbib)
1169         "achicago",
1170         "apacite",
1171         "apalike",
1172         "astron",
1173         "authordate1-4",
1174         "babelbib",
1175         "bibgerm",
1176         "chapterbib",
1177         "chicago",
1178         "chscite",
1179         "harvard",
1180         "mslapa",
1181         "named"
1182 };
1183
1184 } // namespace
1185
1186
1187 string const LaTeXFeatures::getColorOptions() const
1188 {
1189         ostringstream colors;
1190
1191         // Handling the color packages separately is needed to be able to load them
1192         // before babel when hyperref is loaded with the colorlinks option
1193         // for more info see Bufferparams.cpp
1194
1195         // [x]color.sty
1196         if (mustProvide("color") || mustProvide("xcolor")) {
1197                 string const package =
1198                         (mustProvide("xcolor") ? "xcolor" : "color");
1199                 if (params_.graphics_driver == "default"
1200                         || params_.graphics_driver == "none")
1201                         colors << "\\usepackage{" << package << "}\n";
1202                 else
1203                         colors << "\\usepackage["
1204                                  << params_.graphics_driver
1205                                  << "]{" << package << "}\n";
1206         }
1207
1208         // pdfcolmk must be loaded after color
1209         if (mustProvide("pdfcolmk"))
1210                 colors << "\\usepackage{pdfcolmk}\n";
1211
1212         // the following 3 color commands must be set after color
1213         // is loaded and before pdfpages, therefore add the command
1214         // here define the set color
1215         if (mustProvide("pagecolor")) {
1216                 colors << "\\definecolor{page_backgroundcolor}{rgb}{";
1217                 colors << outputLaTeXColor(params_.backgroundcolor) << "}\n";
1218                 // set the page color
1219                 colors << "\\pagecolor{page_backgroundcolor}\n";
1220         }
1221
1222         if (mustProvide("fontcolor")) {
1223                 colors << "\\definecolor{document_fontcolor}{rgb}{";
1224                 colors << outputLaTeXColor(params_.fontcolor) << "}\n";
1225                 // set the color
1226                 colors << "\\color{document_fontcolor}\n";
1227         }
1228
1229         if (mustProvide("lyxgreyedout")) {
1230                 colors << "\\definecolor{note_fontcolor}{rgb}{";
1231                 colors << outputLaTeXColor(params_.notefontcolor) << "}\n";
1232                 // the color will be set together with the definition of
1233                 // the lyxgreyedout environment (see lyxgreyedout_def)
1234         }
1235
1236         // color for shaded boxes
1237         if (isRequired("framed") && mustProvide("color")) {
1238                 colors << "\\definecolor{shadecolor}{rgb}{";
1239                 colors << outputLaTeXColor(params_.boxbgcolor) << "}\n";
1240                 // this color is automatically used by the LaTeX-package "framed"
1241         }
1242
1243         return colors.str();
1244 }
1245
1246
1247 string const LaTeXFeatures::getPackageOptions() const
1248 {
1249         ostringstream packageopts;
1250         // Output all the package option stuff we have been asked to do.
1251         for (auto const & p : params_.documentClass().packageOptions())
1252                 if (mustProvide(p.first))
1253                         packageopts << "\\PassOptionsToPackage{" << p.second << "}"
1254                                  << "{" << p.first << "}\n";
1255         return packageopts.str();
1256 }
1257
1258
1259 string const LaTeXFeatures::getPackages() const
1260 {
1261         ostringstream packages;
1262
1263         // FIXME: currently, we can only load packages and macros known
1264         // to LyX.
1265         // However, with the Require tag of layouts/custom insets,
1266         // also unknown packages can be requested. They are silently
1267         // swallowed now. We should change this eventually.
1268
1269         //  These are all the 'simple' includes.  i.e
1270         //  packages which we just \usepackage{package}
1271         for (char const * feature : simplefeatures) {
1272                 if (mustProvide(feature))
1273                         packages << "\\usepackage{" << feature << "}\n";
1274         }
1275
1276         // The rest of these packages are somewhat more complicated
1277         // than those above.
1278
1279         if (mustProvide("changebar")) {
1280                 packages << "\\usepackage";
1281                 if (runparams_.flavor == Flavor::LaTeX
1282                     || runparams_.flavor == Flavor::DviLuaTeX)
1283                         packages << "[dvips]";
1284                 packages << "{changebar}\n";
1285         }
1286
1287         if (mustProvide("footnote")) {
1288                 if (isRequired("hyperref"))
1289                         packages << "\\usepackage{footnotehyper}\n";
1290                 else
1291                         packages << "\\usepackage{footnote}\n";
1292         }
1293
1294         // [pdf]lscape is used to rotate longtables
1295         if (mustProvide("lscape")) {
1296                 if (runparams_.flavor == Flavor::LaTeX
1297                     || runparams_.flavor == Flavor::DviLuaTeX)
1298                         packages << "\\usepackage{lscape}\n";
1299                 else
1300                         packages << "\\usepackage{pdflscape}\n";
1301         }
1302
1303         // The tipa package and its extensions (tipx, tone) must not
1304         // be loaded with non-TeX fonts, since fontspec includes the
1305         // respective macros
1306         if (mustProvide("tipa") && !params_.useNonTeXFonts)
1307                 packages << "\\usepackage{tipa}\n";
1308         if (mustProvide("tipx") && !params_.useNonTeXFonts)
1309                 packages << "\\usepackage{tipx}\n";
1310         if (mustProvide("extraipa") && !params_.useNonTeXFonts)
1311                 packages << "\\usepackage{extraipa}\n";
1312         if (mustProvide("tone") && !params_.useNonTeXFonts)
1313                 packages << "\\usepackage{tone}\n";
1314
1315         // if fontspec or newtxmath is used, AMS packages have to be loaded
1316         // before fontspec (in BufferParams)
1317         string const amsPackages = loadAMSPackages();
1318         bool const ot1 = (params_.main_font_encoding() == "default"
1319                           || params_.main_font_encoding() == "OT1");
1320         bool const use_newtxmath =
1321                 theLaTeXFonts().getLaTeXFont(from_ascii(params_.fontsMath())).getUsedPackage(
1322                         ot1, false, false) == "newtxmath";
1323
1324         if (!params_.useNonTeXFonts && !use_newtxmath && !amsPackages.empty())
1325                 packages << amsPackages;
1326
1327         if (mustProvide("cancel") &&
1328             params_.use_package("cancel") != BufferParams::package_off)
1329                 packages << "\\usepackage{cancel}\n";
1330
1331         // marvosym and bbding both define the \Cross macro
1332         if (mustProvide("marvosym")) {
1333             if (mustProvide("bbding"))
1334                 packages << "\\let\\Cross\\relax\n";
1335             packages << "\\usepackage{marvosym}\n";
1336         }
1337
1338         // accents must be loaded after amsmath
1339         if (mustProvide("accents") &&
1340             params_.use_package("accents") != BufferParams::package_off)
1341                 packages << "\\usepackage{accents}\n";
1342
1343         // mathdots must be loaded after amsmath
1344         if (mustProvide("mathdots") &&
1345                 params_.use_package("mathdots") != BufferParams::package_off)
1346                 packages << "\\usepackage{mathdots}\n";
1347
1348         // yhmath must be loaded after amsmath
1349         if (mustProvide("yhmath") &&
1350             params_.use_package("yhmath") != BufferParams::package_off)
1351                 packages << "\\usepackage{yhmath}\n";
1352
1353         // stmaryrd must be loaded after amsmath
1354         if (mustProvide("stmaryrd") &&
1355             params_.use_package("stmaryrd") != BufferParams::package_off)
1356                 packages << "\\usepackage{stmaryrd}\n";
1357
1358         if (mustProvide("stackrel") &&
1359             params_.use_package("stackrel") != BufferParams::package_off)
1360                 packages << "\\usepackage{stackrel}\n";
1361
1362         if (mustProvide("undertilde") &&
1363                 params_.use_package("undertilde") != BufferParams::package_off)
1364                 packages << "\\usepackage{undertilde}\n";
1365
1366         // [x]color and pdfcolmk are handled in getColorOptions() above
1367
1368         // makeidx.sty
1369         if (isRequired("makeidx") || isRequired("splitidx")) {
1370                 if (!isProvided("makeidx") && !isRequired("splitidx"))
1371                         packages << "\\usepackage{makeidx}\n";
1372                 if (mustProvide("splitidx"))
1373                         packages << "\\usepackage{splitidx}\n";
1374                 packages << "\\makeindex\n";
1375         }
1376
1377         // graphicx.sty
1378         if (mustProvide("graphicx") && params_.graphics_driver != "none") {
1379                 if (params_.graphics_driver == "default")
1380                         packages << "\\usepackage{graphicx}\n";
1381                 else
1382                         packages << "\\usepackage["
1383                                  << params_.graphics_driver
1384                                  << "]{graphicx}\n";
1385         }
1386
1387         // These must be loaded after graphicx, since they try
1388         // to load graphicx without options
1389         if (mustProvide("rotating"))
1390                 packages << "\\usepackage{rotating}\n";
1391         if (mustProvide("rotfloat"))
1392                 packages << "\\usepackage{rotfloat}\n";
1393         // and this must be loaded after rotating
1394         if (mustProvide("tablefootnote"))
1395                 packages << "\\usepackage{tablefootnote}\n";
1396
1397         // lyxskak.sty --- newer chess support based on skak.sty
1398         if (mustProvide("chess"))
1399                 packages << "\\usepackage[ps,mover]{lyxskak}\n";
1400
1401         // setspace.sty
1402         if (mustProvide("setspace") && !isProvided("SetSpace"))
1403                 packages << "\\usepackage{setspace}\n";
1404
1405         // we need to assure that mhchem is loaded before esint and every other
1406         // package that redefines command of amsmath because mhchem loads amlatex
1407         // (this info is from the author of mhchem from June 2013)
1408         if (mustProvide("mhchem") &&
1409             params_.use_package("mhchem") != BufferParams::package_off)
1410                 packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
1411                             "\\usepackage{mhchem}\n";
1412
1413         // wasysym is a simple feature, but it must be after amsmath if both
1414         // are used
1415         // wasysym redefines some integrals (e.g. iint) from amsmath. That
1416         // leads to inconsistent integrals. We only load this package if
1417         // the document does not contain integrals (then isRequired("esint")
1418         // is false) or if esint is used, since esint redefines all relevant
1419         // integral symbols from wasysym and amsmath.
1420         // See http://www.lyx.org/trac/ticket/1942
1421         if (mustProvide("wasysym") &&
1422             params_.use_package("wasysym") != BufferParams::package_off &&
1423             (params_.use_package("esint") != BufferParams::package_off || !isRequired("esint")))
1424                 packages << "\\usepackage{wasysym}\n";
1425
1426         // esint must be after amsmath (and packages requiring amsmath, like mhchem)
1427         // and wasysym, since it will redeclare inconsistent integral symbols
1428         if (mustProvide("esint") &&
1429             params_.use_package("esint") != BufferParams::package_off)
1430                 packages << "\\usepackage{esint}\n";
1431
1432         // Known bibliography packages (simple \usepackage{package})
1433         for (char const * feature : bibliofeatures) {
1434                 if (mustProvide(feature))
1435                         packages << "\\usepackage{" << feature << "}\n";
1436         }
1437
1438         // Compatibility between achicago and natbib
1439         if (mustProvide("achicago") && mustProvide("natbib"))
1440                 packages << "\\let\\achicagobib\\thebibliography\n";
1441
1442         // natbib.sty
1443         // Some classes load natbib themselves, but still allow (or even require)
1444         // plain numeric citations (ReVTeX is such a case, see bug 5182).
1445         // This special case is indicated by the "natbib-internal" key.
1446         if (mustProvide("natbib")
1447             && !isProvided("natbib-internal")
1448             && !isProvided("biblatex")
1449             && !isProvided("biblatex-natbib")
1450             && !isProvided("jurabib")) {
1451                 packages << "\\usepackage[";
1452                 if (params_.citeEngineType() == ENGINE_TYPE_NUMERICAL)
1453                         packages << "numbers";
1454                 else
1455                         packages << "authoryear";
1456                 if (!params_.biblio_opts.empty())
1457                         packages << ',' << params_.biblio_opts;
1458                 packages << "]{natbib}\n";
1459         }
1460
1461         // Compatibility between achicago and natbib
1462         if (mustProvide("achicago") && mustProvide("natbib")) {
1463                 packages << "\\let\\thebibliography\\achicagobib\n";
1464                 packages << "\\let\\SCcite\\astroncite\n";
1465                 packages << "\\let\\UnexpandableProtect\\protect\n";
1466         }
1467
1468         // jurabib -- we need version 0.6 at least.
1469         if (mustProvide("jurabib")
1470             && !isProvided("natbib-internal")
1471             && !isProvided("natbib")
1472             && !isProvided("biblatex")
1473             && !isProvided("biblatex-natbib")) {
1474                 packages << "\\usepackage";
1475                 if (!params_.biblio_opts.empty())
1476                         packages << '[' << params_.biblio_opts << ']';
1477                 packages << "{jurabib}[2004/01/25]\n";
1478         }
1479
1480         // opcit -- we pass custombst as we output \bibliographystyle ourselves
1481         if (mustProvide("opcit")) {
1482                 if (isRequired("hyperref"))
1483                         packages << "\\usepackage[custombst,hyperref]{opcit}\n";
1484                 else
1485                         packages << "\\usepackage[custombst]{opcit}\n";
1486         }
1487
1488         // xargs -- we need version 1.09 at least
1489         if (mustProvide("xargs"))
1490                 packages << "\\usepackage{xargs}[2008/03/08]\n";
1491
1492         if (mustProvide("xy"))
1493                 packages << "\\usepackage[all]{xy}\n";
1494
1495         if (mustProvide("feyn"))
1496                 packages << "\\usepackage{feyn}\n"; //Diagram
1497
1498         if (mustProvide("ulem"))
1499                 packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
1500                             "\\usepackage{ulem}\n";
1501
1502         if (mustProvide("nomencl")) {
1503                 // Make it work with the new and old version of the package,
1504                 // but don't use the compatibility option since it is
1505                 // incompatible to other packages.
1506                 packages << "\\usepackage{nomencl}\n"
1507                             "% the following is useful when we have the old nomencl.sty package\n"
1508                             "\\providecommand{\\printnomenclature}{\\printglossary}\n"
1509                             "\\providecommand{\\makenomenclature}{\\makeglossary}\n"
1510                             "\\makenomenclature\n";
1511         }
1512
1513         // fixltx2e provides subscript
1514         if (mustProvide("subscript") && !isRequired("fixltx2e"))
1515                 packages << "\\usepackage{subscript}\n";
1516
1517         // footmisc must be loaded after setspace
1518         // Set options here, load the package after the user preamble to
1519         // avoid problems with manual loaded footmisc.
1520         if (mustProvide("footmisc"))
1521                 packages << "\\PassOptionsToPackage{stable}{footmisc}\n";
1522
1523         if (mustProvide("microtype")){
1524                 packages << "\\usepackage{microtype}\n";
1525         }
1526
1527         return packages.str();
1528 }
1529
1530
1531 TexString LaTeXFeatures::getMacros() const
1532 {
1533         otexstringstream macros;
1534
1535         if (!preamble_snippets_.empty()) {
1536                 macros << '\n';
1537                 macros << getPreambleSnippets();
1538         }
1539
1540         if (mustProvide("xetexdashbreakstate"))
1541                 macros << "\\XeTeXdashbreakstate 0" << '\n';
1542
1543         if (mustProvide("papersize")) {
1544                 if (runparams_.flavor == Flavor::LaTeX
1545                     || runparams_.flavor == Flavor::DviLuaTeX)
1546                         macros << papersizedvi_def << '\n';
1547                 else if  (runparams_.flavor == Flavor::LuaTeX)
1548                         macros << papersizepdflua_def << '\n';
1549                 else
1550                         macros << papersizepdf_def << '\n';
1551         }
1552
1553         if (mustProvide("LyX")) {
1554                 macros << "\\providecommand{\\LyX}";
1555                 // open conditional wrappers
1556                 if (runparams_.use_polyglossia && hasRTLLanguage())
1557                         macros << "{\\@ensure@LTR";
1558                 if (isRequired("hyperref"))
1559                         macros << "{\\texorpdfstring";
1560                 if (useBabel())
1561                         macros << "{\\ensureascii";
1562                 // main definition
1563                 macros << lyx_def;
1564                 // close conditional wrappers
1565                 if (useBabel())
1566                         macros << '}';
1567                 if (isRequired("hyperref"))
1568                         macros << "{LyX}}";
1569                 if (runparams_.use_polyglossia && hasRTLLanguage())
1570                         macros << '}';
1571                 macros << '\n';
1572         }
1573
1574         if (mustProvide("noun"))
1575                 macros << noun_def << '\n';
1576
1577         if (mustProvide("lyxarrow"))
1578                 macros << lyxarrow_def << '\n';
1579
1580         if (mustProvide("aastex_case"))
1581                 macros << aastex_case_def << '\n';
1582
1583         if (mustProvide("lyxzerowidthspace"))
1584                 macros << lyxZWSP_def << '\n';
1585
1586         if (!usePolyglossia() && mustProvide("textgreek")) {
1587             // ensure LGR font encoding is defined also if fontenc is not loaded by LyX
1588                 if (params_.main_font_encoding() == "default")
1589                         macros << textgreek_LGR_def;
1590                 macros << textgreek_def << '\n';
1591         }
1592
1593         if (!usePolyglossia() && mustProvide("textcyrillic")) {
1594                 // ensure T2A font encoding is set up also if fontenc is not loaded by LyX
1595                 if (params_.main_font_encoding() == "default")
1596                         macros << textcyr_T2A_def;
1597                 macros << textcyr_def << '\n';
1598         }
1599
1600         // non-standard text accents:
1601         if (mustProvide("textcommaabove") || mustProvide("textcommaaboveright") ||
1602             mustProvide("textcommabelow") || mustProvide("textbaltic"))
1603                 macros << lyxaccent_def;
1604
1605         if (mustProvide("textcommabelow") || mustProvide("textbaltic"))
1606                 macros << textcommabelow_def << '\n';
1607
1608         if (mustProvide("textcommaabove") || mustProvide("textbaltic"))
1609                 macros << textcommaabove_def << '\n';
1610
1611         if (mustProvide("textcommaaboveright"))
1612                 macros << textcommaaboveright_def << '\n';
1613
1614         if (mustProvide("textbaltic"))
1615                 macros << textbaltic_def << '\n';
1616
1617         if (mustProvide("textschwa"))
1618                 macros << textschwa_def << '\n';
1619
1620         // split-level fractions
1621         if (mustProvide("xfrac") || mustProvide("smallLetterFrac"))
1622                 macros << xfrac_def << '\n';
1623
1624         if (mustProvide("smallLetterFrac"))
1625                 macros << smallLetterFrac_def << '\n';
1626
1627         if (mustProvide("lyxmathsym"))
1628                 macros << lyxmathsym_def << '\n';
1629
1630         if (mustProvide("cedilla"))
1631                 macros << cedilla_def << '\n';
1632
1633         if (mustProvide("subring"))
1634                 macros << subring_def << '\n';
1635
1636         if (mustProvide("subdot"))
1637                 macros << subdot_def << '\n';
1638
1639         if (mustProvide("subhat"))
1640                 macros << subhat_def << '\n';
1641
1642         if (mustProvide("subtilde"))
1643                 macros << subtilde_def << '\n';
1644
1645         if (mustProvide("dacute"))
1646                 macros << dacute_def << '\n';
1647
1648         if (mustProvide("tipasymb"))
1649                 macros << tipasymb_def << '\n';
1650
1651         if (mustProvide("dgrave"))
1652                 macros << dgrave_def << '\n';
1653
1654         if (mustProvide("rcap"))
1655                 macros << rcap_def << '\n';
1656
1657         if (mustProvide("ogonek"))
1658                 macros << ogonek_def << '\n';
1659
1660         // quotes.
1661         if (mustProvide("quotesinglbase"))
1662                 macros << quotesinglbase_def << '\n';
1663         if (mustProvide("quotedblbase"))
1664                 macros << quotedblbase_def << '\n';
1665         if (mustProvide("guilsinglleft"))
1666                 macros << guilsinglleft_def << '\n';
1667         if (mustProvide("guilsinglright"))
1668                 macros << guilsinglright_def << '\n';
1669         if (mustProvide("guillemotleft"))
1670                 macros << guillemotleft_def << '\n';
1671         if (mustProvide("guillemotright"))
1672                 macros << guillemotright_def << '\n';
1673         if (mustProvide("textquotedbl"))
1674                 macros << textquotedbl_def << '\n';
1675         if (mustProvide("textquotesinglep")) {
1676                 if (runparams_.flavor == Flavor::XeTeX)
1677                         macros << textquotesinglep_xetex_def << '\n';
1678                 else
1679                         macros << textquotesinglep_luatex_def << '\n';
1680         }
1681         if (mustProvide("textquotedblp")) {
1682                 if (runparams_.flavor == Flavor::XeTeX)
1683                         macros << textquotedblp_xetex_def << '\n';
1684                 else
1685                         macros << textquotedblp_luatex_def << '\n';
1686         }
1687
1688         // Math mode
1689         if (mustProvide("binom") && !isRequired("amsmath"))
1690                 macros << binom_def << '\n';
1691         if (mustProvide("mathcircumflex"))
1692                 macros << mathcircumflex_def << '\n';
1693
1694         // other
1695         if (mustProvide("ParagraphLeftIndent"))
1696                 macros << paragraphleftindent_def;
1697         if (mustProvide("NeedLyXFootnoteCode"))
1698                 macros << floatingfootnote_def;
1699
1700         // some problems with tex->html converters
1701         if (mustProvide("NeedTabularnewline"))
1702                 macros << tabularnewline_def;
1703
1704         if (mustProvide("cellvarwidth"))
1705                 macros << cellvarwidth_def;
1706
1707         // greyed-out environment (note inset)
1708         // the color is specified in the routine
1709         // getColorOptions() to avoid LaTeX-package clashes
1710         if (mustProvide("lyxgreyedout"))
1711                 // We need different version for RTL (#8647), with change tracking (#12025)
1712                 // and for some specific engine/language package combinations
1713                 macros << lyxgreyedoutDef(hasRTLLanguage(), mustProvide("ct-xcolor-ulem"),
1714                                           (runparams_.flavor == Flavor::LuaTeX), useBabel());
1715
1716         if (mustProvide("lyxdot"))
1717                 macros << lyxdot_def << '\n';
1718
1719         // floats
1720         getFloatDefinitions(macros);
1721
1722         if (mustProvide("refstyle"))
1723                 macros << lyxref_def << '\n';
1724
1725         // change tracking
1726         if (mustProvide("ct-xcolor-ulem")) {
1727                 streamsize const prec = macros.os().precision(2);
1728
1729                 RGBColor cadd = rgbFromHexName(lcolor.getX11HexName(Color_addedtext));
1730                 macros << "\\providecolor{lyxadded}{rgb}{"
1731                        << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
1732
1733                 RGBColor cdel = rgbFromHexName(lcolor.getX11HexName(Color_deletedtext));
1734                 macros << "\\providecolor{lyxdeleted}{rgb}{"
1735                        << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
1736
1737                 macros.os().precision(prec);
1738
1739                 macros << changetracking_xcolor_ulem_base_def;
1740
1741                 if (isRequired("changebar")) {
1742                         if (isRequired("hyperref"))
1743                                 macros << changetracking_xcolor_ulem_hyperref_cb_def;
1744                         else
1745                                 macros << changetracking_xcolor_ulem_cb_def;
1746                 } else {
1747                         if (isRequired("hyperref"))
1748                                 macros << changetracking_xcolor_ulem_hyperref_def;
1749                         else
1750                                 macros << changetracking_xcolor_ulem_def;
1751                 }
1752         }
1753
1754         if (mustProvide("ct-tikz-object-sout")) {
1755                 if (!mustProvide("ct-xcolor-ulem")) {
1756                         streamsize const prec = macros.os().precision(2);
1757
1758                         RGBColor cadd = rgbFromHexName(lcolor.getX11HexName(Color_addedtext));
1759                         macros << "\\providecolor{lyxadded}{rgb}{"
1760                                << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
1761
1762                         RGBColor cdel = rgbFromHexName(lcolor.getX11HexName(Color_deletedtext));
1763                         macros << "\\providecolor{lyxdeleted}{rgb}{"
1764                                << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
1765
1766                         macros.os().precision(prec);
1767                 }
1768
1769                 macros << changetracking_tikz_object_sout_def;
1770
1771                 if (isRequired("changebar")) {
1772                         if (isRequired("hyperref"))
1773                                 macros << changetracking_xcolor_ulem_hyperref_cb_object_def;
1774                         else
1775                                 macros << changetracking_xcolor_ulem_cb_object_def;
1776                 } else {
1777                         if (isRequired("hyperref"))
1778                                 macros << changetracking_xcolor_ulem_hyperref_object_def;
1779                         else
1780                                 macros << changetracking_xcolor_ulem_object_def;
1781                 }
1782         }
1783
1784         if (mustProvide("ct-none"))
1785                 macros << changetracking_none_def;
1786
1787         if (mustProvide("rtloutputdblcol"))
1788                 macros << rtloutputdblcol_def;
1789
1790         if (mustProvide("lyxmintcaption"))
1791                 macros << lyxmintcaption_def;
1792
1793         return macros.release();
1794 }
1795
1796
1797 docstring const LaTeXFeatures::getBabelPresettings() const
1798 {
1799         odocstringstream tmp;
1800
1801         for (auto const & lang : UsedLanguages_)
1802                 if (!lang->babel_presettings().empty())
1803                         tmp << lang->babel_presettings() << '\n';
1804         if (!params_.language->babel_presettings().empty())
1805                 tmp << params_.language->babel_presettings() << '\n';
1806
1807         if (!contains(tmp.str(), '@'))
1808                 return tmp.str();
1809
1810         return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
1811 }
1812
1813
1814 docstring const LaTeXFeatures::getBabelPostsettings() const
1815 {
1816         odocstringstream tmp;
1817
1818         for (auto const & lang : UsedLanguages_)
1819                 if (!lang->babel_postsettings().empty())
1820                         tmp << lang->babel_postsettings() << '\n';
1821         if (!params_.language->babel_postsettings().empty())
1822                 tmp << params_.language->babel_postsettings() << '\n';
1823
1824         if (!contains(tmp.str(), '@'))
1825                 return tmp.str();
1826
1827         return "\\makeatletter\n" + tmp.str() + "\\makeatother\n";
1828 }
1829
1830
1831 string const LaTeXFeatures::loadAMSPackages() const
1832 {
1833         ostringstream tmp;
1834
1835         if (mustProvide("amsmath")
1836             && params_.use_package("amsmath") != BufferParams::package_off) {
1837                 tmp << "\\usepackage{amsmath}\n";
1838         } else {
1839                 // amsbsy and amstext are already provided by amsmath
1840                 if (mustProvide("amsbsy"))
1841                         tmp << "\\usepackage{amsbsy}\n";
1842                 if (mustProvide("amstext"))
1843                         tmp << "\\usepackage{amstext}\n";
1844         }
1845
1846         if (mustProvide("amsthm"))
1847                 tmp << "\\usepackage{amsthm}\n";
1848
1849         if (mustProvide("amssymb")
1850             && params_.use_package("amssymb") != BufferParams::package_off)
1851                 tmp << "\\usepackage{amssymb}\n";
1852
1853         return tmp.str();
1854 }
1855
1856
1857 docstring const LaTeXFeatures::getTClassPreamble() const
1858 {
1859         // the text class specific preamble
1860         DocumentClass const & tclass = params_.documentClass();
1861         odocstringstream tcpreamble;
1862
1863         tcpreamble << tclass.preamble();
1864
1865         list<docstring>::const_iterator cit = usedLayouts_.begin();
1866         list<docstring>::const_iterator end = usedLayouts_.end();
1867         for (; cit != end; ++cit)
1868                 // For InPreamble layouts, we output the preamble stuff earlier
1869                 // (before the layouts). See Paragraph::Private::validate.
1870                 if (!tclass[*cit].inpreamble)
1871                         tcpreamble << tclass[*cit].preamble();
1872
1873         cit = usedInsetLayouts_.begin();
1874         end = usedInsetLayouts_.end();
1875         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1876         for (; cit != end; ++cit) {
1877                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1878                 if (it == ils.end())
1879                         continue;
1880                 tcpreamble << it->second.preamble();
1881         }
1882
1883         return tcpreamble.str();
1884 }
1885
1886
1887 docstring const LaTeXFeatures::getTClassHTMLPreamble() const
1888 {
1889         DocumentClass const & tclass = params_.documentClass();
1890         odocstringstream tcpreamble;
1891
1892         tcpreamble << tclass.htmlpreamble();
1893
1894         list<docstring>::const_iterator cit = usedLayouts_.begin();
1895         list<docstring>::const_iterator end = usedLayouts_.end();
1896         for (; cit != end; ++cit)
1897                 tcpreamble << tclass[*cit].htmlpreamble();
1898
1899         cit = usedInsetLayouts_.begin();
1900         end = usedInsetLayouts_.end();
1901         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1902         for (; cit != end; ++cit) {
1903                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1904                 if (it == ils.end())
1905                         continue;
1906                 tcpreamble << it->second.htmlpreamble();
1907         }
1908
1909         return tcpreamble.str();
1910 }
1911
1912
1913 docstring const LaTeXFeatures::getTClassHTMLStyles() const
1914 {
1915         DocumentClass const & tclass = params_.documentClass();
1916         odocstringstream tcpreamble;
1917
1918         if (mustProvide("noun"))
1919                 tcpreamble << lyxnoun_style;
1920         // this isn't exact, but it won't hurt that much if it
1921         // wasn't for this.
1922         if (mustProvide("ulem"))
1923                 tcpreamble << lyxstrikeout_style;
1924
1925         tcpreamble << tclass.htmlstyles();
1926
1927         list<docstring>::const_iterator cit = usedLayouts_.begin();
1928         list<docstring>::const_iterator end = usedLayouts_.end();
1929         for (; cit != end; ++cit)
1930                 tcpreamble << tclass[*cit].htmlstyle();
1931
1932         cit = usedInsetLayouts_.begin();
1933         end = usedInsetLayouts_.end();
1934         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1935         for (; cit != end; ++cit) {
1936                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1937                 if (it == ils.end())
1938                         continue;
1939                 tcpreamble << it->second.htmlstyle();
1940         }
1941
1942         return tcpreamble.str();
1943 }
1944
1945
1946 namespace {
1947
1948 docstring const getFloatI18nPreamble(docstring const & type,
1949                         docstring const & name, Language const * lang,
1950                         Encoding const & enc, bool const polyglossia)
1951 {
1952         // Check whether name can be encoded in the buffer encoding
1953         bool encodable = true;
1954         for (char_type c : name) {
1955                 if (!enc.encodable(c)) {
1956                         encodable = false;
1957                         break;
1958                 }
1959         }
1960
1961         docstring const language = polyglossia ? from_ascii(lang->polyglossia())
1962                                                : from_ascii(lang->babel());
1963         docstring const langenc = from_ascii(lang->encoding()->iconvName());
1964         docstring const texenc = from_ascii(lang->encoding()->latexName());
1965         docstring const bufenc = from_ascii(enc.iconvName());
1966         docstring const s1 = docstring(1, 0xF0000);
1967         docstring const s2 = docstring(1, 0xF0001);
1968         docstring const translated = encodable ? name
1969                 : from_ascii("\\inputencoding{") + texenc + from_ascii("}")
1970                         + s1 + langenc + s2 + name + s1 + bufenc + s2;
1971
1972         odocstringstream os;
1973         os << "\\addto\\captions" << language
1974            << "{\\renewcommand{\\" << type << "name}{" << translated << "}}\n";
1975         return os.str();
1976 }
1977
1978
1979 docstring const i18npreamble(docstring const & templ, Language const * lang,
1980                              Encoding const & enc, bool const polyglossia,
1981                              bool const need_fixedwidth)
1982 {
1983         if (templ.empty())
1984                 return templ;
1985
1986         string preamble = polyglossia ?
1987                 subst(to_utf8(templ), "$$lang", lang->polyglossia()) :
1988                 subst(to_utf8(templ), "$$lang", lang->babel());
1989
1990         string const langenc = lang->encoding()->iconvName();
1991         string const texenc = lang->encoding()->latexName();
1992         string const bufenc = enc.iconvName();
1993         Encoding const * testenc(&enc);
1994         bool lang_fallback = false;
1995         bool ascii_fallback = false;
1996         if (need_fixedwidth && !enc.hasFixedWidth()) {
1997                 if (lang->encoding()->hasFixedWidth()) {
1998                         testenc = lang->encoding();
1999                         lang_fallback = true;
2000                 } else {
2001                         // We need a fixed width encoding, but both the buffer
2002                         // encoding and the language encoding are variable
2003                         // width. As a last fallback, try to convert to pure
2004                         // ASCII using the LaTeX commands defined in unicodesymbols.
2005                         testenc = encodings.fromLyXName("ascii");
2006                         if (!testenc)
2007                                 return docstring();
2008                         ascii_fallback = true;
2009                 }
2010         }
2011         // First and second character of plane 15 (Private Use Area)
2012         string const s1 = "\xf3\xb0\x80\x80"; // U+F0000
2013         string const s2 = "\xf3\xb0\x80\x81"; // U+F0001
2014         // FIXME UNICODE
2015         // lyx::regex is not unicode-safe.
2016         // Should use QRegExp or (boost::u32regex, but that requires ICU)
2017         static regex const reg("_\\(([^\\)]+)\\)");
2018         smatch sub;
2019         while (regex_search(preamble, sub, reg)) {
2020                 string const key = sub.str(1);
2021                 docstring const name = lang->translateLayout(key);
2022                 // Check whether name can be encoded in the buffer encoding
2023                 bool encodable = true;
2024                 for (size_t i = 0; i < name.size() && encodable; ++i)
2025                         if (!testenc->encodable(name[i]))
2026                                 encodable = false;
2027                 string translated;
2028                 if (encodable && !lang_fallback)
2029                         translated = to_utf8(name);
2030                 else if (ascii_fallback)
2031                         translated = to_ascii(testenc->latexString(name).first);
2032                 else
2033                         translated = "\\inputencoding{" + texenc + "}"
2034                                 + s1 + langenc + s2 + to_utf8(name)
2035                                 + s1 + bufenc + s2;
2036                 preamble = subst(preamble, sub.str(), translated);
2037         }
2038         return from_utf8(preamble);
2039 }
2040
2041 } // namespace
2042
2043
2044 docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel,
2045                                 bool use_polyglossia, bool use_minted) const
2046 {
2047         DocumentClass const & tclass = params_.documentClass();
2048         // collect preamble snippets in a set to prevent multiple identical
2049         // commands (would happen if e.g. both theorem and theorem* are used)
2050         set<docstring> snippets;
2051         typedef LanguageList::const_iterator lang_it;
2052         lang_it const lbeg = UsedLanguages_.begin();
2053         lang_it const lend =  UsedLanguages_.end();
2054         list<docstring>::const_iterator cit = usedLayouts_.begin();
2055         list<docstring>::const_iterator end = usedLayouts_.end();
2056         for (; cit != end; ++cit) {
2057                 // language dependent commands (once per document)
2058                 snippets.insert(i18npreamble(tclass[*cit].langpreamble(),
2059                                                 buffer().language(),
2060                                                 buffer().params().encoding(),
2061                                                 use_polyglossia, false));
2062                 // commands for language changing (for multilanguage documents)
2063                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2064                         snippets.insert(i18npreamble(
2065                                                 tclass[*cit].babelpreamble(),
2066                                                 buffer().language(),
2067                                                 buffer().params().encoding(),
2068                                                 use_polyglossia, false));
2069                         for (lang_it lit = lbeg; lit != lend; ++lit)
2070                                 snippets.insert(i18npreamble(
2071                                                 tclass[*cit].babelpreamble(),
2072                                                 *lit,
2073                                                 buffer().params().encoding(),
2074                                                 use_polyglossia, false));
2075                 }
2076         }
2077         if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2078                 FloatList const & floats = params_.documentClass().floats();
2079                 UsedFloats::const_iterator fit = usedFloats_.begin();
2080                 UsedFloats::const_iterator fend = usedFloats_.end();
2081                 for (; fit != fend; ++fit) {
2082                         Floating const & fl = floats.getType(fit->first);
2083                         // we assume builtin floats are translated
2084                         if (fl.isPredefined())
2085                                 continue;
2086                         docstring const type = from_ascii(fl.floattype());
2087                         docstring const flname = from_utf8(fl.name());
2088                         docstring name = buffer().language()->translateLayout(fl.name());
2089                         // only request translation if we have a real translation
2090                         // (that differs from the source)
2091                         if (flname != name)
2092                                 snippets.insert(getFloatI18nPreamble(
2093                                                 type, name, buffer().language(),
2094                                                 buffer().params().encoding(),
2095                                                 use_polyglossia));
2096                         for (lang_it lit = lbeg; lit != lend; ++lit) {
2097                                 string const code = (*lit)->code();
2098                                 name = (*lit)->translateLayout(fl.name());
2099                                 // we assume we have a suitable translation if
2100                                 // either the language is English (we need to
2101                                 // translate into English if English is a secondary
2102                                 // language) or if translateIfPossible returns
2103                                 // something different to the English source.
2104                                 bool const have_translation =
2105                                         (flname != name || contains(code, "en"));
2106                                 if (have_translation)
2107                                         snippets.insert(getFloatI18nPreamble(
2108                                                 type, name, *lit,
2109                                                 buffer().params().encoding(),
2110                                                 use_polyglossia));
2111                         }
2112                 }
2113         }
2114
2115         cit = usedInsetLayouts_.begin();
2116         end = usedInsetLayouts_.end();
2117         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
2118         for (; cit != end; ++cit) {
2119                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
2120                 if (it == ils.end())
2121                         continue;
2122                 // The listings package does not work with variable width
2123                 // encodings, only with fixed width encodings. Therefore we
2124                 // need to force a fixed width encoding for
2125                 // \lstlistlistingname and \lstlistingname (bug 9382).
2126                 // This needs to be consistent with InsetListings::latex()
2127                 // rsp. InsetListings::forcedEncoding().
2128                 bool const need_fixedwidth = !use_minted &&
2129                                         !runparams_.isFullUnicode() &&
2130                                         buffer().params().encoding().package() != Encoding::japanese &&
2131                                         it->second.fixedwidthpreambleencoding();
2132                 // language dependent commands (once per document)
2133                 snippets.insert(i18npreamble(it->second.langpreamble(),
2134                                                 buffer().language(),
2135                                                 buffer().params().encoding(),
2136                                                 use_polyglossia, need_fixedwidth));
2137                 // commands for language changing (for multilanguage documents)
2138                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
2139                         snippets.insert(i18npreamble(
2140                                                 it->second.babelpreamble(),
2141                                                 buffer().language(),
2142                                                 buffer().params().encoding(),
2143                                                 use_polyglossia, need_fixedwidth));
2144                         for (lang_it lit = lbeg; lit != lend; ++lit)
2145                                 snippets.insert(i18npreamble(
2146                                                 it->second.babelpreamble(),
2147                                                 *lit,
2148                                                 buffer().params().encoding(),
2149                                                 use_polyglossia, need_fixedwidth));
2150                 }
2151         }
2152
2153         odocstringstream tcpreamble;
2154         set<docstring>::const_iterator const send = snippets.end();
2155         set<docstring>::const_iterator it = snippets.begin();
2156         for (; it != send; ++it)
2157                 tcpreamble << *it;
2158         return tcpreamble.str();
2159 }
2160
2161
2162 docstring const LaTeXFeatures::getLyXSGMLEntities() const
2163 {
2164         // Definition of entities used in the document that are LyX related.
2165         odocstringstream entities;
2166
2167         if (mustProvide("lyxarrow")) {
2168                 entities << "<!ENTITY lyxarrow \"-&gt;\">" << '\n';
2169         }
2170
2171         return entities.str();
2172 }
2173
2174
2175 docstring const LaTeXFeatures::getIncludedFiles(string const & fname) const
2176 {
2177         odocstringstream sgmlpreamble;
2178         // FIXME UNICODE
2179         docstring const basename(from_utf8(onlyPath(fname)));
2180
2181         FileMap::const_iterator end = IncludedFiles_.end();
2182         for (FileMap::const_iterator fi = IncludedFiles_.begin();
2183              fi != end; ++fi)
2184                 // FIXME UNICODE
2185                 sgmlpreamble << "\n<!ENTITY " << fi->first
2186                              << (isSGMLFileName(fi->second) ? " SYSTEM \"" : " \"")
2187                              << makeRelPath(from_utf8(fi->second), basename) << "\">";
2188
2189         return sgmlpreamble.str();
2190 }
2191
2192
2193 void LaTeXFeatures::showStruct() const
2194 {
2195         lyxerr << "LyX needs the following commands when LaTeXing:"
2196                << "\n***** Packages:" << getPackages()
2197                << "\n***** Macros:" << to_utf8(getMacros().str)
2198                << "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
2199                << "\n***** done." << endl;
2200 }
2201
2202
2203 Buffer const & LaTeXFeatures::buffer() const
2204 {
2205         return *buffer_;
2206 }
2207
2208
2209 void LaTeXFeatures::setBuffer(Buffer const & buffer)
2210 {
2211         buffer_ = &buffer;
2212 }
2213
2214
2215 BufferParams const & LaTeXFeatures::bufferParams() const
2216 {
2217         return params_;
2218 }
2219
2220
2221 void LaTeXFeatures::getFloatDefinitions(otexstream & os) const
2222 {
2223         FloatList const & floats = params_.documentClass().floats();
2224
2225         // Here we will output the code to create the needed float styles.
2226         // We will try to do this as minimal as possible.
2227         // \floatstyle{ruled}
2228         // \newfloat{algorithm}{htbp}{loa}
2229         // \providecommand{\algorithmname}{Algorithm}
2230         // \floatname{algorithm}{\protect\algorithmname}
2231         for (auto const & cit : usedFloats_) {
2232                 Floating const & fl = floats.getType(cit.first);
2233
2234                 // For builtin floats we do nothing.
2235                 if (fl.isPredefined())
2236                         continue;
2237
2238                 // We have to special case "table" and "figure"
2239                 if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
2240                         // Output code to modify "table" or "figure"
2241                         // but only if builtin == false
2242                         // and that have to be true at this point in the
2243                         // function.
2244                         docstring const type = from_ascii(fl.floattype());
2245                         docstring const placement = from_ascii(fl.placement());
2246                         docstring const style = from_ascii(fl.style());
2247                         if (!style.empty()) {
2248                                 os << "\\floatstyle{" << style << "}\n"
2249                                    << "\\restylefloat{" << type << "}\n";
2250                         }
2251                         if (!placement.empty()) {
2252                                 os << "\\floatplacement{" << type << "}{"
2253                                    << placement << "}\n";
2254                         }
2255                 } else {
2256                         // The other non builtin floats.
2257
2258                         docstring const type = from_ascii(fl.floattype());
2259                         docstring const placement = from_ascii(fl.placement());
2260                         docstring const ext = from_ascii(fl.ext());
2261                         docstring const within = from_ascii(fl.within());
2262                         docstring const style = from_ascii(fl.style());
2263                         docstring const name =
2264                                 buffer().language()->translateLayout(fl.name());
2265                         os << "\\floatstyle{" << style << "}\n"
2266                            << "\\newfloat{" << type << "}{" << placement
2267                            << "}{" << ext << '}';
2268                         if (!within.empty())
2269                                 os << '[' << within << ']';
2270                         os << '\n'
2271                            << "\\providecommand{\\" << type << "name}{"
2272                            << name << "}\n"
2273                            << "\\floatname{" << type << "}{\\protect\\"
2274                            << type << "name}\n";
2275
2276                         // What missing here is to code to minimalize the code
2277                         // output so that the same floatstyle will not be
2278                         // used several times, when the same style is still in
2279                         // effect. (Lgb)
2280                 }
2281                 if (cit.second)
2282                         // The subfig package is loaded later
2283                         os << "\n\\AtBeginDocument{\\newsubfloat{" << from_ascii(fl.floattype()) << "}}\n";
2284         }
2285 }
2286
2287
2288 void LaTeXFeatures::resolveAlternatives()
2289 {
2290         for (Features::iterator it = features_.begin(); it != features_.end();) {
2291                 if (contains(*it, '|')) {
2292                         vector<string> const alternatives = getVectorFromString(*it, "|");
2293                         vector<string>::const_iterator const end = alternatives.end();
2294                         vector<string>::const_iterator ita = alternatives.begin();
2295                         // Is any alternative already required? => use that
2296                         for (; ita != end; ++ita) {
2297                                 if (isRequired(*ita))
2298                                         break;
2299                         }
2300                         // Is any alternative available? => use the first one
2301                         // (bug 9498)
2302                         if (ita == end) {
2303                                 for (ita = alternatives.begin(); ita != end; ++ita) {
2304                                         if (isAvailable(*ita)) {
2305                                                 require(*ita);
2306                                                 break;
2307                                         }
2308                                 }
2309                         }
2310                         // This will not work, but not requiring something
2311                         // would be more confusing
2312                         if (ita == end)
2313                                 require(alternatives.front());
2314                         features_.erase(it);
2315                         it = features_.begin();
2316                 } else
2317                         ++it;
2318         }
2319 }
2320
2321
2322 void LaTeXFeatures::expandMultiples()
2323 {
2324         for (Features::iterator it = features_.begin(); it != features_.end();) {
2325                 if (contains(*it, ',')) {
2326                         // Do nothing if any multiple is already required
2327                         for (string const & pkg : getVectorFromString(*it, ",")) {
2328                                 if (!isRequired(pkg))
2329                                         require(pkg);
2330                         }
2331                         features_.erase(it);
2332                         it = features_.begin();
2333                 } else
2334                         ++it;
2335         }
2336 }
2337
2338
2339 } // namespace lyx