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