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