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         "ascii",
 580         "url",
 581         "covington",
 582         "csquotes",
 583         "enumitem",
 584         "endnotes",
 585         "hhline",
 586         "ifthen",
 587         // listings is handled in BufferParams.cpp
 588         "bm",
 589         "pdfpages",
 590         "amscd",
 591         "slashed",
 592         "multirow",
 593         "tfrupee"
 594 };
 595
 596 int const nb_simplefeatures = sizeof(simplefeatures) / sizeof(char const *);
 597
 598 }
 599
 600
 601 string const LaTeXFeatures::getColorOptions() const
 602 {
 603         ostringstream colors;
 604
 605         // Handling the color packages separately is needed to be able to load them
 606         // before babel when hyperref is loaded with the colorlinks option
 607         // for more info see Bufferparams.cpp
 608
 609         // [x]color.sty
 610         if (mustProvide("color") || mustProvide("xcolor")) {
 611                 string const package =
 612                         (mustProvide("xcolor") ? "xcolor" : "color");
 613                 if (params_.graphics_driver == "default"
 614                         || params_.graphics_driver == "none")
 615                         colors << "\\usepackage{" << package << "}\n";
 616                 else
 617                         colors << "\\usepackage["
 618                                  << params_.graphics_driver
 619                                  << "]{" << package << "}\n";
 620         }
 621
 622         // pdfcolmk must be loaded after color
 623         if (mustProvide("pdfcolmk"))
 624                 colors << "\\usepackage{pdfcolmk}\n";
 625
 626         // the following 3 color commands must be set after color
 627         // is loaded and before pdfpages, therefore add the command
 628         // here define the set color
 629         if (mustProvide("pagecolor")) {
 630                 colors << "\\definecolor{page_backgroundcolor}{rgb}{";
 631                 colors << outputLaTeXColor(params_.backgroundcolor) << "}\n";
 632                 // set the page color
 633                 colors << "\\pagecolor{page_backgroundcolor}\n";
 634         }
 635
 636         if (mustProvide("fontcolor")) {
 637                 colors << "\\definecolor{document_fontcolor}{rgb}{";
 638                 colors << outputLaTeXColor(params_.fontcolor) << "}\n";
 639                 // set the color
 640                 colors << "\\color{document_fontcolor}\n";
 641         }
 642
 643         if (mustProvide("lyxgreyedout")) {
 644                 colors << "\\definecolor{note_fontcolor}{rgb}{";
 645                 colors << outputLaTeXColor(params_.notefontcolor) << "}\n";
 646                 // the color will be set together with the definition of
 647                 // the lyxgreyedout environment (see lyxgreyedout_def)
 648         }
 649
 650         // color for shaded boxes
 651         if (isRequired("framed") && mustProvide("color")) {
 652                 colors << "\\definecolor{shadecolor}{rgb}{";
 653                 colors << outputLaTeXColor(params_.boxbgcolor) << "}\n";
 654                 // this color is automatically used by the LaTeX-package "framed"
 655         }
 656
 657         return colors.str();
 658 }
 659
 660
 661 string const LaTeXFeatures::getPackages() const
 662 {
 663         ostringstream packages;
 664         DocumentClass const & tclass = params_.documentClass();
 665
 666         // FIXME: currently, we can only load packages and macros known
 667         // to LyX.
 668         // However, with the Require tag of layouts/custom insets,
 669         // also unknown packages can be requested. They are silently
 670         // swallowed now. We should change this eventually.
 671
 672         //
 673         //  These are all the 'simple' includes.  i.e
 674         //  packages which we just \usepackage{package}
 675         //
 676         for (int i = 0; i < nb_simplefeatures; ++i) {
 677                 if (mustProvide(simplefeatures[i]))
 678                         packages << "\\usepackage{"
 679                                  << simplefeatures[i] << "}\n";
 680         }
 681
 682         //
 683         // The rest of these packages are somewhat more complicated
 684         // than those above.
 685         //
 686
 687         // if fontspec is used, AMS packages have to be loaded before
 688         // fontspec (in BufferParams)
 689         string const amsPackages = loadAMSPackages();
 690         if (!params_.useNonTeXFonts && !amsPackages.empty())
 691                 packages << amsPackages;
 692
 693         // fixltx2e must be loaded after amsthm, since amsthm produces an error with
 694         // the redefined \[ command (bug 7233). Load is as early as possible, since
 695         // other packages might profit from it.
 696         if (mustProvide("fixltx2e"))
 697                 packages << "\\usepackage{fixltx2e}\n";
 698
 699         // wasysym is a simple feature, but it must be after amsmath if both
 700         // are used
 701         // wasysym redefines some integrals (e.g. iint) from amsmath. That
 702         // leads to inconsistent integrals. We only load this package if
 703         // the document does not contain integrals (then isRequired("esint")
 704         // is false) or if esint is used, since esint redefines all relevant
 705         // integral symbols from wasysym and amsmath.
 706         // See http://www.lyx.org/trac/ticket/1942
 707         if (mustProvide("wasysym") &&
 708             (params_.use_esint != BufferParams::package_off || !isRequired("esint")))
 709                 packages << "\\usepackage{wasysym}\n";
 710
 711         // accents must be loaded after amsmath
 712         if (mustProvide("accents"))
 713                 packages << "\\usepackage{accents}\n";
 714
 715         // mathdots must be loaded after amsmath
 716         if (mustProvide("mathdots") &&
 717                 params_.use_mathdots != BufferParams::package_off)
 718                 packages << "\\usepackage{mathdots}\n";
 719
 720         // yhmath must be loaded after amsmath
 721         if (mustProvide("yhmath"))
 722                 packages << "\\usepackage{yhmath}\n";
 723
 724         if (mustProvide("undertilde") &&
 725                 params_.use_undertilde != BufferParams::package_off)
 726                 packages << "\\usepackage{undertilde}\n";
 727
 728         // [x]color and pdfcolmk are handled in getColorOptions() above
 729
 730         // makeidx.sty
 731         if (isRequired("makeidx") || isRequired("splitidx")) {
 732                 if (!tclass.provides("makeidx") && !isRequired("splitidx"))
 733                         packages << "\\usepackage{makeidx}\n";
 734                 if (!tclass.provides("splitidx") && isRequired("splitidx"))
 735                         packages << "\\usepackage{splitidx}\n";
 736                 packages << "\\makeindex\n";
 737         }
 738
 739         // graphicx.sty
 740         if (mustProvide("graphicx") && params_.graphics_driver != "none") {
 741                 if (params_.graphics_driver == "default")
 742                         packages << "\\usepackage{graphicx}\n";
 743                 else
 744                         packages << "\\usepackage["
 745                                  << params_.graphics_driver
 746                                  << "]{graphicx}\n";
 747         }
 748
 749         // lyxskak.sty --- newer chess support based on skak.sty
 750         if (mustProvide("chess"))
 751                 packages << "\\usepackage[ps,mover]{lyxskak}\n";
 752
 753         // setspace.sty
 754         if (mustProvide("setspace") && !tclass.provides("SetSpace"))
 755                 packages << "\\usepackage{setspace}\n";
 756
 757         // esint must be after amsmath and wasysym, since it will redeclare
 758         // inconsistent integral symbols
 759         if (mustProvide("esint") &&
 760             params_.use_esint != BufferParams::package_off)
 761                 packages << "\\usepackage{esint}\n";
 762
 763         // natbib.sty
 764         // Some classes load natbib themselves, but still allow (or even require)
 765         // plain numeric citations (ReVTeX is such a case, see bug 5182).
 766         // This special case is indicated by the "natbib-internal" key.
 767         if (mustProvide("natbib") && !tclass.provides("natbib-internal")) {
 768                 packages << "\\usepackage[";
 769                 if (params_.citeEngine() == ENGINE_NATBIB_NUMERICAL)
 770                         packages << "numbers";
 771                 else
 772                         packages << "authoryear";
 773                 packages << "]{natbib}\n";
 774         }
 775
 776         // jurabib -- we need version 0.6 at least.
 777         if (mustProvide("jurabib"))
 778                 packages << "\\usepackage{jurabib}[2004/01/25]\n";
 779
 780         // xargs -- we need version 1.09 at least
 781         if (mustProvide("xargs"))
 782                 packages << "\\usepackage{xargs}[2008/03/08]\n";
 783
 784         // bibtopic -- the dot provides the aux file naming which
 785         // LyX can detect.
 786         if (mustProvide("bibtopic"))
 787                 packages << "\\usepackage[dot]{bibtopic}\n";
 788
 789         if (mustProvide("xy"))
 790                 packages << "\\usepackage[all]{xy}\n";
 791
 792         if (mustProvide("feyn"))
 793                 packages << "\\usepackage{feyn}\n"; //Diagram
 794
 795         if (mustProvide("ulem"))
 796                 packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
 797                             "\\usepackage{ulem}\n";
 798
 799         if (params_.use_mhchem == BufferParams::package_on ||
 800             (mustProvide("mhchem") &&
 801              params_.use_mhchem != BufferParams::package_off))
 802                 packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
 803                             "\\usepackage{mhchem}\n";
 804
 805         if (mustProvide("nomencl")) {
 806                 // Make it work with the new and old version of the package,
 807                 // but don't use the compatibility option since it is
 808                 // incompatible to other packages.
 809                 packages << "\\usepackage{nomencl}\n"
 810                             "% the following is useful when we have the old nomencl.sty package\n"
 811                             "\\providecommand{\\printnomenclature}{\\printglossary}\n"
 812                             "\\providecommand{\\makenomenclature}{\\makeglossary}\n"
 813                             "\\makenomenclature\n";
 814         }
 815
 816         // fixltx2e provides subscript
 817         if (mustProvide("subscript") && !isRequired("fixltx2e"))
 818                 packages << "\\usepackage{subscript}\n";
 819
 820         return packages.str();
 821 }
 822
 823
 824 string LaTeXFeatures::getPreambleSnippets() const
 825 {
 826         ostringstream snip;
 827         SnippetList::const_iterator pit  = preamble_snippets_.begin();
 828         SnippetList::const_iterator pend = preamble_snippets_.end();
 829         for (; pit != pend; ++pit)
 830                 snip << *pit << '\n';
 831         return snip.str();
 832 }
 833
 834
 835 std::string LaTeXFeatures::getCSSSnippets() const
 836 {
 837         ostringstream snip;
 838         SnippetList::const_iterator pit  = css_snippets_.begin();
 839         SnippetList::const_iterator pend = css_snippets_.end();
 840         for (; pit != pend; ++pit)
 841                 snip << *pit << '\n';
 842         return snip.str();
 843 }
 844
 845
 846 docstring const LaTeXFeatures::getMacros() const
 847 {
 848         odocstringstream macros;
 849
 850         if (!preamble_snippets_.empty()) {
 851                 macros << '\n';
 852                 macros << from_utf8(getPreambleSnippets());
 853         }
 854
 855         if (mustProvide("papersize")) {
 856                 if (runparams_.flavor == OutputParams::LATEX)
 857                         macros << papersizedvi_def << '\n';
 858                 else
 859                         macros << papersizepdf_def << '\n';
 860         }
 861
 862         if (mustProvide("LyX")) {
 863                 if (isRequired("hyperref"))
 864                         macros << lyx_hyperref_def << '\n';
 865                 else
 866                         macros << lyx_def << '\n';
 867         }
 868
 869         if (mustProvide("noun"))
 870                 macros << noun_def << '\n';
 871
 872         if (mustProvide("lyxarrow"))
 873                 macros << lyxarrow_def << '\n';
 874
 875         if (!usePolyglossia() && mustProvide("textgreek")) {
 876                 // Avoid a LaTeX error if times fonts are used and the grtimes
 877                 // package is installed but actual fonts are not (bug 6469).
 878                 if (params_.fonts_roman == "times")
 879                         macros << subst(textgreek_def,
 880                                         from_ascii("\\greektext #1"),
 881                                         from_ascii("%\n  \\IfFileExists"
 882                                                    "{grtm10.tfm}{}{\\fontfamily"
 883                                                    "{cmr}}\\greektext #1"))
 884                                << '\n';
 885                 else
 886                         macros << textgreek_def << '\n';
 887         }
 888
 889         if (!usePolyglossia() && mustProvide("textcyr"))
 890                 macros << textcyr_def << '\n';
 891
 892         if (mustProvide("lyxmathsym"))
 893                 macros << lyxmathsym_def << '\n';
 894
 895         if (mustProvide("cedilla"))
 896                 macros << cedilla_def << '\n';
 897
 898         if (mustProvide("subring"))
 899                 macros << subring_def << '\n';
 900
 901         if (mustProvide("subdot"))
 902                 macros << subdot_def << '\n';
 903
 904         if (mustProvide("subhat"))
 905                 macros << subhat_def << '\n';
 906
 907         if (mustProvide("subtilde"))
 908                 macros << subtilde_def << '\n';
 909
 910         if (mustProvide("dacute"))
 911                 macros << dacute_def << '\n';
 912
 913         if (mustProvide("tipasymb"))
 914                 macros << tipasymb_def << '\n';
 915
 916         if (mustProvide("dgrave"))
 917                 macros << dgrave_def << '\n';
 918
 919         if (mustProvide("rcap"))
 920                 macros << rcap_def << '\n';
 921
 922         if (mustProvide("ogonek"))
 923                 macros << ogonek_def << '\n';
 924
 925         // quotes.
 926         if (mustProvide("quotesinglbase"))
 927                 macros << quotesinglbase_def << '\n';
 928         if (mustProvide("quotedblbase"))
 929                 macros << quotedblbase_def << '\n';
 930         if (mustProvide("guilsinglleft"))
 931                 macros << guilsinglleft_def << '\n';
 932         if (mustProvide("guilsinglright"))
 933                 macros << guilsinglright_def << '\n';
 934         if (mustProvide("guillemotleft"))
 935                 macros << guillemotleft_def << '\n';
 936         if (mustProvide("guillemotright"))
 937                 macros << guillemotright_def << '\n';
 938
 939         // Math mode
 940         if (mustProvide("binom") && !isRequired("amsmath"))
 941                 macros << binom_def << '\n';
 942         if (mustProvide("mathcircumflex"))
 943                 macros << mathcircumflex_def << '\n';
 944
 945         // other
 946         if (mustProvide("ParagraphLeftIndent"))
 947                 macros << paragraphleftindent_def;
 948         if (mustProvide("NeedLyXFootnoteCode"))
 949                 macros << floatingfootnote_def;
 950
 951         // some problems with tex->html converters
 952         if (mustProvide("NeedTabularnewline"))
 953                 macros << tabularnewline_def;
 954
 955         // greyed-out environment (note inset)
 956         // the color is specified in the routine
 957         // getColorOptions() to avoid LaTeX-package clashes
 958         if (mustProvide("lyxgreyedout"))
 959                 macros << lyxgreyedout_def;
 960
 961         if (mustProvide("lyxdot"))
 962                 macros << lyxdot_def << '\n';
 963
 964         // floats
 965         getFloatDefinitions(macros);
 966
 967         if (mustProvide("refstyle"))
 968                 macros << lyxref_def << '\n';
 969
 970         // change tracking
 971         if (mustProvide("ct-dvipost"))
 972                 macros << changetracking_dvipost_def;
 973
 974         if (mustProvide("ct-xcolor-ulem")) {
 975                 streamsize const prec = macros.precision(2);
 976
 977                 RGBColor cadd = rgbFromHexName(lcolor.getX11Name(Color_addedtext));
 978                 macros << "\\providecolor{lyxadded}{rgb}{"
 979                        << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
 980
 981                 RGBColor cdel = rgbFromHexName(lcolor.getX11Name(Color_deletedtext));
 982                 macros << "\\providecolor{lyxdeleted}{rgb}{"
 983                        << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
 984
 985                 macros.precision(prec);
 986
 987                 if (isRequired("hyperref"))
 988                         macros << changetracking_xcolor_ulem_hyperref_def;
 989                 else
 990                         macros << changetracking_xcolor_ulem_def;
 991         }
 992
 993         if (mustProvide("ct-none"))
 994                 macros << changetracking_none_def;
 995
 996         return macros.str();
 997 }
 998
 999
1000 string const LaTeXFeatures::getBabelPresettings() const
1001 {
1002         ostringstream tmp;
1003
1004         LanguageList::const_iterator it  = UsedLanguages_.begin();
1005         LanguageList::const_iterator end = UsedLanguages_.end();
1006         for (; it != end; ++it)
1007                 if (!(*it)->babel_presettings().empty())
1008                         tmp << (*it)->babel_presettings() << '\n';
1009         if (!params_.language->babel_presettings().empty())
1010                 tmp << params_.language->babel_presettings() << '\n';
1011
1012         return tmp.str();
1013 }
1014
1015
1016 string const LaTeXFeatures::getBabelPostsettings() const
1017 {
1018         ostringstream tmp;
1019
1020         LanguageList::const_iterator it  = UsedLanguages_.begin();
1021         LanguageList::const_iterator end = UsedLanguages_.end();
1022         for (; it != end; ++it)
1023                 if (!(*it)->babel_postsettings().empty())
1024                         tmp << (*it)->babel_postsettings() << '\n';
1025         if (!params_.language->babel_postsettings().empty())
1026                 tmp << params_.language->babel_postsettings() << '\n';
1027
1028         return tmp.str();
1029 }
1030
1031
1032 bool LaTeXFeatures::needBabelLangOptions() const
1033 {
1034         if (!lyxrc.language_global_options || params_.language->asBabelOptions())
1035                 return true;
1036
1037         LanguageList::const_iterator it  = UsedLanguages_.begin();
1038         LanguageList::const_iterator end = UsedLanguages_.end();
1039         for (; it != end; ++it)
1040                 if ((*it)->asBabelOptions())
1041                         return true;
1042
1043         return false;
1044 }
1045
1046
1047 string const LaTeXFeatures::loadAMSPackages() const
1048 {
1049         ostringstream tmp;
1050         if (mustProvide("amsthm"))
1051                 tmp << "\\usepackage{amsthm}\n";
1052
1053         if (mustProvide("amsmath")
1054             && params_.use_amsmath != BufferParams::package_off) {
1055                 tmp << "\\usepackage{amsmath}\n";
1056         } else {
1057                 // amsbsy and amstext are already provided by amsmath
1058                 if (mustProvide("amsbsy"))
1059                         tmp << "\\usepackage{amsbsy}\n";
1060                 if (mustProvide("amstext"))
1061                         tmp << "\\usepackage{amstext}\n";
1062         }
1063
1064         if (mustProvide("amssymb")
1065             || params_.use_amsmath == BufferParams::package_on)
1066                 tmp << "\\usepackage{amssymb}\n";
1067
1068         return tmp.str();
1069 }
1070
1071
1072 docstring const LaTeXFeatures::getTClassPreamble() const
1073 {
1074         // the text class specific preamble
1075         DocumentClass const & tclass = params_.documentClass();
1076         odocstringstream tcpreamble;
1077
1078         tcpreamble << tclass.preamble();
1079
1080         list<docstring>::const_iterator cit = usedLayouts_.begin();
1081         list<docstring>::const_iterator end = usedLayouts_.end();
1082         for (; cit != end; ++cit)
1083                 tcpreamble << tclass[*cit].preamble();
1084
1085         cit = usedInsetLayouts_.begin();
1086         end = usedInsetLayouts_.end();
1087         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1088         for (; cit != end; ++cit) {
1089                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1090                 if (it == ils.end())
1091                         continue;
1092                 tcpreamble << it->second.preamble();
1093         }
1094
1095         return tcpreamble.str();
1096 }
1097
1098
1099 docstring const LaTeXFeatures::getTClassHTMLPreamble() const
1100 {
1101         DocumentClass const & tclass = params_.documentClass();
1102         odocstringstream tcpreamble;
1103
1104         tcpreamble << tclass.htmlpreamble();
1105
1106         list<docstring>::const_iterator cit = usedLayouts_.begin();
1107         list<docstring>::const_iterator end = usedLayouts_.end();
1108         for (; cit != end; ++cit)
1109                 tcpreamble << tclass[*cit].htmlpreamble();
1110
1111         cit = usedInsetLayouts_.begin();
1112         end = usedInsetLayouts_.end();
1113         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1114         for (; cit != end; ++cit) {
1115                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1116                 if (it == ils.end())
1117                         continue;
1118                 tcpreamble << it->second.htmlpreamble();
1119         }
1120
1121         return tcpreamble.str();
1122 }
1123
1124
1125 docstring const LaTeXFeatures::getTClassHTMLStyles() const
1126 {
1127         DocumentClass const & tclass = params_.documentClass();
1128         odocstringstream tcpreamble;
1129
1130         tcpreamble << tclass.htmlstyles();
1131
1132         list<docstring>::const_iterator cit = usedLayouts_.begin();
1133         list<docstring>::const_iterator end = usedLayouts_.end();
1134         for (; cit != end; ++cit)
1135                 tcpreamble << tclass[*cit].htmlstyle();
1136
1137         cit = usedInsetLayouts_.begin();
1138         end = usedInsetLayouts_.end();
1139         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1140         for (; cit != end; ++cit) {
1141                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1142                 if (it == ils.end())
1143                         continue;
1144                 tcpreamble << it->second.htmlstyle();
1145         }
1146
1147         return tcpreamble.str();
1148 }
1149
1150
1151 namespace {
1152 docstring const getFloatI18nPreamble(docstring const & type,
1153                         docstring const & name, Language const * lang,
1154                         Encoding const & enc, bool const polyglossia)
1155 {
1156         docstring const language = polyglossia ? from_ascii(lang->polyglossia())
1157                                                : from_ascii(lang->babel());
1158         docstring const langenc = from_ascii(lang->encoding()->iconvName());
1159         docstring const texenc = from_ascii(lang->encoding()->latexName());
1160         docstring const bufenc = from_ascii(enc.iconvName());
1161         docstring const s1 = docstring(1, 0xF0000);
1162         docstring const s2 = docstring(1, 0xF0001);
1163         docstring const translated = (langenc == bufenc) ? name
1164                 : from_ascii("\\inputencoding{") + texenc + from_ascii("}")
1165                         + s1 + langenc + s2 + name + s1 + bufenc + s2;
1166
1167         odocstringstream os;
1168         os << "\\addto\\captions" << language
1169            << "{\\renewcommand{\\" << type << "name}{" << translated << "}}\n";
1170         return os.str();
1171 }
1172 }
1173
1174
1175 docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel, bool use_polyglossia) const
1176 {
1177         DocumentClass const & tclass = params_.documentClass();
1178         // collect preamble snippets in a set to prevent multiple identical
1179         // commands (would happen if e.g. both theorem and theorem* are used)
1180         set<docstring> snippets;
1181         typedef LanguageList::const_iterator lang_it;
1182         lang_it const lbeg = UsedLanguages_.begin();
1183         lang_it const lend =  UsedLanguages_.end();
1184         list<docstring>::const_iterator cit = usedLayouts_.begin();
1185         list<docstring>::const_iterator end = usedLayouts_.end();
1186         for (; cit != end; ++cit) {
1187                 // language dependent commands (once per document)
1188                 snippets.insert(tclass[*cit].langpreamble(buffer().language(),
1189                                                 buffer().params().encoding(),
1190                                                 use_polyglossia));
1191                 // commands for language changing (for multilanguage documents)
1192                 if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
1193                         snippets.insert(tclass[*cit].babelpreamble(
1194                                                 buffer().language(),
1195                                                 buffer().params().encoding(),
1196                                                 use_polyglossia));
1197                         for (lang_it lit = lbeg; lit != lend; ++lit)
1198                                 snippets.insert(tclass[*cit].babelpreamble(
1199                                                 *lit,
1200                                                 buffer().params().encoding(),
1201                                                 use_polyglossia));
1202                 }
1203         }
1204         if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
1205                 FloatList const & floats = params_.documentClass().floats();
1206                 UsedFloats::const_iterator fit = usedFloats_.begin();
1207                 UsedFloats::const_iterator fend = usedFloats_.end();
1208                 for (; fit != fend; ++fit) {
1209                         Floating const & fl = floats.getType(fit->first);
1210                         // we assume builtin floats are translated
1211                         if (fl.isPredefined())
1212                                 continue;
1213                         docstring const type = from_ascii(fl.floattype());
1214                         docstring const flname = from_utf8(fl.name());
1215                         docstring name = buffer().language()->translateLayout(fl.name());
1216                         // only request translation if we have a real translation
1217                         // (that differs from the source)
1218                         if (flname != name)
1219                                 snippets.insert(getFloatI18nPreamble(
1220                                                 type, name, buffer().language(),
1221                                                 buffer().params().encoding(),
1222                                                 use_polyglossia));
1223                         for (lang_it lit = lbeg; lit != lend; ++lit) {
1224                                 string const code = (*lit)->code();
1225                                 name = (*lit)->translateLayout(fl.name());
1226                                 // we assume we have a suitable translation if
1227                                 // either the language is English (we need to
1228                                 // translate into English if English is a secondary
1229                                 // language) or if translateIfPossible returns
1230                                 // something different to the English source.
1231                                 bool const have_translation =
1232                                         (flname != name || contains(code, "en"));
1233                                 if (have_translation)
1234                                         snippets.insert(getFloatI18nPreamble(
1235                                                 type, name, *lit,
1236                                                 buffer().params().encoding(),
1237                                                 use_polyglossia));
1238                         }
1239                 }
1240         }
1241
1242         odocstringstream tcpreamble;
1243         set<docstring>::const_iterator const send = snippets.end();
1244         set<docstring>::const_iterator it = snippets.begin();
1245         for (; it != send; ++it)
1246                 tcpreamble << *it;
1247         return tcpreamble.str();
1248 }
1249
1250
1251 docstring const LaTeXFeatures::getLyXSGMLEntities() const
1252 {
1253         // Definition of entities used in the document that are LyX related.
1254         odocstringstream entities;
1255
1256         if (mustProvide("lyxarrow")) {
1257                 entities << "<!ENTITY lyxarrow \"-&gt;\">" << '\n';
1258         }
1259
1260         return entities.str();
1261 }
1262
1263
1264 docstring const LaTeXFeatures::getIncludedFiles(string const & fname) const
1265 {
1266         odocstringstream sgmlpreamble;
1267         // FIXME UNICODE
1268         docstring const basename(from_utf8(onlyPath(fname)));
1269
1270         FileMap::const_iterator end = IncludedFiles_.end();
1271         for (FileMap::const_iterator fi = IncludedFiles_.begin();
1272              fi != end; ++fi)
1273                 // FIXME UNICODE
1274                 sgmlpreamble << "\n<!ENTITY " << fi->first
1275                              << (isSGMLFileName(fi->second) ? " SYSTEM \"" : " \"")
1276                              << makeRelPath(from_utf8(fi->second), basename) << "\">";
1277
1278         return sgmlpreamble.str();
1279 }
1280
1281
1282 void LaTeXFeatures::showStruct() const
1283 {
1284         lyxerr << "LyX needs the following commands when LaTeXing:"
1285                << "\n***** Packages:" << getPackages()
1286                << "\n***** Macros:" << to_utf8(getMacros())
1287                << "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
1288                << "\n***** done." << endl;
1289 }
1290
1291
1292 Buffer const & LaTeXFeatures::buffer() const
1293 {
1294         return *buffer_;
1295 }
1296
1297
1298 void LaTeXFeatures::setBuffer(Buffer const & buffer)
1299 {
1300         buffer_ = &buffer;
1301 }
1302
1303
1304 BufferParams const & LaTeXFeatures::bufferParams() const
1305 {
1306         return params_;
1307 }
1308
1309
1310 void LaTeXFeatures::getFloatDefinitions(odocstream & os) const
1311 {
1312         FloatList const & floats = params_.documentClass().floats();
1313
1314         // Here we will output the code to create the needed float styles.
1315         // We will try to do this as minimal as possible.
1316         // \floatstyle{ruled}
1317         // \newfloat{algorithm}{htbp}{loa}
1318         // \providecommand{\algorithmname}{Algorithm}
1319         // \floatname{algorithm}{\protect\algorithmname}
1320         UsedFloats::const_iterator cit = usedFloats_.begin();
1321         UsedFloats::const_iterator end = usedFloats_.end();
1322         for (; cit != end; ++cit) {
1323                 Floating const & fl = floats.getType(cit->first);
1324
1325                 // For builtin floats we do nothing.
1326                 if (fl.isPredefined())
1327                         continue;
1328
1329                 // We have to special case "table" and "figure"
1330                 if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
1331                         // Output code to modify "table" or "figure"
1332                         // but only if builtin == false
1333                         // and that have to be true at this point in the
1334                         // function.
1335                         docstring const type = from_ascii(fl.floattype());
1336                         docstring const placement = from_ascii(fl.placement());
1337                         docstring const style = from_ascii(fl.style());
1338                         if (!style.empty()) {
1339                                 os << "\\floatstyle{" << style << "}\n"
1340                                    << "\\restylefloat{" << type << "}\n";
1341                         }
1342                         if (!placement.empty()) {
1343                                 os << "\\floatplacement{" << type << "}{"
1344                                    << placement << "}\n";
1345                         }
1346                 } else {
1347                         // The other non builtin floats.
1348
1349                         docstring const type = from_ascii(fl.floattype());
1350                         docstring const placement = from_ascii(fl.placement());
1351                         docstring const ext = from_ascii(fl.ext());
1352                         docstring const within = from_ascii(fl.within());
1353                         docstring const style = from_ascii(fl.style());
1354                         docstring const name =
1355                                 buffer().language()->translateLayout(fl.name());
1356                         os << "\\floatstyle{" << style << "}\n"
1357                            << "\\newfloat{" << type << "}{" << placement
1358                            << "}{" << ext << '}';
1359                         if (!within.empty())
1360                                 os << '[' << within << ']';
1361                         os << '\n'
1362                            << "\\providecommand{\\" << type << "name}{"
1363                            << name << "}\n"
1364                            << "\\floatname{" << type << "}{\\protect\\"
1365                            << type << "name}\n";
1366
1367                         // What missing here is to code to minimalize the code
1368                         // output so that the same floatstyle will not be
1369                         // used several times, when the same style is still in
1370                         // effect. (Lgb)
1371                 }
1372                 if (cit->second)
1373                         os << "\n\\newsubfloat{" << from_ascii(fl.floattype()) << "}\n";
1374         }
1375 }
1376
1377
1378 void LaTeXFeatures::resolveAlternatives()
1379 {
1380         for (Features::iterator it = features_.begin(); it != features_.end();) {
1381                 if (contains(*it, '|')) {
1382                         vector<string> const alternatives = getVectorFromString(*it, "|");
1383                         vector<string>::const_iterator const end = alternatives.end();
1384                         vector<string>::const_iterator ita = alternatives.begin();
1385                         for (; ita != end; ++ita) {
1386                                 if (isRequired(*ita))
1387                                         break;
1388                         }
1389                         if (ita == end)
1390                                 require(alternatives.front());
1391                         features_.erase(it);
1392                         it = features_.begin();
1393                 } else
1394                         ++it;
1395         }
1396 }
1397
1398
1399 } // namespace lyx