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 "LaTeXPackages.h"
  28 #include "Layout.h"
  29 #include "Lexer.h"
  30 #include "LyXRC.h"
  31 #include "TextClass.h"
  32
  33 #include "insets/InsetLayout.h"
  34
  35 #include "support/debug.h"
  36 #include "support/docstream.h"
  37 #include "support/FileName.h"
  38 #include "support/filetools.h"
  39 #include "support/gettext.h"
  40 #include "support/lstrings.h"
  41
  42 #include <algorithm>
  43
  44
  45 using namespace std;
  46 using namespace lyx::support;
  47
  48
  49 namespace lyx {
  50
  51 /////////////////////////////////////////////////////////////////////
  52 //
  53 // Strings
  54 //
  55 /////////////////////////////////////////////////////////////////////
  56
  57 //\NeedsTeXFormat{LaTeX2e}
  58 //\ProvidesPackage{lyx}[1996/01/11 LLE v0.2 (LyX LaTeX Extensions)]
  59 //\message{LyX LaTeX Extensions (LLE v0.2) of 11-Jan-1996.}
  60
  61 static docstring const lyx_def = from_ascii(
  62         "\\providecommand{\\LyX}{L\\kern-.1667em\\lower.25em\\hbox{Y}\\kern-.125emX\\@}");
  63
  64 static docstring const lyx_hyperref_def = from_ascii(
  65         "\\providecommand{\\LyX}{\\texorpdfstring%\n"
  66         "  {L\\kern-.1667em\\lower.25em\\hbox{Y}\\kern-.125emX\\@}\n"
  67         "  {LyX}}");
  68
  69 static docstring const noun_def = from_ascii(
  70         "\\newcommand{\\noun}[1]{\\textsc{#1}}");
  71
  72 static docstring const lyxarrow_def = from_ascii(
  73         "\\DeclareRobustCommand*{\\lyxarrow}{%\n"
  74         "\\@ifstar\n"
  75         "{\\leavevmode\\,$\\triangleleft$\\,\\allowbreak}\n"
  76         "{\\leavevmode\\,$\\triangleright$\\,\\allowbreak}}");
  77
  78 // for quotes without babel. This does not give perfect results, but
  79 // anybody serious about non-english quotes should use babel (JMarc).
  80
  81 static docstring const quotedblbase_def = from_ascii(
  82         "\\ProvideTextCommandDefault{\\quotedblbase}{%\n"
  83         "  \\raisebox{-1.4ex}[1ex][.5ex]{\\textquotedblright}%\n"
  84         "  \\penalty10000\\hskip0em\\relax%\n"
  85         "}");
  86
  87 static docstring const quotesinglbase_def = from_ascii(
  88         "\\ProvideTextCommandDefault{\\quotesinglbase}{%\n"
  89         "  \\raisebox{-1.4ex}[1ex][.5ex]{\\textquoteright}%\n"
  90         "  \\penalty10000\\hskip0em\\relax%\n"
  91         "}");
  92
  93 static docstring const guillemotleft_def = from_ascii(
  94         "\\ProvideTextCommandDefault{\\guillemotleft}{%\n"
  95         "  {\\usefont{U}{lasy}{m}{n}\\char'50\\kern-.15em\\char'50}%\n"
  96         "\\penalty10000\\hskip0pt\\relax%\n"
  97         "}");
  98
  99 static docstring const guillemotright_def = from_ascii(
 100         "\\ProvideTextCommandDefault{\\guillemotright}{%\n"
 101         "  \\penalty10000\\hskip0pt%\n"
 102         "  {\\usefont{U}{lasy}{m}{n}\\char'51\\kern-.15em\\char'51}%\n"
 103         "}");
 104
 105 static docstring const guilsinglleft_def = from_ascii(
 106         "\\ProvideTextCommandDefault{\\guilsinglleft}{%\n"
 107         "  {\\usefont{U}{lasy}{m}{n}\\char'50}%\n"
 108         "  \\penalty10000\\hskip0pt\\relax%\n"
 109         "}");
 110
 111 static docstring const guilsinglright_def = from_ascii(
 112         "\\ProvideTextCommandDefault{\\guilsinglright}{%\n"
 113         "  \\penalty10000\\hskip0pt%\n"
 114         "  {\\usefont{U}{lasy}{m}{n}\\char'51}%\n"
 115         "}");
 116
 117 static docstring const paragraphleftindent_def = from_ascii(
 118         "\\newenvironment{LyXParagraphLeftIndent}[1]%\n"
 119         "{\n"
 120         "  \\begin{list}{}{%\n"
 121         "    \\setlength{\\topsep}{0pt}%\n"
 122         "    \\addtolength{\\leftmargin}{#1}\n"
 123 // ho hum, yet more things commented out with no hint as to why they
 124 // weren't just removed
 125 //      "%%    \\addtolength{\\leftmargin}{#1\\textwidth}\n"
 126 //      "%%    \\setlength{\\textwidth}{#2\\textwidth}\n"
 127 //      "%%    \\setlength\\listparindent\\parindent%\n"
 128 //      "%%    \\setlength\\itemindent\\parindent%\n"
 129         "    \\setlength{\\parsep}{0pt plus 1pt}%\n"
 130         "  }\n"
 131         "  \\item[]\n"
 132         "}\n"
 133         "{\\end{list}}\n");
 134
 135 static docstring const floatingfootnote_def = from_ascii(
 136         "%% Special footnote code from the package 'stblftnt.sty'\n"
 137         "%% Author: Robin Fairbairns -- Last revised Dec 13 1996\n"
 138         "\\let\\SF@@footnote\\footnote\n"
 139         "\\def\\footnote{\\ifx\\protect\\@typeset@protect\n"
 140         "    \\expandafter\\SF@@footnote\n"
 141         "  \\else\n"
 142         "    \\expandafter\\SF@gobble@opt\n"
 143         "  \\fi\n"
 144         "}\n"
 145         "\\expandafter\\def\\csname SF@gobble@opt \\endcsname{\\@ifnextchar[%]\n"
 146         "  \\SF@gobble@twobracket\n"
 147         "  \\@gobble\n"
 148         "}\n"
 149         "\\edef\\SF@gobble@opt{\\noexpand\\protect\n"
 150         "  \\expandafter\\noexpand\\csname SF@gobble@opt \\endcsname}\n"
 151         "\\def\\SF@gobble@twobracket[#1]#2{}\n");
 152
 153 static docstring const binom_def = from_ascii(
 154         "%% Binom macro for standard LaTeX users\n"
 155         "\\newcommand{\\binom}[2]{{#1 \\choose #2}}\n");
 156
 157 static docstring const mathcircumflex_def = from_ascii(
 158         "%% For printing a cirumflex inside a formula\n"
 159         "\\newcommand{\\mathcircumflex}[0]{\\mbox{\\^{}}}\n");
 160
 161 static docstring const tabularnewline_def = from_ascii(
 162         "%% Because html converters don't know tabularnewline\n"
 163         "\\providecommand{\\tabularnewline}{\\\\}\n");
 164
 165 static docstring const lyxgreyedout_def = from_ascii(
 166         "%% The greyedout annotation environment\n"
 167         "\\newenvironment{lyxgreyedout}\n"
 168         "  {\\textcolor{note_fontcolor}\\bgroup\\ignorespaces}\n"
 169         "  {\\ignorespacesafterend\\egroup}\n");
 170
 171 // We want to omit the file extension for includegraphics, but this does not
 172 // work when the filename contains other dots.
 173 // Idea from http://www.tex.ac.uk/cgi-bin/texfaq2html?label=unkgrfextn
 174 static docstring const lyxdot_def = from_ascii(
 175         "%% A simple dot to overcome graphicx limitations\n"
 176         "\\newcommand{\\lyxdot}{.}\n");
 177
 178 static docstring const changetracking_dvipost_def = from_ascii(
 179         "%% Change tracking with dvipost\n"
 180         "\\dvipostlayout\n"
 181         "\\dvipost{osstart color push Red}\n"
 182         "\\dvipost{osend color pop}\n"
 183         "\\dvipost{cbstart color push Blue}\n"
 184         "\\dvipost{cbend color pop}\n"
 185         "\\newcommand{\\lyxadded}[3]{\\changestart#3\\changeend}\n"
 186         "\\newcommand{\\lyxdeleted}[3]{%\n"
 187         "\\changestart\\overstrikeon#3\\overstrikeoff\\changeend}\n");
 188
 189 static docstring const changetracking_xcolor_ulem_def = from_ascii(
 190         "%% Change tracking with ulem\n"
 191         "\\newcommand{\\lyxadded}[3]{{\\color{lyxadded}{}#3}}\n"
 192         "\\newcommand{\\lyxdeleted}[3]{{\\color{lyxdeleted}\\sout{#3}}}\n");
 193
 194 static docstring const changetracking_xcolor_ulem_hyperref_def = from_ascii(
 195         "%% Change tracking with ulem\n"
 196         "\\newcommand{\\lyxadded}[3]{{\\texorpdfstring{\\color{lyxadded}{}}{}#3}}\n"
 197         "\\newcommand{\\lyxdeleted}[3]{{\\texorpdfstring{\\color{lyxdeleted}\\sout{#3}}{}}}\n");
 198
 199 static docstring const changetracking_none_def = from_ascii(
 200         "\\newcommand{\\lyxadded}[3]{#3}\n"
 201         "\\newcommand{\\lyxdeleted}[3]{}\n");
 202
 203 static docstring const textgreek_def = from_ascii(
 204         "\\DeclareRobustCommand{\\greektext}{%\n"
 205         "  \\fontencoding{LGR}\\selectfont\\def\\encodingdefault{LGR}}\n"
 206         "\\DeclareRobustCommand{\\textgreek}[1]{\\leavevmode{\\greektext #1}}\n"
 207         "\\DeclareFontEncoding{LGR}{}{}\n"
 208         "\\DeclareTextSymbol{\\~}{LGR}{126}");
 209
 210 static docstring const textcyr_def = from_ascii(
 211         "\\DeclareRobustCommand{\\cyrtext}{%\n"
 212         "  \\fontencoding{T2A}\\selectfont\\def\\encodingdefault{T2A}}\n"
 213         "\\DeclareRobustCommand{\\textcyr}[1]{\\leavevmode{\\cyrtext #1}}\n"
 214         "\\AtBeginDocument{\\DeclareFontEncoding{T2A}{}{}}\n");
 215
 216 static docstring const lyxmathsym_def = from_ascii(
 217         "\\newcommand{\\lyxmathsym}[1]{\\ifmmode\\begingroup\\def\\b@ld{bold}\n"
 218         "  \\text{\\ifx\\math@version\\b@ld\\bfseries\\fi#1}\\endgroup\\else#1\\fi}\n");
 219
 220 static docstring const papersizedvi_def = from_ascii(
 221         "\\special{papersize=\\the\\paperwidth,\\the\\paperheight}\n");
 222
 223 static docstring const papersizepdf_def = from_ascii(
 224         "\\pdfpageheight\\paperheight\n"
 225         "\\pdfpagewidth\\paperwidth\n");
 226
 227 static docstring const cedilla_def = from_ascii(
 228         "\\newcommand{\\docedilla}[2]{\\underaccent{#1\\mathchar'30}{#2}}\n"
 229         "\\newcommand{\\cedilla}[1]{\\mathpalette\\docedilla{#1}}\n");
 230
 231 static docstring const subring_def = from_ascii(
 232         "\\newcommand{\\dosubring}[2]{\\underaccent{#1\\mathchar'27}{#2}}\n"
 233         "\\newcommand{\\subring}[1]{\\mathpalette\\dosubring{#1}}\n");
 234
 235 static docstring const subdot_def = from_ascii(
 236         "\\newcommand{\\dosubdot}[2]{\\underaccent{#1.}{#2}}\n"
 237         "\\newcommand{\\subdot}[1]{\\mathpalette\\dosubdot{#1}}\n");
 238
 239 static docstring const subhat_def = from_ascii(
 240         "\\newcommand{\\dosubhat}[2]{\\underaccent{#1\\mathchar'136}{#2}}\n"
 241         "\\newcommand{\\subhat}[1]{\\mathpalette\\dosubhat{#1}}\n");
 242
 243 static docstring const subtilde_def = from_ascii(
 244         "\\newcommand{\\dosubtilde}[2]{\\underaccent{#1\\mathchar'176}{#2}}\n"
 245         "\\newcommand{\\subtilde}[1]{\\mathpalette\\dosubtilde{#1}}\n");
 246
 247 static docstring const dacute_def = from_ascii(
 248         "\\DeclareMathAccent{\\dacute}{\\mathalpha}{operators}{'175}\n");
 249
 250 static docstring const tipasymb_def = from_ascii(
 251         "\\DeclareFontEncoding{T3}{}{}\n"
 252         "\\DeclareSymbolFont{tipasymb}{T3}{cmr}{m}{n}\n");
 253
 254 static docstring const dgrave_def = from_ascii(
 255         "\\DeclareMathAccent{\\dgrave}{\\mathord}{tipasymb}{'15}\n");
 256
 257 static docstring const rcap_def = from_ascii(
 258         "\\DeclareMathAccent{\\rcap}{\\mathord}{tipasymb}{'20}\n");
 259
 260 static docstring const ogonek_def = from_ascii(
 261         "\\newcommand{\\doogonek}[2]{\\setbox0=\\hbox{$#1#2$}\\underaccent{#1\\mkern-6mu\n"
 262         "  \\ifx#2O\\hskip0.5\\wd0\\else\\ifx#2U\\hskip0.5\\wd0\\else\\hskip\\wd0\\fi\\fi\n"
 263         "  \\ifx#2o\\mkern-2mu\\else\\ifx#2e\\mkern-1mu\\fi\\fi\n"
 264         "  \\mathchar\"0\\hexnumber@\\symtipasymb0C}{#2}}\n"
 265         "\\newcommand{\\ogonek}[1]{\\mathpalette\\doogonek{#1}}\n");
 266
 267 static docstring const lyxref_def = from_ascii(
 268                 "\\RS@ifundefined{subref}\n"
 269                 "  {\\def\\RSsubtxt{section~}\\newref{sub}{name = \\RSsubtxt}}\n"
 270                 "  {}\n"
 271                 "\\RS@ifundefined{thmref}\n"
 272                 "  {\\def\\RSthmtxt{theorem~}\\newref{thm}{name = \\RSthmtxt}}\n"
 273                 "  {}\n"
 274                 "\\RS@ifundefined{lemref}\n"
 275                 "  {\\def\\RSlemtxt{lemma~}\\newref{lem}{name = \\RSlemtxt}}\n"
 276                 "  {}\n");
 277
 278
 279 /////////////////////////////////////////////////////////////////////
 280 //
 281 // LaTeXFeatures
 282 //
 283 /////////////////////////////////////////////////////////////////////
 284
 285
 286 LaTeXFeatures::LaTeXFeatures(Buffer const & b, BufferParams const & p,
 287                              OutputParams const & r)
 288         : buffer_(&b), params_(p), runparams_(r), in_float_(false)
 289 {}
 290
 291
 292 bool LaTeXFeatures::useBabel() const
 293 {
 294         if (usePolyglossia())
 295                 return false;
 296         if (bufferParams().lang_package == "default")
 297                 return (lyxrc.language_package_selection != LyXRC::LP_NONE)
 298                         || (bufferParams().language->lang() != lyxrc.default_language
 299                             && !bufferParams().language->babel().empty())
 300                         || this->hasLanguages();
 301         return (bufferParams().lang_package != "none")
 302                 || (bufferParams().language->lang() != lyxrc.default_language
 303                     && !bufferParams().language->babel().empty())
 304                 || this->hasLanguages();
 305 }
 306
 307
 308 bool LaTeXFeatures::usePolyglossia() const
 309 {
 310         if (bufferParams().lang_package == "default")
 311                 return (lyxrc.language_package_selection == LyXRC::LP_AUTO)
 312                         && isRequired("polyglossia")
 313                         && isAvailable("polyglossia")
 314                         && !params_.documentClass().provides("babel")
 315                         && this->hasPolyglossiaLanguages();
 316         return (bufferParams().lang_package == "auto")
 317                 && isRequired("polyglossia")
 318                 && isAvailable("polyglossia")
 319                 && !params_.documentClass().provides("babel")
 320                 && this->hasPolyglossiaLanguages();
 321 }
 322
 323
 324 void LaTeXFeatures::require(string const & name)
 325 {
 326         features_.insert(name);
 327 }
 328
 329
 330 void LaTeXFeatures::require(set<string> const & names)
 331 {
 332         features_.insert(names.begin(), names.end());
 333 }
 334
 335
 336 void LaTeXFeatures::useLayout(docstring const & layoutname)
 337 {
 338         // Some code to avoid loops in dependency definition
 339         static int level = 0;
 340         const int maxlevel = 30;
 341         if (level > maxlevel) {
 342                 lyxerr << "LaTeXFeatures::useLayout: maximum level of "
 343                        << "recursion attained by layout "
 344                        << to_utf8(layoutname) << endl;
 345                 return;
 346         }
 347
 348         DocumentClass const & tclass = params_.documentClass();
 349         if (tclass.hasLayout(layoutname)) {
 350                 // Is this layout already in usedLayouts?
 351                 if (find(usedLayouts_.begin(), usedLayouts_.end(), layoutname)
 352                     != usedLayouts_.end())
 353                         return;
 354
 355                 Layout const & layout = tclass[layoutname];
 356                 require(layout.requires());
 357
 358                 if (!layout.depends_on().empty()) {
 359                         ++level;
 360                         useLayout(layout.depends_on());
 361                         --level;
 362                 }
 363                 usedLayouts_.push_back(layoutname);
 364         } else {
 365                 lyxerr << "LaTeXFeatures::useLayout: layout `"
 366                        << to_utf8(layoutname) << "' does not exist in this class"
 367                        << endl;
 368         }
 369
 370         --level;
 371 }
 372
 373
 374 void LaTeXFeatures::useInsetLayout(InsetLayout const & lay)
 375 {
 376         docstring const & lname = lay.name();
 377         DocumentClass const & tclass = params_.documentClass();
 378
 379         // this is a default inset layout, nothing useful here
 380         if (!tclass.hasInsetLayout(lname))
 381                 return;
 382         // Is this layout already in usedInsetLayouts?
 383         if (find(usedInsetLayouts_.begin(), usedInsetLayouts_.end(), lname)
 384                         != usedInsetLayouts_.end())
 385                 return;
 386
 387         require(lay.requires());
 388         usedInsetLayouts_.push_back(lname);
 389 }
 390
 391
 392 bool LaTeXFeatures::isRequired(string const & name) const
 393 {
 394         return features_.find(name) != features_.end();
 395 }
 396
 397
 398 bool LaTeXFeatures::mustProvide(string const & name) const
 399 {
 400         return isRequired(name) && !params_.documentClass().provides(name);
 401 }
 402
 403
 404 bool LaTeXFeatures::isAvailable(string const & name)
 405 {
 406         string::size_type const i = name.find("->");
 407         if (i != string::npos) {
 408                 string const from = name.substr(0,i);
 409                 string const to = name.substr(i+2);
 410                 //LYXERR0("from=[" << from << "] to=[" << to << "]");
 411                 return theConverters().isReachable(from, to);
 412         }
 413         return LaTeXPackages::isAvailable(name);
 414 }
 415
 416
 417 void LaTeXFeatures::addPreambleSnippet(string const & preamble)
 418 {
 419         SnippetList::const_iterator begin = preamble_snippets_.begin();
 420         SnippetList::const_iterator end   = preamble_snippets_.end();
 421         if (find(begin, end, preamble) == end)
 422                 preamble_snippets_.push_back(preamble);
 423 }
 424
 425
 426 void LaTeXFeatures::addCSSSnippet(std::string const & snippet)
 427 {
 428         SnippetList::const_iterator begin = css_snippets_.begin();
 429         SnippetList::const_iterator end   = css_snippets_.end();
 430         if (find(begin, end, snippet) == end)
 431                 css_snippets_.push_back(snippet);
 432 }
 433
 434
 435 void LaTeXFeatures::useFloat(string const & name, bool subfloat)
 436 {
 437         if (!usedFloats_[name])
 438                 usedFloats_[name] = subfloat;
 439         if (subfloat)
 440                 require("subfig");
 441         // We only need float.sty if we use non builtin floats, or if we
 442         // use the "H" modifier. This includes modified table and
 443         // figure floats. (Lgb)
 444         Floating const & fl = params_.documentClass().floats().getType(name);
 445         if (!fl.floattype().empty() && fl.usesFloatPkg()) {
 446                 require("float");
 447         }
 448 }
 449
 450
 451 void LaTeXFeatures::useLanguage(Language const * lang)
 452 {
 453         if (!lang->babel().empty())
 454                 UsedLanguages_.insert(lang);
 455         if (lang->lang() == "vietnamese")
 456                 require("vietnamese");
 457         // CJK languages do not have a babel name.
 458         // They use the CJK package
 459         if (lang->encoding()->package() == Encoding::CJK)
 460                 require("CJK");
 461         // japanese package is special
 462         if (lang->encoding()->package() == Encoding::japanese)
 463                 require("japanese");
 464 }
 465
 466
 467 void LaTeXFeatures::includeFile(docstring const & key, string const & name)
 468 {
 469         IncludedFiles_[key] = name;
 470 }
 471
 472
 473 bool LaTeXFeatures::hasLanguages() const
 474 {
 475         return !UsedLanguages_.empty();
 476 }
 477
 478
 479 bool LaTeXFeatures::hasPolyglossiaLanguages() const
 480 {
 481         LanguageList::const_iterator const begin = UsedLanguages_.begin();
 482         for (LanguageList::const_iterator cit = begin;
 483              cit != UsedLanguages_.end();
 484              ++cit) {
 485                 if ((*cit)->polyglossia().empty())
 486                         return false;
 487         }
 488         return true;
 489 }
 490
 491
 492 string LaTeXFeatures::getLanguages() const
 493 {
 494         ostringstream languages;
 495
 496         LanguageList::const_iterator const begin = UsedLanguages_.begin();
 497         for (LanguageList::const_iterator cit = begin;
 498              cit != UsedLanguages_.end();
 499              ++cit) {
 500                 if (cit != begin)
 501                         languages << ',';
 502                 languages << (*cit)->babel();
 503         }
 504         return languages.str();
 505 }
 506
 507
 508 std::map<std::string, std::string> LaTeXFeatures::getPolyglossiaLanguages() const
 509 {
 510         std::map<std::string, std::string> languages;
 511
 512         LanguageList::const_iterator const begin = UsedLanguages_.begin();
 513         for (LanguageList::const_iterator cit = begin;
 514              cit != UsedLanguages_.end();
 515              ++cit) {
 516                 languages[(*cit)->polyglossia()] = (*cit)->polyglossiaOpts();
 517         }
 518         return languages;
 519 }
 520
 521
 522 set<string> LaTeXFeatures::getEncodingSet(string const & doc_encoding) const
 523 {
 524         // This does only find encodings of languages supported by babel, but
 525         // that does not matter since we don't have a language with an
 526         // encoding supported by inputenc but without babel support.
 527         set<string> encodings;
 528         LanguageList::const_iterator it  = UsedLanguages_.begin();
 529         LanguageList::const_iterator end = UsedLanguages_.end();
 530         for (; it != end; ++it)
 531                 if ((*it)->encoding()->latexName() != doc_encoding &&
 532                     ((*it)->encoding()->package() == Encoding::inputenc
 533                      || (*it)->encoding()->package() == Encoding::japanese))
 534                         encodings.insert((*it)->encoding()->latexName());
 535         return encodings;
 536 }
 537
 538 namespace {
 539
 540 char const * simplefeatures[] = {
 541 // note that the package order here will be the same in the LaTeX-output
 542         "array",
 543         "verbatim",
 544         "longtable",
 545         "rotating",
 546         "latexsym",
 547         "pifont",
 548         // subfig is handled in BufferParams.cpp
 549         "varioref",
 550         "prettyref",
 551         "refstyle",
 552         /*For a successful cooperation of the `wrapfig' package with the
 553           `float' package you should load the `wrapfig' package *after*
 554           the `float' package. See the caption package documentation
 555           for explanation.*/
 556         "float",
 557         "rotfloat",
 558         "wrapfig",
 559         "booktabs",
 560         "dvipost",
 561         "fancybox",
 562         "calc",
 563         "units",
 564         "tipa",
 565         "tipx",
 566         "framed",
 567         "soul",
 568         "textcomp",
 569         "pmboxdraw",
 570         "bbding",
 571         "ifsym",
 572         "marvosym",
 573         "txfonts",
 574         "pxfonts",
 575         "mathdesign",
 576         "mathrsfs",
 577         "mathabx",
 578         "mathtools",
 579         "cancel",
 580         "ascii",
 581         "url",
 582         "covington",
 583         "csquotes",
 584         "enumitem",
 585         "endnotes",
 586         "hhline",
 587         "ifthen",
 588         // listings is handled in BufferParams.cpp
 589         "bm",
 590         "pdfpages",
 591         "amscd",
 592         "slashed",
 593         "multirow",
 594         "tfrupee"
 595 };
 596
 597 int const nb_simplefeatures = sizeof(simplefeatures) / sizeof(char const *);
 598
 599 }
 600
 601
 602 string const LaTeXFeatures::getColorOptions() const
 603 {
 604         ostringstream colors;
 605
 606         // Handling the color packages separately is needed to be able to load them
 607         // before babel when hyperref is loaded with the colorlinks option
 608         // for more info see Bufferparams.cpp
 609
 610         // [x]color.sty
 611         if (mustProvide("color") || mustProvide("xcolor")) {
 612                 string const package =
 613                         (mustProvide("xcolor") ? "xcolor" : "color");
 614                 if (params_.graphics_driver == "default"
 615                         || params_.graphics_driver == "none")
 616                         colors << "\\usepackage{" << package << "}\n";
 617                 else
 618                         colors << "\\usepackage["
 619                                  << params_.graphics_driver
 620                                  << "]{" << package << "}\n";
 621         }
 622
 623         // pdfcolmk must be loaded after color
 624         if (mustProvide("pdfcolmk"))
 625                 colors << "\\usepackage{pdfcolmk}\n";
 626
 627         // the following 3 color commands must be set after color
 628         // is loaded and before pdfpages, therefore add the command
 629         // here define the set color
 630         if (mustProvide("pagecolor")) {
 631                 colors << "\\definecolor{page_backgroundcolor}{rgb}{";
 632                 colors << outputLaTeXColor(params_.backgroundcolor) << "}\n";
 633                 // set the page color
 634                 colors << "\\pagecolor{page_backgroundcolor}\n";
 635         }
 636
 637         if (mustProvide("fontcolor")) {
 638                 colors << "\\definecolor{document_fontcolor}{rgb}{";
 639                 colors << outputLaTeXColor(params_.fontcolor) << "}\n";
 640                 // set the color
 641                 colors << "\\color{document_fontcolor}\n";
 642         }
 643
 644         if (mustProvide("lyxgreyedout")) {
 645                 colors << "\\definecolor{note_fontcolor}{rgb}{";
 646                 colors << outputLaTeXColor(params_.notefontcolor) << "}\n";
 647                 // the color will be set together with the definition of
 648                 // the lyxgreyedout environment (see lyxgreyedout_def)
 649         }
 650
 651         // color for shaded boxes
 652         if (isRequired("framed") && mustProvide("color")) {
 653                 colors << "\\definecolor{shadecolor}{rgb}{";
 654                 colors << outputLaTeXColor(params_.boxbgcolor) << "}\n";
 655                 // this color is automatically used by the LaTeX-package "framed"
 656         }
 657
 658         return colors.str();
 659 }
 660
 661
 662 string const LaTeXFeatures::getPackages() const
 663 {
 664         ostringstream packages;
 665         DocumentClass const & tclass = params_.documentClass();
 666
 667         // FIXME: currently, we can only load packages and macros known
 668         // to LyX.
 669         // However, with the Require tag of layouts/custom insets,
 670         // also unknown packages can be requested. They are silently
 671         // swallowed now. We should change this eventually.
 672
 673         //
 674         //  These are all the 'simple' includes.  i.e
 675         //  packages which we just \usepackage{package}
 676         //
 677         for (int i = 0; i < nb_simplefeatures; ++i) {
 678                 if (mustProvide(simplefeatures[i]))
 679                         packages << "\\usepackage{"
 680                                  << simplefeatures[i] << "}\n";
 681         }
 682
 683         //
 684         // The rest of these packages are somewhat more complicated
 685         // than those above.
 686         //
 687
 688         // if fontspec is used, AMS packages have to be loaded before
 689         // fontspec (in BufferParams)
 690         string const amsPackages = loadAMSPackages();
 691         if (!params_.useNonTeXFonts && !amsPackages.empty())
 692                 packages << amsPackages;
 693
 694         // fixltx2e must be loaded after amsthm, since amsthm produces an error with
 695         // the redefined \[ command (bug 7233). Load it as early as possible, since
 696         // other packages might profit from it.
 697         if (mustProvide("fixltx2e"))
 698                 packages << "\\usepackage{fixltx2e}\n";
 699
 700         // wasysym is a simple feature, but it must be after amsmath if both
 701         // are used
 702         // wasysym redefines some integrals (e.g. iint) from amsmath. That
 703         // leads to inconsistent integrals. We only load this package if
 704         // the document does not contain integrals (then isRequired("esint")
 705         // is false) or if esint is used, since esint redefines all relevant
 706         // integral symbols from wasysym and amsmath.
 707         // See http://www.lyx.org/trac/ticket/1942
 708         if (mustProvide("wasysym") &&
 709             params_.use_package("wasysym") != BufferParams::package_off &&
 710             (params_.use_package("esint") != BufferParams::package_off || !isRequired("esint")))
 711                 packages << "\\usepackage{wasysym}\n";
 712
 713         // accents must be loaded after amsmath
 714         if (mustProvide("accents") &&
 715             params_.use_package("accents") != BufferParams::package_off)
 716                 packages << "\\usepackage{accents}\n";
 717
 718         // mathdots must be loaded after amsmath
 719         if (mustProvide("mathdots") &&
 720                 params_.use_package("mathdots") != BufferParams::package_off)
 721                 packages << "\\usepackage{mathdots}\n";
 722
 723         // yhmath must be loaded after amsmath
 724         if (mustProvide("yhmath") &&
 725             params_.use_package("yhmath") != BufferParams::package_off)
 726                 packages << "\\usepackage{yhmath}\n";
 727
 728         if (mustProvide("undertilde") &&
 729                 params_.use_package("undertilde") != BufferParams::package_off)
 730                 packages << "\\usepackage{undertilde}\n";
 731
 732         // [x]color and pdfcolmk are handled in getColorOptions() above
 733
 734         // makeidx.sty
 735         if (isRequired("makeidx") || isRequired("splitidx")) {
 736                 if (!tclass.provides("makeidx") && !isRequired("splitidx"))
 737                         packages << "\\usepackage{makeidx}\n";
 738                 if (!tclass.provides("splitidx") && isRequired("splitidx"))
 739                         packages << "\\usepackage{splitidx}\n";
 740                 packages << "\\makeindex\n";
 741         }
 742
 743         // graphicx.sty
 744         if (mustProvide("graphicx") && params_.graphics_driver != "none") {
 745                 if (params_.graphics_driver == "default")
 746                         packages << "\\usepackage{graphicx}\n";
 747                 else
 748                         packages << "\\usepackage["
 749                                  << params_.graphics_driver
 750                                  << "]{graphicx}\n";
 751         }
 752
 753         // lyxskak.sty --- newer chess support based on skak.sty
 754         if (mustProvide("chess"))
 755                 packages << "\\usepackage[ps,mover]{lyxskak}\n";
 756
 757         // setspace.sty
 758         if (mustProvide("setspace") && !tclass.provides("SetSpace"))
 759                 packages << "\\usepackage{setspace}\n";
 760
 761         // esint must be after amsmath and wasysym, since it will redeclare
 762         // inconsistent integral symbols
 763         if (mustProvide("esint") &&
 764             params_.use_package("esint") != BufferParams::package_off)
 765                 packages << "\\usepackage{esint}\n";
 766
 767         // natbib.sty
 768         // Some classes load natbib themselves, but still allow (or even require)
 769         // plain numeric citations (ReVTeX is such a case, see bug 5182).
 770         // This special case is indicated by the "natbib-internal" key.
 771         if (mustProvide("natbib") && !tclass.provides("natbib-internal")) {
 772                 packages << "\\usepackage[";
 773                 if (params_.citeEngineType() == ENGINE_TYPE_NUMERICAL)
 774                         packages << "numbers";
 775                 else
 776                         packages << "authoryear";
 777                 packages << "]{natbib}\n";
 778         }
 779
 780         // jurabib -- we need version 0.6 at least.
 781         if (mustProvide("jurabib"))
 782                 packages << "\\usepackage{jurabib}[2004/01/25]\n";
 783
 784         // xargs -- we need version 1.09 at least
 785         if (mustProvide("xargs"))
 786                 packages << "\\usepackage{xargs}[2008/03/08]\n";
 787
 788         // bibtopic -- the dot provides the aux file naming which
 789         // LyX can detect.
 790         if (mustProvide("bibtopic"))
 791                 packages << "\\usepackage[dot]{bibtopic}\n";
 792
 793         if (mustProvide("xy"))
 794                 packages << "\\usepackage[all]{xy}\n";
 795
 796         if (mustProvide("feyn"))
 797                 packages << "\\usepackage{feyn}\n"; //Diagram
 798
 799         if (mustProvide("ulem"))
 800                 packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
 801                             "\\usepackage{ulem}\n";
 802
 803         if (mustProvide("mhchem") &&
 804             params_.use_package("mhchem") != BufferParams::package_off)
 805                 packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
 806                             "\\usepackage{mhchem}\n";
 807
 808         if (mustProvide("nomencl")) {
 809                 // Make it work with the new and old version of the package,
 810                 // but don't use the compatibility option since it is
 811                 // incompatible to other packages.
 812                 packages << "\\usepackage{nomencl}\n"
 813                             "% the following is useful when we have the old nomencl.sty package\n"
 814                             "\\providecommand{\\printnomenclature}{\\printglossary}\n"
 815                             "\\providecommand{\\makenomenclature}{\\makeglossary}\n"
 816                             "\\makenomenclature\n";
 817         }
 818
 819         // fixltx2e provides subscript
 820         if (mustProvide("subscript") && !isRequired("fixltx2e"))
 821                 packages << "\\usepackage{subscript}\n";
 822
 823         return packages.str();
 824 }
 825
 826
 827 string LaTeXFeatures::getPreambleSnippets() const
 828 {
 829         ostringstream snip;
 830         SnippetList::const_iterator pit  = preamble_snippets_.begin();
 831         SnippetList::const_iterator pend = preamble_snippets_.end();
 832         for (; pit != pend; ++pit)
 833                 snip << *pit << '\n';
 834         return snip.str();
 835 }
 836
 837
 838 std::string LaTeXFeatures::getCSSSnippets() const
 839 {
 840         ostringstream snip;
 841         SnippetList::const_iterator pit  = css_snippets_.begin();
 842         SnippetList::const_iterator pend = css_snippets_.end();
 843         for (; pit != pend; ++pit)
 844                 snip << *pit << '\n';
 845         return snip.str();
 846 }
 847
 848
 849 docstring const LaTeXFeatures::getMacros() const
 850 {
 851         odocstringstream macros;
 852
 853         if (!preamble_snippets_.empty()) {
 854                 macros << '\n';
 855                 macros << from_utf8(getPreambleSnippets());
 856         }
 857
 858         if (mustProvide("papersize")) {
 859                 if (runparams_.flavor == OutputParams::LATEX)
 860                         macros << papersizedvi_def << '\n';
 861                 else
 862                         macros << papersizepdf_def << '\n';
 863         }
 864
 865         if (mustProvide("LyX")) {
 866                 if (isRequired("hyperref"))
 867                         macros << lyx_hyperref_def << '\n';
 868                 else
 869                         macros << lyx_def << '\n';
 870         }
 871
 872         if (mustProvide("noun"))
 873                 macros << noun_def << '\n';
 874
 875         if (mustProvide("lyxarrow"))
 876                 macros << lyxarrow_def << '\n';
 877
 878         if (!usePolyglossia() && mustProvide("textgreek")) {
 879                 // Avoid a LaTeX error if times fonts are used and the grtimes
 880                 // package is installed but actual fonts are not (bug 6469).
 881                 if (params_.fonts_roman == "times")
 882                         macros << subst(textgreek_def,
 883                                         from_ascii("\\greektext #1"),
 884                                         from_ascii("%\n  \\IfFileExists"
 885                                                    "{grtm10.tfm}{}{\\fontfamily"
 886                                                    "{cmr}}\\greektext #1"))
 887                                << '\n';
 888                 else
 889                         macros << textgreek_def << '\n';
 890         }
 891
 892         if (!usePolyglossia() && mustProvide("textcyr"))
 893                 macros << textcyr_def << '\n';
 894
 895         if (mustProvide("lyxmathsym"))
 896                 macros << lyxmathsym_def << '\n';
 897
 898         if (mustProvide("cedilla"))
 899                 macros << cedilla_def << '\n';
 900
 901         if (mustProvide("subring"))
 902                 macros << subring_def << '\n';
 903
 904         if (mustProvide("subdot"))
 905                 macros << subdot_def << '\n';
 906
 907         if (mustProvide("subhat"))
 908                 macros << subhat_def << '\n';
 909
 910         if (mustProvide("subtilde"))
 911                 macros << subtilde_def << '\n';
 912
 913         if (mustProvide("dacute"))
 914                 macros << dacute_def << '\n';
 915
 916         if (mustProvide("tipasymb"))
 917                 macros << tipasymb_def << '\n';
 918
 919         if (mustProvide("dgrave"))
 920                 macros << dgrave_def << '\n';
 921
 922         if (mustProvide("rcap"))
 923                 macros << rcap_def << '\n';
 924
 925         if (mustProvide("ogonek"))
 926                 macros << ogonek_def << '\n';
 927
 928         // quotes.
 929         if (mustProvide("quotesinglbase"))
 930                 macros << quotesinglbase_def << '\n';
 931         if (mustProvide("quotedblbase"))
 932                 macros << quotedblbase_def << '\n';
 933         if (mustProvide("guilsinglleft"))
 934                 macros << guilsinglleft_def << '\n';
 935         if (mustProvide("guilsinglright"))
 936                 macros << guilsinglright_def << '\n';
 937         if (mustProvide("guillemotleft"))
 938                 macros << guillemotleft_def << '\n';
 939         if (mustProvide("guillemotright"))
 940                 macros << guillemotright_def << '\n';
 941
 942         // Math mode
 943         if (mustProvide("binom") && !isRequired("amsmath"))
 944                 macros << binom_def << '\n';
 945         if (mustProvide("mathcircumflex"))
 946                 macros << mathcircumflex_def << '\n';
 947
 948         // other
 949         if (mustProvide("ParagraphLeftIndent"))
 950                 macros << paragraphleftindent_def;
 951         if (mustProvide("NeedLyXFootnoteCode"))
 952                 macros << floatingfootnote_def;
 953
 954         // some problems with tex->html converters
 955         if (mustProvide("NeedTabularnewline"))
 956                 macros << tabularnewline_def;
 957
 958         // greyed-out environment (note inset)
 959         // the color is specified in the routine
 960         // getColorOptions() to avoid LaTeX-package clashes
 961         if (mustProvide("lyxgreyedout"))
 962                 macros << lyxgreyedout_def;
 963
 964         if (mustProvide("lyxdot"))
 965                 macros << lyxdot_def << '\n';
 966
 967         // floats
 968         getFloatDefinitions(macros);
 969
 970         if (mustProvide("refstyle"))
 971                 macros << lyxref_def << '\n';
 972
 973         // change tracking
 974         if (mustProvide("ct-dvipost"))
 975                 macros << changetracking_dvipost_def;
 976
 977         if (mustProvide("ct-xcolor-ulem")) {
 978                 streamsize const prec = macros.precision(2);
 979
 980                 RGBColor cadd = rgbFromHexName(lcolor.getX11Name(Color_addedtext));
 981                 macros << "\\providecolor{lyxadded}{rgb}{"
 982                        << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
 983
 984                 RGBColor cdel = rgbFromHexName(lcolor.getX11Name(Color_deletedtext));
 985                 macros << "\\providecolor{lyxdeleted}{rgb}{"
 986                        << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
 987
 988                 macros.precision(prec);
 989
 990                 if (isRequired("hyperref"))
 991                         macros << changetracking_xcolor_ulem_hyperref_def;
 992                 else
 993                         macros << changetracking_xcolor_ulem_def;
 994         }
 995
 996         if (mustProvide("ct-none"))
 997                 macros << changetracking_none_def;
 998
 999         return macros.str();
1000 }
1001
1002
1003 string const LaTeXFeatures::getBabelPresettings() const
1004 {
1005         ostringstream tmp;
1006
1007         LanguageList::const_iterator it  = UsedLanguages_.begin();
1008         LanguageList::const_iterator end = UsedLanguages_.end();
1009         for (; it != end; ++it)
1010                 if (!(*it)->babel_presettings().empty())
1011                         tmp << (*it)->babel_presettings() << '\n';
1012         if (!params_.language->babel_presettings().empty())
1013                 tmp << params_.language->babel_presettings() << '\n';
1014
1015         return tmp.str();
1016 }
1017
1018
1019 string const LaTeXFeatures::getBabelPostsettings() const
1020 {
1021         ostringstream tmp;
1022
1023         LanguageList::const_iterator it  = UsedLanguages_.begin();
1024         LanguageList::const_iterator end = UsedLanguages_.end();
1025         for (; it != end; ++it)
1026                 if (!(*it)->babel_postsettings().empty())
1027                         tmp << (*it)->babel_postsettings() << '\n';
1028         if (!params_.language->babel_postsettings().empty())
1029                 tmp << params_.language->babel_postsettings() << '\n';
1030
1031         return tmp.str();
1032 }
1033
1034
1035 bool LaTeXFeatures::needBabelLangOptions() const
1036 {
1037         if (!lyxrc.language_global_options || params_.language->asBabelOptions())
1038                 return true;
1039
1040         LanguageList::const_iterator it  = UsedLanguages_.begin();
1041         LanguageList::const_iterator end = UsedLanguages_.end();
1042         for (; it != end; ++it)
1043                 if ((*it)->asBabelOptions())
1044                         return true;
1045
1046         return false;
1047 }
1048
1049
1050 string const LaTeXFeatures::loadAMSPackages() const
1051 {
1052         ostringstream tmp;
1053         if (mustProvide("amsthm"))
1054                 tmp << "\\usepackage{amsthm}\n";
1055
1056         if (mustProvide("amsmath")
1057             && params_.use_package("amsmath") != BufferParams::package_off) {
1058                 tmp << "\\usepackage{amsmath}\n";
1059         } else {
1060                 // amsbsy and amstext are already provided by amsmath
1061                 if (mustProvide("amsbsy"))
1062                         tmp << "\\usepackage{amsbsy}\n";
1063                 if (mustProvide("amstext"))
1064                         tmp << "\\usepackage{amstext}\n";
1065         }
1066
1067         if (mustProvide("amssymb")
1068             || params_.use_package("amsmath") == BufferParams::package_on)
1069                 tmp << "\\usepackage{amssymb}\n";
1070
1071         return tmp.str();
1072 }
1073
1074
1075 docstring const LaTeXFeatures::getTClassPreamble() const
1076 {
1077         // the text class specific preamble
1078         DocumentClass const & tclass = params_.documentClass();
1079         odocstringstream tcpreamble;
1080
1081         tcpreamble << tclass.preamble();
1082
1083         list<docstring>::const_iterator cit = usedLayouts_.begin();
1084         list<docstring>::const_iterator end = usedLayouts_.end();
1085         for (; cit != end; ++cit)
1086                 tcpreamble << tclass[*cit].preamble();
1087
1088         cit = usedInsetLayouts_.begin();
1089         end = usedInsetLayouts_.end();
1090         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1091         for (; cit != end; ++cit) {
1092                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1093                 if (it == ils.end())
1094                         continue;
1095                 tcpreamble << it->second.preamble();
1096         }
1097
1098         return tcpreamble.str();
1099 }
1100
1101
1102 docstring const LaTeXFeatures::getTClassHTMLPreamble() const
1103 {
1104         DocumentClass const & tclass = params_.documentClass();
1105         odocstringstream tcpreamble;
1106
1107         tcpreamble << tclass.htmlpreamble();
1108
1109         list<docstring>::const_iterator cit = usedLayouts_.begin();
1110         list<docstring>::const_iterator end = usedLayouts_.end();
1111         for (; cit != end; ++cit)
1112                 tcpreamble << tclass[*cit].htmlpreamble();
1113
1114         cit = usedInsetLayouts_.begin();
1115         end = usedInsetLayouts_.end();
1116         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1117         for (; cit != end; ++cit) {
1118                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1119                 if (it == ils.end())
1120                         continue;
1121                 tcpreamble << it->second.htmlpreamble();
1122         }
1123
1124         return tcpreamble.str();
1125 }
1126
1127
1128 docstring const LaTeXFeatures::getTClassHTMLStyles() const
1129 {
1130         DocumentClass const & tclass = params_.documentClass();
1131         odocstringstream tcpreamble;
1132
1133         tcpreamble << tclass.htmlstyles();
1134
1135         list<docstring>::const_iterator cit = usedLayouts_.begin();
1136         list<docstring>::const_iterator end = usedLayouts_.end();
1137         for (; cit != end; ++cit)
1138                 tcpreamble << tclass[*cit].htmlstyle();
1139
1140         cit = usedInsetLayouts_.begin();
1141         end = usedInsetLayouts_.end();
1142         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1143         for (; cit != end; ++cit) {
1144                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1145                 if (it == ils.end())
1146                         continue;
1147                 tcpreamble << it->second.htmlstyle();
1148         }
1149
1150         return tcpreamble.str();
1151 }
1152
1153
1154 namespace {
1155 docstring const getFloatI18nPreamble(docstring const & type,
1156                         docstring const & name, Language const * lang,
1157                         Encoding const & enc, bool const polyglossia)
1158 {
1159         // Check whether name can be encoded in the buffer encoding
1160         bool encodable = true;
1161         for (size_t i = 0; i < name.size(); ++i) {
1162                 if (enc.latexChar(name[i], true)[0] != name[i]) {
1163                         encodable = false;
1164                         break;
1165                 }
1166         }
1167
1168         docstring const language = polyglossia ? from_ascii(lang->polyglossia())
1169                                                : from_ascii(lang->babel());
1170         docstring const langenc = from_ascii(lang->encoding()->iconvName());
1171         docstring const texenc = from_ascii(lang->encoding()->latexName());
1172         docstring const bufenc = from_ascii(enc.iconvName());
1173         docstring const s1 = docstring(1, 0xF0000);
1174         docstring const s2 = docstring(1, 0xF0001);
1175         docstring const translated = encodable ? name
1176                 : from_ascii("\\inputencoding{") + texenc + from_ascii("}")
1177                         + s1 + langenc + s2 + name + s1 + bufenc + s2;
1178
1179         odocstringstream os;
1180         os << "\\addto\\captions" << language
1181            << "{\\renewcommand{\\" << type << "name}{" << translated << "}}\n";
1182         return os.str();
1183 }
1184 }
1185
1186
1187 docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel, bool use_polyglossia) const
1188 {
1189         DocumentClass const & tclass = params_.documentClass();
1190         // collect preamble snippets in a set to prevent multiple identical
1191         // commands (would happen if e.g. both theorem and theorem* are used)
1192         set<docstring> snippets;
1193         typedef LanguageList::const_iterator lang_it;
1194         lang_it const lbeg = UsedLanguages_.begin();
1195         lang_it const lend =  UsedLanguages_.end();
1196         list<docstring>::const_iterator cit = usedLayouts_.begin();
1197         list<docstring>::const_iterator end = usedLayouts_.end();
1198         for (; cit != end; ++cit) {
1199                 // language dependent commands (once per document)
1200                 snippets.insert(tclass[*cit].langpreamble(buffer().language(),
1201                                                 buffer().params().encoding(),
1202                                                 use_polyglossia));
1203                 // commands for language changing (for multilanguage documents)
1204                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
1205                         snippets.insert(tclass[*cit].babelpreamble(
1206                                                 buffer().language(),
1207                                                 buffer().params().encoding(),
1208                                                 use_polyglossia));
1209                         for (lang_it lit = lbeg; lit != lend; ++lit)
1210                                 snippets.insert(tclass[*cit].babelpreamble(
1211                                                 *lit,
1212                                                 buffer().params().encoding(),
1213                                                 use_polyglossia));
1214                 }
1215         }
1216         if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
1217                 FloatList const & floats = params_.documentClass().floats();
1218                 UsedFloats::const_iterator fit = usedFloats_.begin();
1219                 UsedFloats::const_iterator fend = usedFloats_.end();
1220                 for (; fit != fend; ++fit) {
1221                         Floating const & fl = floats.getType(fit->first);
1222                         // we assume builtin floats are translated
1223                         if (fl.isPredefined())
1224                                 continue;
1225                         docstring const type = from_ascii(fl.floattype());
1226                         docstring const flname = from_utf8(fl.name());
1227                         docstring name = buffer().language()->translateLayout(fl.name());
1228                         // only request translation if we have a real translation
1229                         // (that differs from the source)
1230                         if (flname != name)
1231                                 snippets.insert(getFloatI18nPreamble(
1232                                                 type, name, buffer().language(),
1233                                                 buffer().params().encoding(),
1234                                                 use_polyglossia));
1235                         for (lang_it lit = lbeg; lit != lend; ++lit) {
1236                                 string const code = (*lit)->code();
1237                                 name = (*lit)->translateLayout(fl.name());
1238                                 // we assume we have a suitable translation if
1239                                 // either the language is English (we need to
1240                                 // translate into English if English is a secondary
1241                                 // language) or if translateIfPossible returns
1242                                 // something different to the English source.
1243                                 bool const have_translation =
1244                                         (flname != name || contains(code, "en"));
1245                                 if (have_translation)
1246                                         snippets.insert(getFloatI18nPreamble(
1247                                                 type, name, *lit,
1248                                                 buffer().params().encoding(),
1249                                                 use_polyglossia));
1250                         }
1251                 }
1252         }
1253
1254         odocstringstream tcpreamble;
1255         set<docstring>::const_iterator const send = snippets.end();
1256         set<docstring>::const_iterator it = snippets.begin();
1257         for (; it != send; ++it)
1258                 tcpreamble << *it;
1259         return tcpreamble.str();
1260 }
1261
1262
1263 docstring const LaTeXFeatures::getLyXSGMLEntities() const
1264 {
1265         // Definition of entities used in the document that are LyX related.
1266         odocstringstream entities;
1267
1268         if (mustProvide("lyxarrow")) {
1269                 entities << "<!ENTITY lyxarrow \"-&gt;\">" << '\n';
1270         }
1271
1272         return entities.str();
1273 }
1274
1275
1276 docstring const LaTeXFeatures::getIncludedFiles(string const & fname) const
1277 {
1278         odocstringstream sgmlpreamble;
1279         // FIXME UNICODE
1280         docstring const basename(from_utf8(onlyPath(fname)));
1281
1282         FileMap::const_iterator end = IncludedFiles_.end();
1283         for (FileMap::const_iterator fi = IncludedFiles_.begin();
1284              fi != end; ++fi)
1285                 // FIXME UNICODE
1286                 sgmlpreamble << "\n<!ENTITY " << fi->first
1287                              << (isSGMLFileName(fi->second) ? " SYSTEM \"" : " \"")
1288                              << makeRelPath(from_utf8(fi->second), basename) << "\">";
1289
1290         return sgmlpreamble.str();
1291 }
1292
1293
1294 void LaTeXFeatures::showStruct() const
1295 {
1296         lyxerr << "LyX needs the following commands when LaTeXing:"
1297                << "\n***** Packages:" << getPackages()
1298                << "\n***** Macros:" << to_utf8(getMacros())
1299                << "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
1300                << "\n***** done." << endl;
1301 }
1302
1303
1304 Buffer const & LaTeXFeatures::buffer() const
1305 {
1306         return *buffer_;
1307 }
1308
1309
1310 void LaTeXFeatures::setBuffer(Buffer const & buffer)
1311 {
1312         buffer_ = &buffer;
1313 }
1314
1315
1316 BufferParams const & LaTeXFeatures::bufferParams() const
1317 {
1318         return params_;
1319 }
1320
1321
1322 void LaTeXFeatures::getFloatDefinitions(odocstream & os) const
1323 {
1324         FloatList const & floats = params_.documentClass().floats();
1325
1326         // Here we will output the code to create the needed float styles.
1327         // We will try to do this as minimal as possible.
1328         // \floatstyle{ruled}
1329         // \newfloat{algorithm}{htbp}{loa}
1330         // \providecommand{\algorithmname}{Algorithm}
1331         // \floatname{algorithm}{\protect\algorithmname}
1332         UsedFloats::const_iterator cit = usedFloats_.begin();
1333         UsedFloats::const_iterator end = usedFloats_.end();
1334         for (; cit != end; ++cit) {
1335                 Floating const & fl = floats.getType(cit->first);
1336
1337                 // For builtin floats we do nothing.
1338                 if (fl.isPredefined())
1339                         continue;
1340
1341                 // We have to special case "table" and "figure"
1342                 if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
1343                         // Output code to modify "table" or "figure"
1344                         // but only if builtin == false
1345                         // and that have to be true at this point in the
1346                         // function.
1347                         docstring const type = from_ascii(fl.floattype());
1348                         docstring const placement = from_ascii(fl.placement());
1349                         docstring const style = from_ascii(fl.style());
1350                         if (!style.empty()) {
1351                                 os << "\\floatstyle{" << style << "}\n"
1352                                    << "\\restylefloat{" << type << "}\n";
1353                         }
1354                         if (!placement.empty()) {
1355                                 os << "\\floatplacement{" << type << "}{"
1356                                    << placement << "}\n";
1357                         }
1358                 } else {
1359                         // The other non builtin floats.
1360
1361                         docstring const type = from_ascii(fl.floattype());
1362                         docstring const placement = from_ascii(fl.placement());
1363                         docstring const ext = from_ascii(fl.ext());
1364                         docstring const within = from_ascii(fl.within());
1365                         docstring const style = from_ascii(fl.style());
1366                         docstring const name =
1367                                 buffer().language()->translateLayout(fl.name());
1368                         os << "\\floatstyle{" << style << "}\n"
1369                            << "\\newfloat{" << type << "}{" << placement
1370                            << "}{" << ext << '}';
1371                         if (!within.empty())
1372                                 os << '[' << within << ']';
1373                         os << '\n'
1374                            << "\\providecommand{\\" << type << "name}{"
1375                            << name << "}\n"
1376                            << "\\floatname{" << type << "}{\\protect\\"
1377                            << type << "name}\n";
1378
1379                         // What missing here is to code to minimalize the code
1380                         // output so that the same floatstyle will not be
1381                         // used several times, when the same style is still in
1382                         // effect. (Lgb)
1383                 }
1384                 if (cit->second)
1385                         os << "\n\\newsubfloat{" << from_ascii(fl.floattype()) << "}\n";
1386         }
1387 }
1388
1389
1390 void LaTeXFeatures::resolveAlternatives()
1391 {
1392         for (Features::iterator it = features_.begin(); it != features_.end();) {
1393                 if (contains(*it, '|')) {
1394                         vector<string> const alternatives = getVectorFromString(*it, "|");
1395                         vector<string>::const_iterator const end = alternatives.end();
1396                         vector<string>::const_iterator ita = alternatives.begin();
1397                         for (; ita != end; ++ita) {
1398                                 if (isRequired(*ita))
1399                                         break;
1400                         }
1401                         if (ita == end)
1402                                 require(alternatives.front());
1403                         features_.erase(it);
1404                         it = features_.begin();
1405                 } else
1406                         ++it;
1407         }
1408 }
1409
1410
1411 } // namespace lyx