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         "subscript",
 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         "ifthen",
 592         "amsthm",
 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_.graphicsDriver == "default"
 620                         || params_.graphicsDriver == "none")
 621                         colors << "\\usepackage{" << package << "}\n";
 622                 else
 623                         colors << "\\usepackage["
 624                                  << params_.graphicsDriver
 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         // esint is preferred for esintoramsmath
 694         if ((mustProvide("amsmath")
 695              && params_.use_amsmath != BufferParams::package_off)
 696             || (mustProvide("esintoramsmath")
 697                 && params_.use_esint == BufferParams::package_off
 698                 && params_.use_amsmath != BufferParams::package_off)) {
 699                 packages << "\\usepackage{amsmath}\n";
 700         } else {
 701                 // amsbsy and amstext are already provided by amsmath
 702                 if (mustProvide("amsbsy"))
 703                         packages << "\\usepackage{amsbsy}\n";
 704                 if (mustProvide("amstext"))
 705                         packages << "\\usepackage{amstext}\n";
 706         }
 707
 708         // wasysym is a simple feature, but it must be after amsmath if both
 709         // are used
 710         // wasysym redefines some integrals (e.g. iint) from amsmath. That
 711         // leads to inconsistent integrals. We only load this package if
 712         // the document does not contain integrals (then isRequired("esint")
 713         // is false) or if esint is used, since esint redefines all relevant
 714         // integral symbols from wasysym and amsmath.
 715         // See http://www.lyx.org/trac/ticket/1942
 716         if (mustProvide("wasysym") &&
 717             (params_.use_esint != BufferParams::package_off || !isRequired("esint")))
 718                 packages << "\\usepackage{wasysym}\n";
 719
 720         // accents must be loaded after amsmath
 721         if (mustProvide("accents"))
 722                 packages << "\\usepackage{accents}\n";
 723
 724         // mathdots must be loaded after amsmath
 725         if (mustProvide("mathdots") &&
 726                 params_.use_mathdots != BufferParams::package_off)
 727                 packages << "\\usepackage{mathdots}\n";
 728
 729         // yhmath must be loaded after amsmath
 730         if (mustProvide("yhmath"))
 731                 packages << "\\usepackage{yhmath}\n";
 732
 733         // [x]color and pdfcolmk are handled in getColorOptions() above
 734
 735         // makeidx.sty
 736         if (isRequired("makeidx") || isRequired("splitidx")) {
 737                 if (!tclass.provides("makeidx") && !isRequired("splitidx"))
 738                         packages << "\\usepackage{makeidx}\n";
 739                 if (!tclass.provides("splitidx") && isRequired("splitidx"))
 740                         packages << "\\usepackage{splitidx}\n";
 741                 packages << "\\makeindex\n";
 742         }
 743
 744         // graphicx.sty
 745         if (mustProvide("graphicx") && params_.graphicsDriver != "none") {
 746                 if (params_.graphicsDriver == "default")
 747                         packages << "\\usepackage{graphicx}\n";
 748                 else
 749                         packages << "\\usepackage["
 750                                  << params_.graphicsDriver
 751                                  << "]{graphicx}\n";
 752         }
 753
 754         // lyxskak.sty --- newer chess support based on skak.sty
 755         if (mustProvide("chess"))
 756                 packages << "\\usepackage[ps,mover]{lyxskak}\n";
 757
 758         // setspace.sty
 759         if (mustProvide("setspace") && !tclass.provides("SetSpace"))
 760                 packages << "\\usepackage{setspace}\n";
 761
 762         // amssymb.sty
 763         if (mustProvide("amssymb")
 764             || params_.use_amsmath == BufferParams::package_on)
 765                 packages << "\\usepackage{amssymb}\n";
 766
 767         // esint must be after amsmath and wasysym, since it will redeclare
 768         // inconsistent integral symbols
 769         if ((mustProvide("esint") || mustProvide("esintoramsmath")) &&
 770             params_.use_esint != BufferParams::package_off)
 771                 packages << "\\usepackage{esint}\n";
 772
 773         // natbib.sty
 774         // Some classes load natbib themselves, but still allow (or even require)
 775         // plain numeric citations (ReVTeX is such a case, see bug 5182).
 776         // This special case is indicated by the "natbib-internal" key.
 777         if (mustProvide("natbib") && !tclass.provides("natbib-internal")) {
 778                 packages << "\\usepackage[";
 779                 if (params_.citeEngine() == ENGINE_NATBIB_NUMERICAL)
 780                         packages << "numbers";
 781                 else
 782                         packages << "authoryear";
 783                 packages << "]{natbib}\n";
 784         }
 785
 786         // jurabib -- we need version 0.6 at least.
 787         if (mustProvide("jurabib"))
 788                 packages << "\\usepackage{jurabib}[2004/01/25]\n";
 789
 790         // xargs -- we need version 1.09 at least
 791         if (mustProvide("xargs"))
 792                 packages << "\\usepackage{xargs}[2008/03/08]\n";
 793
 794         // bibtopic -- the dot provides the aux file naming which
 795         // LyX can detect.
 796         if (mustProvide("bibtopic"))
 797                 packages << "\\usepackage[dot]{bibtopic}\n";
 798
 799         if (mustProvide("xy"))
 800                 packages << "\\usepackage[all]{xy}\n";
 801
 802         if (mustProvide("feyn"))
 803                 packages << "\\usepackage{feyn}\n"; //Diagram
 804
 805         if (mustProvide("ulem"))
 806                 packages << "\\PassOptionsToPackage{normalem}{ulem}\n"
 807                             "\\usepackage{ulem}\n";
 808
 809         if (params_.use_mhchem == BufferParams::package_on ||
 810             (mustProvide("mhchem") &&
 811              params_.use_mhchem != BufferParams::package_off))
 812                 packages << "\\PassOptionsToPackage{version=3}{mhchem}\n"
 813                             "\\usepackage{mhchem}\n";
 814
 815         if (mustProvide("nomencl")) {
 816                 // Make it work with the new and old version of the package,
 817                 // but don't use the compatibility option since it is
 818                 // incompatible to other packages.
 819                 packages << "\\usepackage{nomencl}\n"
 820                             "% the following is useful when we have the old nomencl.sty package\n"
 821                             "\\providecommand{\\printnomenclature}{\\printglossary}\n"
 822                             "\\providecommand{\\makenomenclature}{\\makeglossary}\n"
 823                             "\\makenomenclature\n";
 824         }
 825
 826         return packages.str();
 827 }
 828
 829
 830 string LaTeXFeatures::getPreambleSnippets() const
 831 {
 832         ostringstream snip;
 833         SnippetList::const_iterator pit  = preamble_snippets_.begin();
 834         SnippetList::const_iterator pend = preamble_snippets_.end();
 835         for (; pit != pend; ++pit)
 836                 snip << *pit << '\n';
 837         return snip.str();
 838 }
 839
 840
 841 docstring const LaTeXFeatures::getMacros() const
 842 {
 843         odocstringstream macros;
 844
 845         if (!preamble_snippets_.empty()) {
 846                 macros << '\n';
 847                 macros << from_utf8(getPreambleSnippets());
 848         }
 849
 850         if (mustProvide("papersize")) {
 851                 if (runparams_.flavor == OutputParams::LATEX)
 852                         macros << papersizedvi_def << '\n';
 853                 else
 854                         macros << papersizepdf_def << '\n';
 855         }
 856
 857         if (mustProvide("LyX"))
 858                 macros << lyx_def << '\n';
 859
 860         if (mustProvide("noun"))
 861                 macros << noun_def << '\n';
 862
 863         if (mustProvide("lyxarrow"))
 864                 macros << lyxarrow_def << '\n';
 865
 866         if (!usePolyglossia() && mustProvide("textgreek")) {
 867                 // Avoid a LaTeX error if times fonts are used and the grtimes
 868                 // package is installed but actual fonts are not (bug 6469).
 869                 if (params_.fontsRoman == "times")
 870                         macros << subst(textgreek_def,
 871                                         from_ascii("\\greektext #1"),
 872                                         from_ascii("%\n  \\IfFileExists"
 873                                                    "{grtm10.tfm}{}{\\fontfamily"
 874                                                    "{cmr}}\\greektext #1"))
 875                                << '\n';
 876                 else
 877                         macros << textgreek_def << '\n';
 878         }
 879
 880         if (!usePolyglossia() && mustProvide("textcyr"))
 881                 macros << textcyr_def << '\n';
 882
 883         if (mustProvide("lyxmathsym"))
 884                 macros << lyxmathsym_def << '\n';
 885
 886         if (mustProvide("cedilla"))
 887                 macros << cedilla_def << '\n';
 888
 889         if (mustProvide("subring"))
 890                 macros << subring_def << '\n';
 891
 892         if (mustProvide("subdot"))
 893                 macros << subdot_def << '\n';
 894
 895         if (mustProvide("subhat"))
 896                 macros << subhat_def << '\n';
 897
 898         if (mustProvide("subtilde"))
 899                 macros << subtilde_def << '\n';
 900
 901         if (mustProvide("dacute"))
 902                 macros << dacute_def << '\n';
 903
 904         if (mustProvide("tipasymb"))
 905                 macros << tipasymb_def << '\n';
 906
 907         if (mustProvide("dgrave"))
 908                 macros << dgrave_def << '\n';
 909
 910         if (mustProvide("rcap"))
 911                 macros << rcap_def << '\n';
 912
 913         if (mustProvide("ogonek"))
 914                 macros << ogonek_def << '\n';
 915
 916         // quotes.
 917         if (mustProvide("quotesinglbase"))
 918                 macros << quotesinglbase_def << '\n';
 919         if (mustProvide("quotedblbase"))
 920                 macros << quotedblbase_def << '\n';
 921         if (mustProvide("guilsinglleft"))
 922                 macros << guilsinglleft_def << '\n';
 923         if (mustProvide("guilsinglright"))
 924                 macros << guilsinglright_def << '\n';
 925         if (mustProvide("guillemotleft"))
 926                 macros << guillemotleft_def << '\n';
 927         if (mustProvide("guillemotright"))
 928                 macros << guillemotright_def << '\n';
 929
 930         // Math mode
 931         if (mustProvide("binom") && !isRequired("amsmath"))
 932                 macros << binom_def << '\n';
 933         if (mustProvide("mathcircumflex"))
 934                 macros << mathcircumflex_def << '\n';
 935
 936         // other
 937         if (mustProvide("ParagraphLeftIndent"))
 938                 macros << paragraphleftindent_def;
 939         if (mustProvide("NeedLyXFootnoteCode"))
 940                 macros << floatingfootnote_def;
 941
 942         // some problems with tex->html converters
 943         if (mustProvide("NeedTabularnewline"))
 944                 macros << tabularnewline_def;
 945
 946         // greyed-out environment (note inset)
 947         // the color is specified in the routine
 948         // getColorOptions() to avoid LaTeX-package clashes
 949         if (mustProvide("lyxgreyedout"))
 950                 macros << lyxgreyedout_def;
 951
 952         if (mustProvide("lyxdot"))
 953                 macros << lyxdot_def << '\n';
 954
 955         // floats
 956         getFloatDefinitions(macros);
 957
 958         if (mustProvide("refstyle"))
 959                 macros << lyxref_def << '\n';
 960
 961         // change tracking
 962         if (mustProvide("ct-dvipost"))
 963                 macros << changetracking_dvipost_def;
 964
 965         if (mustProvide("ct-xcolor-ulem")) {
 966                 streamsize const prec = macros.precision(2);
 967
 968                 RGBColor cadd = rgbFromHexName(lcolor.getX11Name(Color_addedtext));
 969                 macros << "\\providecolor{lyxadded}{rgb}{"
 970                        << cadd.r / 255.0 << ',' << cadd.g / 255.0 << ',' << cadd.b / 255.0 << "}\n";
 971
 972                 RGBColor cdel = rgbFromHexName(lcolor.getX11Name(Color_deletedtext));
 973                 macros << "\\providecolor{lyxdeleted}{rgb}{"
 974                        << cdel.r / 255.0 << ',' << cdel.g / 255.0 << ',' << cdel.b / 255.0 << "}\n";
 975
 976                 macros.precision(prec);
 977
 978                 if (isRequired("hyperref"))
 979                         macros << changetracking_xcolor_ulem_hyperref_def;
 980                 else
 981                         macros << changetracking_xcolor_ulem_def;
 982         }
 983
 984         if (mustProvide("ct-none"))
 985                 macros << changetracking_none_def;
 986
 987         return macros.str();
 988 }
 989
 990
 991 string const LaTeXFeatures::getBabelPresettings() const
 992 {
 993         ostringstream tmp;
 994
 995         LanguageList::const_iterator it  = UsedLanguages_.begin();
 996         LanguageList::const_iterator end = UsedLanguages_.end();
 997         for (; it != end; ++it)
 998                 if (!(*it)->babel_presettings().empty())
 999                         tmp << (*it)->babel_presettings() << '\n';
1000         if (!params_.language->babel_presettings().empty())
1001                 tmp << params_.language->babel_presettings() << '\n';
1002
1003         return tmp.str();
1004 }
1005
1006
1007 string const LaTeXFeatures::getBabelPostsettings() const
1008 {
1009         ostringstream tmp;
1010
1011         LanguageList::const_iterator it  = UsedLanguages_.begin();
1012         LanguageList::const_iterator end = UsedLanguages_.end();
1013         for (; it != end; ++it)
1014                 if (!(*it)->babel_postsettings().empty())
1015                         tmp << (*it)->babel_postsettings() << '\n';
1016         if (!params_.language->babel_postsettings().empty())
1017                 tmp << params_.language->babel_postsettings() << '\n';
1018
1019         return tmp.str();
1020 }
1021
1022
1023 bool LaTeXFeatures::needBabelLangOptions() const
1024 {
1025         if (!lyxrc.language_global_options || params_.language->asBabelOptions())
1026                 return true;
1027
1028         LanguageList::const_iterator it  = UsedLanguages_.begin();
1029         LanguageList::const_iterator end = UsedLanguages_.end();
1030         for (; it != end; ++it)
1031                 if ((*it)->asBabelOptions())
1032                         return true;
1033
1034         return false;
1035 }
1036
1037
1038 docstring const LaTeXFeatures::getTClassPreamble() const
1039 {
1040         // the text class specific preamble
1041         DocumentClass const & tclass = params_.documentClass();
1042         odocstringstream tcpreamble;
1043
1044         tcpreamble << tclass.preamble();
1045
1046         list<docstring>::const_iterator cit = usedLayouts_.begin();
1047         list<docstring>::const_iterator end = usedLayouts_.end();
1048         for (; cit != end; ++cit)
1049                 tcpreamble << tclass[*cit].preamble();
1050
1051         cit = usedInsetLayouts_.begin();
1052         end = usedInsetLayouts_.end();
1053         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1054         for (; cit != end; ++cit) {
1055                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1056                 if (it == ils.end())
1057                         continue;
1058                 tcpreamble << it->second.preamble();
1059         }
1060
1061         return tcpreamble.str();
1062 }
1063
1064
1065 docstring const LaTeXFeatures::getTClassHTMLPreamble() const
1066 {
1067         DocumentClass const & tclass = params_.documentClass();
1068         odocstringstream tcpreamble;
1069
1070         tcpreamble << tclass.htmlpreamble();
1071
1072         list<docstring>::const_iterator cit = usedLayouts_.begin();
1073         list<docstring>::const_iterator end = usedLayouts_.end();
1074         for (; cit != end; ++cit)
1075                 tcpreamble << tclass[*cit].htmlpreamble();
1076
1077         cit = usedInsetLayouts_.begin();
1078         end = usedInsetLayouts_.end();
1079         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1080         for (; cit != end; ++cit) {
1081                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1082                 if (it == ils.end())
1083                         continue;
1084                 tcpreamble << it->second.htmlpreamble();
1085         }
1086
1087         return tcpreamble.str();
1088 }
1089
1090
1091 docstring const LaTeXFeatures::getTClassHTMLStyles() const {
1092         DocumentClass const & tclass = params_.documentClass();
1093         odocstringstream tcpreamble;
1094
1095         list<docstring>::const_iterator cit = usedLayouts_.begin();
1096         list<docstring>::const_iterator end = usedLayouts_.end();
1097         for (; cit != end; ++cit)
1098                 tcpreamble << tclass[*cit].htmlstyle();
1099
1100         cit = usedInsetLayouts_.begin();
1101         end = usedInsetLayouts_.end();
1102         TextClass::InsetLayouts const & ils = tclass.insetLayouts();
1103         for (; cit != end; ++cit) {
1104                 TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
1105                 if (it == ils.end())
1106                         continue;
1107                 tcpreamble << it->second.htmlstyle();
1108         }
1109
1110         return tcpreamble.str();
1111 }
1112
1113
1114 namespace {
1115 docstring const getFloatI18nPreamble(docstring const & type, docstring const & name, docstring const & lang)
1116 {
1117         odocstringstream os;
1118         os << "\\addto\\captions" << lang
1119            << "{\\renewcommand{\\" << type << "name}{" << name << "}}\n";
1120         return os.str();
1121 }
1122 }
1123
1124
1125 docstring const LaTeXFeatures::getTClassI18nPreamble(bool use_babel) const
1126 {
1127         DocumentClass const & tclass = params_.documentClass();
1128         // collect preamble snippets in a set to prevent multiple identical
1129         // commands (would happen if e.g. both theorem and theorem* are used)
1130         set<docstring> snippets;
1131         typedef LanguageList::const_iterator lang_it;
1132         lang_it const lbeg = UsedLanguages_.begin();
1133         lang_it const lend =  UsedLanguages_.end();
1134         list<docstring>::const_iterator cit = usedLayouts_.begin();
1135         list<docstring>::const_iterator end = usedLayouts_.end();
1136         for (; cit != end; ++cit) {
1137                 // language dependent commands (once per document)
1138                 snippets.insert(tclass[*cit].langpreamble(buffer().language()));
1139                 // commands for language changing (for multilanguage documents)
1140                 if (use_babel && !UsedLanguages_.empty()) {
1141                         snippets.insert(tclass[*cit].babelpreamble(buffer().language()));
1142                         for (lang_it lit = lbeg; lit != lend; ++lit)
1143                                 snippets.insert(tclass[*cit].babelpreamble(*lit));
1144                 }
1145         }
1146         if (use_babel && !UsedLanguages_.empty()) {
1147                 FloatList const & floats = params_.documentClass().floats();
1148                 UsedFloats::const_iterator fit = usedFloats_.begin();
1149                 UsedFloats::const_iterator fend = usedFloats_.end();
1150                 for (; fit != fend; ++fit) {
1151                         Floating const & fl = floats.getType(fit->first);
1152                         docstring const type = from_ascii(fl.floattype());
1153                         docstring const flname = from_utf8(fl.name());
1154                         docstring name = translateIfPossible(flname,
1155                                 buffer().language()->code());
1156                         snippets.insert(getFloatI18nPreamble(
1157                                 type, name,
1158                                 from_ascii(buffer().language()->babel())));
1159                         for (lang_it lit = lbeg; lit != lend; ++lit) {
1160                                 name = translateIfPossible(flname,
1161                                         (*lit)->code());
1162                                 snippets.insert(getFloatI18nPreamble(
1163                                         type, name,
1164                                         from_ascii((*lit)->babel())));
1165                         }
1166                 }
1167         }
1168
1169         odocstringstream tcpreamble;
1170         set<docstring>::const_iterator const send = snippets.end();
1171         set<docstring>::const_iterator it = snippets.begin();
1172         for (; it != send; ++it)
1173                 tcpreamble << *it;
1174         return tcpreamble.str();
1175 }
1176
1177
1178 docstring const LaTeXFeatures::getLyXSGMLEntities() const
1179 {
1180         // Definition of entities used in the document that are LyX related.
1181         odocstringstream entities;
1182
1183         if (mustProvide("lyxarrow")) {
1184                 entities << "<!ENTITY lyxarrow \"-&gt;\">" << '\n';
1185         }
1186
1187         return entities.str();
1188 }
1189
1190
1191 docstring const LaTeXFeatures::getIncludedFiles(string const & fname) const
1192 {
1193         odocstringstream sgmlpreamble;
1194         // FIXME UNICODE
1195         docstring const basename(from_utf8(onlyPath(fname)));
1196
1197         FileMap::const_iterator end = IncludedFiles_.end();
1198         for (FileMap::const_iterator fi = IncludedFiles_.begin();
1199              fi != end; ++fi)
1200                 // FIXME UNICODE
1201                 sgmlpreamble << "\n<!ENTITY " << fi->first
1202                              << (isSGMLFileName(fi->second) ? " SYSTEM \"" : " \"")
1203                              << makeRelPath(from_utf8(fi->second), basename) << "\">";
1204
1205         return sgmlpreamble.str();
1206 }
1207
1208
1209 void LaTeXFeatures::showStruct() const
1210 {
1211         lyxerr << "LyX needs the following commands when LaTeXing:"
1212                << "\n***** Packages:" << getPackages()
1213                << "\n***** Macros:" << to_utf8(getMacros())
1214                << "\n***** Textclass stuff:" << to_utf8(getTClassPreamble())
1215                << "\n***** done." << endl;
1216 }
1217
1218
1219 Buffer const & LaTeXFeatures::buffer() const
1220 {
1221         return *buffer_;
1222 }
1223
1224
1225 void LaTeXFeatures::setBuffer(Buffer const & buffer)
1226 {
1227         buffer_ = &buffer;
1228 }
1229
1230
1231 BufferParams const & LaTeXFeatures::bufferParams() const
1232 {
1233         return params_;
1234 }
1235
1236
1237 void LaTeXFeatures::getFloatDefinitions(odocstream & os) const
1238 {
1239         FloatList const & floats = params_.documentClass().floats();
1240
1241         // Here we will output the code to create the needed float styles.
1242         // We will try to do this as minimal as possible.
1243         // \floatstyle{ruled}
1244         // \newfloat{algorithm}{htbp}{loa}
1245         // \providecommand{\algorithmname}{Algorithm}
1246         // \floatname{algorithm}{\protect\algorithmname}
1247         UsedFloats::const_iterator cit = usedFloats_.begin();
1248         UsedFloats::const_iterator end = usedFloats_.end();
1249         for (; cit != end; ++cit) {
1250                 Floating const & fl = floats.getType(cit->first);
1251
1252                 // For builtin floats we do nothing.
1253                 if (!fl.needsFloatPkg())
1254                         continue;
1255
1256                 // We have to special case "table" and "figure"
1257                 if (fl.floattype() == "tabular" || fl.floattype() == "figure") {
1258                         // Output code to modify "table" or "figure"
1259                         // but only if builtin == false
1260                         // and that have to be true at this point in the
1261                         // function.
1262                         docstring const type = from_ascii(fl.floattype());
1263                         docstring const placement = from_ascii(fl.placement());
1264                         docstring const style = from_ascii(fl.style());
1265                         if (!style.empty()) {
1266                                 os << "\\floatstyle{" << style << "}\n"
1267                                    << "\\restylefloat{" << type << "}\n";
1268                         }
1269                         if (!placement.empty()) {
1270                                 os << "\\floatplacement{" << type << "}{"
1271                                    << placement << "}\n";
1272                         }
1273                 } else {
1274                         // The other non builtin floats.
1275
1276                         docstring const type = from_ascii(fl.floattype());
1277                         docstring const placement = from_ascii(fl.placement());
1278                         docstring const ext = from_ascii(fl.ext());
1279                         docstring const within = from_ascii(fl.within());
1280                         docstring const style = from_ascii(fl.style());
1281                         docstring const name = translateIfPossible(
1282                                         from_utf8(fl.name()),
1283                                         buffer().language()->code());
1284                         os << "\\floatstyle{" << style << "}\n"
1285                            << "\\newfloat{" << type << "}{" << placement
1286                            << "}{" << ext << '}';
1287                         if (!within.empty())
1288                                 os << '[' << within << ']';
1289                         os << '\n'
1290                            << "\\providecommand{\\" << type << "name}{"
1291                            << name << "}\n"
1292                            << "\\floatname{" << type << "}{\\protect\\"
1293                            << type << "name}\n";
1294
1295                         // What missing here is to code to minimalize the code
1296                         // output so that the same floatstyle will not be
1297                         // used several times, when the same style is still in
1298                         // effect. (Lgb)
1299                 }
1300                 if (cit->second)
1301                         os << "\n\\newsubfloat{" << from_ascii(fl.floattype()) << "}\n";
1302         }
1303 }
1304
1305
1306 } // namespace lyx