src/LaTeXFeatures.cpp

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