src/BufferParams.cpp

   1 /**
   2  * \file BufferParams.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Alfredo Braunstein
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  * \author John Levon
  10  * \author André Pönitz
  11  * \author Martin Vermeer
  12  *
  13  * Full author contact details are available in file CREDITS.
  14  */
  15
  16 #include <config.h>
  17
  18 #include "BufferParams.h"
  19
  20 #include "Author.h"
  21 #include "LayoutFile.h"
  22 #include "BranchList.h"
  23 #include "buffer_funcs.h"
  24 #include "Bullet.h"
  25 #include "Color.h"
  26 #include "ColorSet.h"
  27 #include "Encoding.h"
  28 #include "HSpace.h"
  29 #include "IndicesList.h"
  30 #include "Language.h"
  31 #include "LaTeXFeatures.h"
  32 #include "ModuleList.h"
  33 #include "Font.h"
  34 #include "Lexer.h"
  35 #include "LyXRC.h"
  36 #include "OutputParams.h"
  37 #include "Spacing.h"
  38 #include "TexRow.h"
  39 #include "VSpace.h"
  40 #include "PDFOptions.h"
  41
  42 #include "frontends/alert.h"
  43
  44 #include "insets/InsetListingsParams.h"
  45
  46 #include "support/convert.h"
  47 #include "support/debug.h"
  48 #include "support/docstream.h"
  49 #include "support/FileName.h"
  50 #include "support/filetools.h"
  51 #include "support/gettext.h"
  52 #include "support/Messages.h"
  53 #include "support/Translator.h"
  54 #include "support/lstrings.h"
  55
  56 #include <algorithm>
  57 #include <sstream>
  58
  59 using namespace std;
  60 using namespace lyx::support;
  61
  62
  63 static char const * const string_paragraph_separation[] = {
  64         "indent", "skip", ""
  65 };
  66
  67
  68 static char const * const string_quotes_language[] = {
  69         "english", "swedish", "german", "polish", "french", "danish", ""
  70 };
  71
  72
  73 static char const * const string_papersize[] = {
  74         "default", "custom", "letterpaper", "legalpaper", "executivepaper",
  75         "a0paper", "a1paper", "a2paper", "a3paper",     "a4paper", "a5paper",
  76         "a6paper", "b0paper", "b1paper", "b2paper","b3paper", "b4paper",
  77         "b5paper", "b6paper", "c0paper", "c1paper", "c2paper", "c3paper",
  78         "c4paper", "c5paper", "c6paper", "b0j", "b1j", "b2j", "b3j", "b4j", "b5j",
  79         "b6j", ""
  80 };
  81
  82
  83 static char const * const string_orientation[] = {
  84         "portrait", "landscape", ""
  85 };
  86
  87
  88 static char const * const string_footnotekinds[] = {
  89         "footnote", "margin", "fig", "tab", "alg", "wide-fig", "wide-tab", ""
  90 };
  91
  92
  93 static char const * const tex_graphics[] = {
  94         "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
  95         "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
  96         "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
  97         "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
  98         "xetex", "none", ""
  99 };
 100
 101
 102
 103 namespace lyx {
 104
 105 // Local translators
 106 namespace {
 107
 108 // Paragraph separation
 109 typedef Translator<string, BufferParams::ParagraphSeparation> ParSepTranslator;
 110
 111
 112 ParSepTranslator const init_parseptranslator()
 113 {
 114         ParSepTranslator translator
 115                 (string_paragraph_separation[0], BufferParams::ParagraphIndentSeparation);
 116         translator.addPair(string_paragraph_separation[1], BufferParams::ParagraphSkipSeparation);
 117         return translator;
 118 }
 119
 120
 121 ParSepTranslator const & parseptranslator()
 122 {
 123         static ParSepTranslator translator = init_parseptranslator();
 124         return translator;
 125 }
 126
 127
 128 // Quotes language
 129 typedef Translator<string, InsetQuotes::QuoteLanguage> QuotesLangTranslator;
 130
 131
 132 QuotesLangTranslator const init_quoteslangtranslator()
 133 {
 134         QuotesLangTranslator translator
 135                 (string_quotes_language[0], InsetQuotes::EnglishQuotes);
 136         translator.addPair(string_quotes_language[1], InsetQuotes::SwedishQuotes);
 137         translator.addPair(string_quotes_language[2], InsetQuotes::GermanQuotes);
 138         translator.addPair(string_quotes_language[3], InsetQuotes::PolishQuotes);
 139         translator.addPair(string_quotes_language[4], InsetQuotes::FrenchQuotes);
 140         translator.addPair(string_quotes_language[5], InsetQuotes::DanishQuotes);
 141         return translator;
 142 }
 143
 144
 145 QuotesLangTranslator const & quoteslangtranslator()
 146 {
 147         static QuotesLangTranslator translator = init_quoteslangtranslator();
 148         return translator;
 149 }
 150
 151
 152 // Paper size
 153 typedef Translator<string, PAPER_SIZE> PaperSizeTranslator;
 154
 155
 156 static PaperSizeTranslator initPaperSizeTranslator()
 157 {
 158         PaperSizeTranslator translator(string_papersize[0], PAPER_DEFAULT);
 159         translator.addPair(string_papersize[1], PAPER_CUSTOM);
 160         translator.addPair(string_papersize[2], PAPER_USLETTER);
 161         translator.addPair(string_papersize[3], PAPER_USLEGAL);
 162         translator.addPair(string_papersize[4], PAPER_USEXECUTIVE);
 163         translator.addPair(string_papersize[5], PAPER_A0);
 164         translator.addPair(string_papersize[6], PAPER_A1);
 165         translator.addPair(string_papersize[7], PAPER_A2);
 166         translator.addPair(string_papersize[8], PAPER_A3);
 167         translator.addPair(string_papersize[9], PAPER_A4);
 168         translator.addPair(string_papersize[10], PAPER_A5);
 169         translator.addPair(string_papersize[11], PAPER_A6);
 170         translator.addPair(string_papersize[12], PAPER_B0);
 171         translator.addPair(string_papersize[13], PAPER_B1);
 172         translator.addPair(string_papersize[14], PAPER_B2);
 173         translator.addPair(string_papersize[15], PAPER_B3);
 174         translator.addPair(string_papersize[16], PAPER_B4);
 175         translator.addPair(string_papersize[17], PAPER_B5);
 176         translator.addPair(string_papersize[18], PAPER_B6);
 177         translator.addPair(string_papersize[19], PAPER_C0);
 178         translator.addPair(string_papersize[20], PAPER_C1);
 179         translator.addPair(string_papersize[21], PAPER_C2);
 180         translator.addPair(string_papersize[22], PAPER_C3);
 181         translator.addPair(string_papersize[23], PAPER_C4);
 182         translator.addPair(string_papersize[24], PAPER_C5);
 183         translator.addPair(string_papersize[25], PAPER_C6);
 184         translator.addPair(string_papersize[26], PAPER_JISB0);
 185         translator.addPair(string_papersize[27], PAPER_JISB1);
 186         translator.addPair(string_papersize[28], PAPER_JISB2);
 187         translator.addPair(string_papersize[29], PAPER_JISB3);
 188         translator.addPair(string_papersize[30], PAPER_JISB4);
 189         translator.addPair(string_papersize[31], PAPER_JISB5);
 190         translator.addPair(string_papersize[32], PAPER_JISB6);
 191         return translator;
 192 }
 193
 194
 195 PaperSizeTranslator const & papersizetranslator()
 196 {
 197         static PaperSizeTranslator translator = initPaperSizeTranslator();
 198         return translator;
 199 }
 200
 201
 202 // Paper orientation
 203 typedef Translator<string, PAPER_ORIENTATION> PaperOrientationTranslator;
 204
 205
 206 PaperOrientationTranslator const init_paperorientationtranslator()
 207 {
 208         PaperOrientationTranslator translator(string_orientation[0], ORIENTATION_PORTRAIT);
 209         translator.addPair(string_orientation[1], ORIENTATION_LANDSCAPE);
 210         return translator;
 211 }
 212
 213
 214 PaperOrientationTranslator const & paperorientationtranslator()
 215 {
 216         static PaperOrientationTranslator translator = init_paperorientationtranslator();
 217         return translator;
 218 }
 219
 220
 221 // Page sides
 222 typedef Translator<int, PageSides> SidesTranslator;
 223
 224
 225 SidesTranslator const init_sidestranslator()
 226 {
 227         SidesTranslator translator(1, OneSide);
 228         translator.addPair(2, TwoSides);
 229         return translator;
 230 }
 231
 232
 233 SidesTranslator const & sidestranslator()
 234 {
 235         static SidesTranslator translator = init_sidestranslator();
 236         return translator;
 237 }
 238
 239
 240 // LaTeX packages
 241 typedef Translator<int, BufferParams::Package> PackageTranslator;
 242
 243
 244 PackageTranslator const init_packagetranslator()
 245 {
 246         PackageTranslator translator(0, BufferParams::package_off);
 247         translator.addPair(1, BufferParams::package_auto);
 248         translator.addPair(2, BufferParams::package_on);
 249         return translator;
 250 }
 251
 252
 253 PackageTranslator const & packagetranslator()
 254 {
 255         static PackageTranslator translator = init_packagetranslator();
 256         return translator;
 257 }
 258
 259
 260 // Cite engine
 261 typedef Translator<string, CiteEngine> CiteEngineTranslator;
 262
 263
 264 CiteEngineTranslator const init_citeenginetranslator()
 265 {
 266         CiteEngineTranslator translator("basic", ENGINE_BASIC);
 267         translator.addPair("natbib_numerical", ENGINE_NATBIB_NUMERICAL);
 268         translator.addPair("natbib_authoryear", ENGINE_NATBIB_AUTHORYEAR);
 269         translator.addPair("jurabib", ENGINE_JURABIB);
 270         return translator;
 271 }
 272
 273
 274 CiteEngineTranslator const & citeenginetranslator()
 275 {
 276         static CiteEngineTranslator translator = init_citeenginetranslator();
 277         return translator;
 278 }
 279
 280
 281 // Spacing
 282 typedef Translator<string, Spacing::Space> SpaceTranslator;
 283
 284
 285 SpaceTranslator const init_spacetranslator()
 286 {
 287         SpaceTranslator translator("default", Spacing::Default);
 288         translator.addPair("single", Spacing::Single);
 289         translator.addPair("onehalf", Spacing::Onehalf);
 290         translator.addPair("double", Spacing::Double);
 291         translator.addPair("other", Spacing::Other);
 292         return translator;
 293 }
 294
 295
 296 SpaceTranslator const & spacetranslator()
 297 {
 298         static SpaceTranslator translator = init_spacetranslator();
 299         return translator;
 300 }
 301
 302 } // anon namespace
 303
 304
 305 class BufferParams::Impl
 306 {
 307 public:
 308         Impl();
 309
 310         AuthorList authorlist;
 311         BranchList branchlist;
 312         Bullet temp_bullets[4];
 313         Bullet user_defined_bullets[4];
 314         IndicesList indiceslist;
 315         Spacing spacing;
 316         /** This is the amount of space used for paragraph_separation "skip",
 317          * and for detached paragraphs in "indented" documents.
 318          */
 319         HSpace indentation;
 320         VSpace defskip;
 321         PDFOptions pdfoptions;
 322         LayoutFileIndex baseClass_;
 323 };
 324
 325
 326 BufferParams::Impl::Impl()
 327         : defskip(VSpace::MEDSKIP), baseClass_(string(""))
 328 {
 329         // set initial author
 330         // FIXME UNICODE
 331         authorlist.record(Author(from_utf8(lyxrc.user_name), from_utf8(lyxrc.user_email)));
 332 }
 333
 334
 335 BufferParams::Impl *
 336 BufferParams::MemoryTraits::clone(BufferParams::Impl const * ptr)
 337 {
 338         LASSERT(ptr, /**/);
 339
 340         return new BufferParams::Impl(*ptr);
 341 }
 342
 343
 344 void BufferParams::MemoryTraits::destroy(BufferParams::Impl * ptr)
 345 {
 346         delete ptr;
 347 }
 348
 349
 350 BufferParams::BufferParams()
 351         : pimpl_(new Impl)
 352 {
 353         setBaseClass(defaultBaseclass());
 354         makeDocumentClass();
 355         paragraph_separation = ParagraphIndentSeparation;
 356         quotes_language = InsetQuotes::EnglishQuotes;
 357         fontsize = "default";
 358
 359         /*  PaperLayout */
 360         papersize = PAPER_DEFAULT;
 361         orientation = ORIENTATION_PORTRAIT;
 362         use_geometry = false;
 363         use_amsmath = package_auto;
 364         use_esint = package_auto;
 365         use_mhchem = package_auto;
 366         use_mathdots = package_auto;
 367         cite_engine_ = ENGINE_BASIC;
 368         use_bibtopic = false;
 369         use_indices = false;
 370         trackChanges = false;
 371         outputChanges = false;
 372         use_default_options = true;
 373         maintain_unincluded_children = false;
 374         secnumdepth = 3;
 375         tocdepth = 3;
 376         language = default_language;
 377         fontenc = "global";
 378         fonts_roman = "default";
 379         fonts_sans = "default";
 380         fonts_typewriter = "default";
 381         fonts_default_family = "default";
 382         useNonTeXFonts = false;
 383         fonts_expert_sc = false;
 384         fonts_old_figures = false;
 385         fonts_sans_scale = 100;
 386         fonts_typewriter_scale = 100;
 387         inputenc = "auto";
 388         graphics_driver = "default";
 389         default_output_format = "default";
 390         bibtex_command = "default";
 391         index_command = "default";
 392         sides = OneSide;
 393         columns = 1;
 394         listings_params = string();
 395         pagestyle = "default";
 396         suppress_date = false;
 397         // no color is the default (white)
 398         backgroundcolor = lyx::rgbFromHexName("#ffffff");
 399         isbackgroundcolor = false;
 400         // no color is the default (black)
 401         fontcolor = lyx::rgbFromHexName("#000000");
 402         isfontcolor = false;
 403         // light gray is the default font color for greyed-out notes
 404         notefontcolor = lyx::rgbFromHexName("#cccccc");
 405         boxbgcolor = lyx::rgbFromHexName("#ff0000");
 406         compressed = lyxrc.save_compressed;
 407         for (int iter = 0; iter < 4; ++iter) {
 408                 user_defined_bullet(iter) = ITEMIZE_DEFAULTS[iter];
 409                 temp_bullet(iter) = ITEMIZE_DEFAULTS[iter];
 410         }
 411         // default index
 412         indiceslist().addDefault(B_("Index"));
 413         html_be_strict = false;
 414         html_math_output = MathML;
 415         html_math_img_scale = 1.0;
 416
 417         output_sync = false;
 418         use_refstyle = true;
 419 }
 420
 421
 422 docstring BufferParams::B_(string const & l10n) const
 423 {
 424         LASSERT(language, /**/);
 425         return getMessages(language->code()).get(l10n);
 426 }
 427
 428
 429 AuthorList & BufferParams::authors()
 430 {
 431         return pimpl_->authorlist;
 432 }
 433
 434
 435 AuthorList const & BufferParams::authors() const
 436 {
 437         return pimpl_->authorlist;
 438 }
 439
 440
 441 BranchList & BufferParams::branchlist()
 442 {
 443         return pimpl_->branchlist;
 444 }
 445
 446
 447 BranchList const & BufferParams::branchlist() const
 448 {
 449         return pimpl_->branchlist;
 450 }
 451
 452
 453 IndicesList & BufferParams::indiceslist()
 454 {
 455         return pimpl_->indiceslist;
 456 }
 457
 458
 459 IndicesList const & BufferParams::indiceslist() const
 460 {
 461         return pimpl_->indiceslist;
 462 }
 463
 464
 465 Bullet & BufferParams::temp_bullet(lyx::size_type const index)
 466 {
 467         LASSERT(index < 4, /**/);
 468         return pimpl_->temp_bullets[index];
 469 }
 470
 471
 472 Bullet const & BufferParams::temp_bullet(lyx::size_type const index) const
 473 {
 474         LASSERT(index < 4, /**/);
 475         return pimpl_->temp_bullets[index];
 476 }
 477
 478
 479 Bullet & BufferParams::user_defined_bullet(lyx::size_type const index)
 480 {
 481         LASSERT(index < 4, /**/);
 482         return pimpl_->user_defined_bullets[index];
 483 }
 484
 485
 486 Bullet const & BufferParams::user_defined_bullet(lyx::size_type const index) const
 487 {
 488         LASSERT(index < 4, /**/);
 489         return pimpl_->user_defined_bullets[index];
 490 }
 491
 492
 493 Spacing & BufferParams::spacing()
 494 {
 495         return pimpl_->spacing;
 496 }
 497
 498
 499 Spacing const & BufferParams::spacing() const
 500 {
 501         return pimpl_->spacing;
 502 }
 503
 504
 505 PDFOptions & BufferParams::pdfoptions()
 506 {
 507         return pimpl_->pdfoptions;
 508 }
 509
 510
 511 PDFOptions const & BufferParams::pdfoptions() const
 512 {
 513         return pimpl_->pdfoptions;
 514 }
 515
 516
 517 HSpace const & BufferParams::getIndentation() const
 518 {
 519         return pimpl_->indentation;
 520 }
 521
 522
 523 void BufferParams::setIndentation(HSpace const & indent)
 524 {
 525         pimpl_->indentation = indent;
 526 }
 527
 528
 529 VSpace const & BufferParams::getDefSkip() const
 530 {
 531         return pimpl_->defskip;
 532 }
 533
 534
 535 void BufferParams::setDefSkip(VSpace const & vs)
 536 {
 537         // DEFSKIP will cause an infinite loop
 538         LASSERT(vs.kind() != VSpace::DEFSKIP, return);
 539         pimpl_->defskip = vs;
 540 }
 541
 542
 543 string BufferParams::readToken(Lexer & lex, string const & token,
 544         FileName const & filepath)
 545 {
 546         if (token == "\\textclass") {
 547                 lex.next();
 548                 string const classname = lex.getString();
 549                 // if there exists a local layout file, ignore the system one
 550                 // NOTE: in this case, the textclass (.cls file) is assumed to
 551                 // be available.
 552                 string tcp;
 553                 LayoutFileList & bcl = LayoutFileList::get();
 554                 if (tcp.empty() && !filepath.empty())
 555                         tcp = bcl.addLocalLayout(classname, filepath.absFileName());
 556                 if (!tcp.empty())
 557                         setBaseClass(tcp);
 558                 else
 559                         setBaseClass(classname);
 560                 // We assume that a tex class exists for local or unknown
 561                 // layouts so this warning, will only be given for system layouts.
 562                 if (!baseClass()->isTeXClassAvailable()) {
 563                         docstring const desc =
 564                                 translateIfPossible(from_utf8(baseClass()->description()));
 565                         docstring const prereqs =
 566                                 from_utf8(baseClass()->prerequisites());
 567                         docstring const msg =
 568                                 bformat(_("The selected document class\n"
 569                                                  "\t%1$s\n"
 570                                                  "requires external files that are not available.\n"
 571                                                  "The document class can still be used, but the\n"
 572                                                  "document cannot be compiled until the following\n"
 573                                                  "prerequisites are installed:\n"
 574                                                  "\t%2$s\n"
 575                                                  "See section 3.1.2.2 (Class Availability) of the\n"
 576                                                  "User's Guide for more information."), desc, prereqs);
 577                         frontend::Alert::warning(_("Document class not available"),
 578                                        msg);
 579                 }
 580         } else if (token == "\\begin_preamble") {
 581                 readPreamble(lex);
 582         } else if (token == "\\begin_local_layout") {
 583                 readLocalLayout(lex);
 584         } else if (token == "\\begin_modules") {
 585                 readModules(lex);
 586         } else if (token == "\\begin_removed_modules") {
 587                 readRemovedModules(lex);
 588         } else if (token == "\\begin_includeonly") {
 589                 readIncludeonly(lex);
 590         } else if (token == "\\maintain_unincluded_children") {
 591                 lex >> maintain_unincluded_children;
 592         } else if (token == "\\options") {
 593                 lex.eatLine();
 594                 options = lex.getString();
 595         } else if (token == "\\use_default_options") {
 596                 lex >> use_default_options;
 597         } else if (token == "\\master") {
 598                 lex.eatLine();
 599                 master = lex.getString();
 600         } else if (token == "\\suppress_date") {
 601                 lex >> suppress_date;
 602         } else if (token == "\\language") {
 603                 readLanguage(lex);
 604         } else if (token == "\\inputencoding") {
 605                 lex >> inputenc;
 606         } else if (token == "\\graphics") {
 607                 readGraphicsDriver(lex);
 608         } else if (token == "\\default_output_format") {
 609                 lex >> default_output_format;
 610         } else if (token == "\\bibtex_command") {
 611                 lex.eatLine();
 612                 bibtex_command = lex.getString();
 613         } else if (token == "\\index_command") {
 614                 lex.eatLine();
 615                 index_command = lex.getString();
 616         } else if (token == "\\fontencoding") {
 617                 lex.eatLine();
 618                 fontenc = lex.getString();
 619         } else if (token == "\\font_roman") {
 620                 lex.eatLine();
 621                 fonts_roman = lex.getString();
 622         } else if (token == "\\font_sans") {
 623                 lex.eatLine();
 624                 fonts_sans = lex.getString();
 625         } else if (token == "\\font_typewriter") {
 626                 lex.eatLine();
 627                 fonts_typewriter = lex.getString();
 628         } else if (token == "\\font_default_family") {
 629                 lex >> fonts_default_family;
 630         } else if (token == "\\use_non_tex_fonts") {
 631                 lex >> useNonTeXFonts;
 632         } else if (token == "\\font_sc") {
 633                 lex >> fonts_expert_sc;
 634         } else if (token == "\\font_osf") {
 635                 lex >> fonts_old_figures;
 636         } else if (token == "\\font_sf_scale") {
 637                 lex >> fonts_sans_scale;
 638         } else if (token == "\\font_tt_scale") {
 639                 lex >> fonts_typewriter_scale;
 640         } else if (token == "\\font_cjk") {
 641                 lex >> fonts_cjk;
 642         } else if (token == "\\paragraph_separation") {
 643                 string parsep;
 644                 lex >> parsep;
 645                 paragraph_separation = parseptranslator().find(parsep);
 646         } else if (token == "\\paragraph_indentation") {
 647                 lex.next();
 648                 string indentation = lex.getString();
 649                 pimpl_->indentation = HSpace(indentation);
 650         } else if (token == "\\defskip") {
 651                 lex.next();
 652                 string const defskip = lex.getString();
 653                 pimpl_->defskip = VSpace(defskip);
 654                 if (pimpl_->defskip.kind() == VSpace::DEFSKIP)
 655                         // that is invalid
 656                         pimpl_->defskip = VSpace(VSpace::MEDSKIP);
 657         } else if (token == "\\quotes_language") {
 658                 string quotes_lang;
 659                 lex >> quotes_lang;
 660                 quotes_language = quoteslangtranslator().find(quotes_lang);
 661         } else if (token == "\\papersize") {
 662                 string ppsize;
 663                 lex >> ppsize;
 664                 papersize = papersizetranslator().find(ppsize);
 665         } else if (token == "\\use_geometry") {
 666                 lex >> use_geometry;
 667         } else if (token == "\\use_amsmath") {
 668                 int use_ams;
 669                 lex >> use_ams;
 670                 use_amsmath = packagetranslator().find(use_ams);
 671         } else if (token == "\\use_esint") {
 672                 int useesint;
 673                 lex >> useesint;
 674                 use_esint = packagetranslator().find(useesint);
 675         } else if (token == "\\use_mhchem") {
 676                 int usemhchem;
 677                 lex >> usemhchem;
 678                 use_mhchem = packagetranslator().find(usemhchem);
 679         } else if (token == "\\use_mathdots") {
 680                 int usemathdots;
 681                 lex >> usemathdots;
 682                 use_mathdots = packagetranslator().find(usemathdots);
 683         } else if (token == "\\cite_engine") {
 684                 string engine;
 685                 lex >> engine;
 686                 cite_engine_ = citeenginetranslator().find(engine);
 687         } else if (token == "\\use_bibtopic") {
 688                 lex >> use_bibtopic;
 689         } else if (token == "\\use_indices") {
 690                 lex >> use_indices;
 691         } else if (token == "\\tracking_changes") {
 692                 lex >> trackChanges;
 693         } else if (token == "\\output_changes") {
 694                 lex >> outputChanges;
 695         } else if (token == "\\branch") {
 696                 lex.eatLine();
 697                 docstring branch = lex.getDocString();
 698                 branchlist().add(branch);
 699                 while (true) {
 700                         lex.next();
 701                         string const tok = lex.getString();
 702                         if (tok == "\\end_branch")
 703                                 break;
 704                         Branch * branch_ptr = branchlist().find(branch);
 705                         if (tok == "\\selected") {
 706                                 lex.next();
 707                                 if (branch_ptr)
 708                                         branch_ptr->setSelected(lex.getInteger());
 709                         }
 710                         if (tok == "\\filename_suffix") {
 711                                 lex.next();
 712                                 if (branch_ptr)
 713                                         branch_ptr->setFileNameSuffix(lex.getInteger());
 714                         }
 715                         if (tok == "\\color") {
 716                                 lex.eatLine();
 717                                 string color = lex.getString();
 718                                 if (branch_ptr)
 719                                         branch_ptr->setColor(color);
 720                                 // Update also the Color table:
 721                                 if (color == "none")
 722                                         color = lcolor.getX11Name(Color_background);
 723                                 // FIXME UNICODE
 724                                 lcolor.setColor(to_utf8(branch), color);
 725                         }
 726                 }
 727         } else if (token == "\\index") {
 728                 lex.eatLine();
 729                 docstring index = lex.getDocString();
 730                 docstring shortcut;
 731                 indiceslist().add(index);
 732                 while (true) {
 733                         lex.next();
 734                         string const tok = lex.getString();
 735                         if (tok == "\\end_index")
 736                                 break;
 737                         Index * index_ptr = indiceslist().find(index);
 738                         if (tok == "\\shortcut") {
 739                                 lex.next();
 740                                 shortcut = lex.getDocString();
 741                                 if (index_ptr)
 742                                         index_ptr->setShortcut(shortcut);
 743                         }
 744                         if (tok == "\\color") {
 745                                 lex.eatLine();
 746                                 string color = lex.getString();
 747                                 if (index_ptr)
 748                                         index_ptr->setColor(color);
 749                                 // Update also the Color table:
 750                                 if (color == "none")
 751                                         color = lcolor.getX11Name(Color_background);
 752                                 // FIXME UNICODE
 753                                 if (!shortcut.empty())
 754                                         lcolor.setColor(to_utf8(shortcut), color);
 755                         }
 756                 }
 757         } else if (token == "\\author") {
 758                 lex.eatLine();
 759                 istringstream ss(lex.getString());
 760                 Author a;
 761                 ss >> a;
 762                 author_map[a.bufferId()] = pimpl_->authorlist.record(a);
 763         } else if (token == "\\paperorientation") {
 764                 string orient;
 765                 lex >> orient;
 766                 orientation = paperorientationtranslator().find(orient);
 767         } else if (token == "\\backgroundcolor") {
 768                 lex.eatLine();
 769                 backgroundcolor = lyx::rgbFromHexName(lex.getString());
 770                 isbackgroundcolor = true;
 771         } else if (token == "\\fontcolor") {
 772                 lex.eatLine();
 773                 fontcolor = lyx::rgbFromHexName(lex.getString());
 774                 isfontcolor = true;
 775         } else if (token == "\\notefontcolor") {
 776                 lex.eatLine();
 777                 string color = lex.getString();
 778                 notefontcolor = lyx::rgbFromHexName(color);
 779         } else if (token == "\\boxbgcolor") {
 780                 lex.eatLine();
 781                 string color = lex.getString();
 782                 boxbgcolor = lyx::rgbFromHexName(color);
 783         } else if (token == "\\paperwidth") {
 784                 lex >> paperwidth;
 785         } else if (token == "\\paperheight") {
 786                 lex >> paperheight;
 787         } else if (token == "\\leftmargin") {
 788                 lex >> leftmargin;
 789         } else if (token == "\\topmargin") {
 790                 lex >> topmargin;
 791         } else if (token == "\\rightmargin") {
 792                 lex >> rightmargin;
 793         } else if (token == "\\bottommargin") {
 794                 lex >> bottommargin;
 795         } else if (token == "\\headheight") {
 796                 lex >> headheight;
 797         } else if (token == "\\headsep") {
 798                 lex >> headsep;
 799         } else if (token == "\\footskip") {
 800                 lex >> footskip;
 801         } else if (token == "\\columnsep") {
 802                 lex >> columnsep;
 803         } else if (token == "\\paperfontsize") {
 804                 lex >> fontsize;
 805         } else if (token == "\\papercolumns") {
 806                 lex >> columns;
 807         } else if (token == "\\listings_params") {
 808                 string par;
 809                 lex >> par;
 810                 listings_params = InsetListingsParams(par).params();
 811         } else if (token == "\\papersides") {
 812                 int psides;
 813                 lex >> psides;
 814                 sides = sidestranslator().find(psides);
 815         } else if (token == "\\paperpagestyle") {
 816                 lex >> pagestyle;
 817         } else if (token == "\\bullet") {
 818                 readBullets(lex);
 819         } else if (token == "\\bulletLaTeX") {
 820                 readBulletsLaTeX(lex);
 821         } else if (token == "\\secnumdepth") {
 822                 lex >> secnumdepth;
 823         } else if (token == "\\tocdepth") {
 824                 lex >> tocdepth;
 825         } else if (token == "\\spacing") {
 826                 string nspacing;
 827                 lex >> nspacing;
 828                 string tmp_val;
 829                 if (nspacing == "other") {
 830                         lex >> tmp_val;
 831                 }
 832                 spacing().set(spacetranslator().find(nspacing), tmp_val);
 833         } else if (token == "\\float_placement") {
 834                 lex >> float_placement;
 835
 836         } else if (prefixIs(token, "\\pdf_") || token == "\\use_hyperref") {
 837                 string toktmp = pdfoptions().readToken(lex, token);
 838                 if (!toktmp.empty()) {
 839                         lyxerr << "PDFOptions::readToken(): Unknown token: " <<
 840                                 toktmp << endl;
 841                         return toktmp;
 842                 }
 843         } else if (token == "\\html_math_output") {
 844                 int temp;
 845                 lex >> temp;
 846                 html_math_output = static_cast<MathOutput>(temp);
 847         } else if (token == "\\html_be_strict") {
 848                 lex >> html_be_strict;
 849         } else if (token == "\\html_math_img_scale") {
 850                 lex >> html_math_img_scale;
 851         } else if (token == "\\html_latex_start") {
 852                 lex.eatLine();
 853                 html_latex_start = lex.getString();
 854         } else if (token == "\\html_latex_end") {
 855                 lex.eatLine();
 856                 html_latex_end = lex.getString();
 857         } else if (token == "\\output_sync") {
 858                 lex >> output_sync;
 859         } else if (token == "\\output_sync_macro") {
 860                 lex >> output_sync_macro;
 861         } else if (token == "\\use_refstyle") {
 862                 lex >> use_refstyle;
 863         } else {
 864                 lyxerr << "BufferParams::readToken(): Unknown token: " <<
 865                         token << endl;
 866                 return token;
 867         }
 868
 869         return string();
 870 }
 871
 872
 873 void BufferParams::writeFile(ostream & os) const
 874 {
 875         // The top of the file is written by the buffer.
 876         // Prints out the buffer info into the .lyx file given by file
 877
 878         // the textclass
 879         os << "\\textclass " << baseClass()->name() << '\n';
 880
 881         // then the preamble
 882         if (!preamble.empty()) {
 883                 // remove '\n' from the end of preamble
 884                 string const tmppreamble = rtrim(preamble, "\n");
 885                 os << "\\begin_preamble\n"
 886                    << tmppreamble
 887                    << "\n\\end_preamble\n";
 888         }
 889
 890         // the options
 891         if (!options.empty()) {
 892                 os << "\\options " << options << '\n';
 893         }
 894
 895         // use the class options defined in the layout?
 896         os << "\\use_default_options "
 897            << convert<string>(use_default_options) << "\n";
 898
 899         // the master document
 900         if (!master.empty()) {
 901                 os << "\\master " << master << '\n';
 902         }
 903
 904         // removed modules
 905         if (!removed_modules_.empty()) {
 906                 os << "\\begin_removed_modules" << '\n';
 907                 list<string>::const_iterator it = removed_modules_.begin();
 908                 list<string>::const_iterator en = removed_modules_.end();
 909                 for (; it != en; it++)
 910                         os << *it << '\n';
 911                 os << "\\end_removed_modules" << '\n';
 912         }
 913
 914         // the modules
 915         if (!layout_modules_.empty()) {
 916                 os << "\\begin_modules" << '\n';
 917                 LayoutModuleList::const_iterator it = layout_modules_.begin();
 918                 LayoutModuleList::const_iterator en = layout_modules_.end();
 919                 for (; it != en; it++)
 920                         os << *it << '\n';
 921                 os << "\\end_modules" << '\n';
 922         }
 923
 924         // includeonly
 925         if (!included_children_.empty()) {
 926                 os << "\\begin_includeonly" << '\n';
 927                 list<string>::const_iterator it = included_children_.begin();
 928                 list<string>::const_iterator en = included_children_.end();
 929                 for (; it != en; it++)
 930                         os << *it << '\n';
 931                 os << "\\end_includeonly" << '\n';
 932         }
 933         os << "\\maintain_unincluded_children "
 934            << convert<string>(maintain_unincluded_children) << '\n';
 935
 936         // local layout information
 937         if (!local_layout.empty()) {
 938                 // remove '\n' from the end
 939                 string const tmplocal = rtrim(local_layout, "\n");
 940                 os << "\\begin_local_layout\n"
 941                    << tmplocal
 942                    << "\n\\end_local_layout\n";
 943         }
 944
 945         // then the text parameters
 946         if (language != ignore_language)
 947                 os << "\\language " << language->lang() << '\n';
 948         os << "\\inputencoding " << inputenc
 949            << "\n\\fontencoding " << fontenc
 950            << "\n\\font_roman " << fonts_roman
 951            << "\n\\font_sans " << fonts_sans
 952            << "\n\\font_typewriter " << fonts_typewriter
 953            << "\n\\font_default_family " << fonts_default_family
 954            << "\n\\use_non_tex_fonts " << convert<string>(useNonTeXFonts)
 955            << "\n\\font_sc " << convert<string>(fonts_expert_sc)
 956            << "\n\\font_osf " << convert<string>(fonts_old_figures)
 957            << "\n\\font_sf_scale " << fonts_sans_scale
 958            << "\n\\font_tt_scale " << fonts_typewriter_scale
 959            << '\n';
 960         if (!fonts_cjk.empty()) {
 961                 os << "\\font_cjk " << fonts_cjk << '\n';
 962         }
 963         os << "\n\\graphics " << graphics_driver << '\n';
 964         os << "\\default_output_format " << default_output_format << '\n';
 965         os << "\\output_sync " << output_sync << '\n';
 966         if (!output_sync_macro.empty())
 967                 os << "\\output_sync_macro \"" << output_sync_macro << "\"\n";
 968         os << "\\bibtex_command " << bibtex_command << '\n';
 969         os << "\\index_command " << index_command << '\n';
 970
 971         if (!float_placement.empty()) {
 972                 os << "\\float_placement " << float_placement << '\n';
 973         }
 974         os << "\\paperfontsize " << fontsize << '\n';
 975
 976         spacing().writeFile(os);
 977         pdfoptions().writeFile(os);
 978
 979         os << "\\papersize " << string_papersize[papersize]
 980            << "\n\\use_geometry " << convert<string>(use_geometry)
 981            << "\n\\use_amsmath " << use_amsmath
 982            << "\n\\use_esint " << use_esint
 983            << "\n\\use_mhchem " << use_mhchem
 984            << "\n\\use_mathdots " << use_mathdots
 985            << "\n\\cite_engine " << citeenginetranslator().find(cite_engine_)
 986            << "\n\\use_bibtopic " << convert<string>(use_bibtopic)
 987            << "\n\\use_indices " << convert<string>(use_indices)
 988            << "\n\\paperorientation " << string_orientation[orientation]
 989            << "\n\\suppress_date " << convert<string>(suppress_date)
 990                  << "\n\\use_refstyle " << use_refstyle
 991            << '\n';
 992         if (isbackgroundcolor == true)
 993                 os << "\\backgroundcolor " << lyx::X11hexname(backgroundcolor) << '\n';
 994         if (isfontcolor == true)
 995                 os << "\\fontcolor " << lyx::X11hexname(fontcolor) << '\n';
 996         if (notefontcolor != lyx::rgbFromHexName("#cccccc"))
 997                 os << "\\notefontcolor " << lyx::X11hexname(notefontcolor) << '\n';
 998         if (boxbgcolor != lyx::rgbFromHexName("#ff0000"))
 999                 os << "\\boxbgcolor " << lyx::X11hexname(boxbgcolor) << '\n';
1000
1001         BranchList::const_iterator it = branchlist().begin();
1002         BranchList::const_iterator end = branchlist().end();
1003         for (; it != end; ++it) {
1004                 os << "\\branch " << to_utf8(it->branch())
1005                    << "\n\\selected " << it->isSelected()
1006                    << "\n\\filename_suffix " << it->hasFileNameSuffix()
1007                    << "\n\\color " << lyx::X11hexname(it->color())
1008                    << "\n\\end_branch"
1009                    << "\n";
1010         }
1011
1012         IndicesList::const_iterator iit = indiceslist().begin();
1013         IndicesList::const_iterator iend = indiceslist().end();
1014         for (; iit != iend; ++iit) {
1015                 os << "\\index " << to_utf8(iit->index())
1016                    << "\n\\shortcut " << to_utf8(iit->shortcut())
1017                    << "\n\\color " << lyx::X11hexname(iit->color())
1018                    << "\n\\end_index"
1019                    << "\n";
1020         }
1021
1022         if (!paperwidth.empty())
1023                 os << "\\paperwidth "
1024                    << VSpace(paperwidth).asLyXCommand() << '\n';
1025         if (!paperheight.empty())
1026                 os << "\\paperheight "
1027                    << VSpace(paperheight).asLyXCommand() << '\n';
1028         if (!leftmargin.empty())
1029                 os << "\\leftmargin "
1030                    << VSpace(leftmargin).asLyXCommand() << '\n';
1031         if (!topmargin.empty())
1032                 os << "\\topmargin "
1033                    << VSpace(topmargin).asLyXCommand() << '\n';
1034         if (!rightmargin.empty())
1035                 os << "\\rightmargin "
1036                    << VSpace(rightmargin).asLyXCommand() << '\n';
1037         if (!bottommargin.empty())
1038                 os << "\\bottommargin "
1039                    << VSpace(bottommargin).asLyXCommand() << '\n';
1040         if (!headheight.empty())
1041                 os << "\\headheight "
1042                    << VSpace(headheight).asLyXCommand() << '\n';
1043         if (!headsep.empty())
1044                 os << "\\headsep "
1045                    << VSpace(headsep).asLyXCommand() << '\n';
1046         if (!footskip.empty())
1047                 os << "\\footskip "
1048                    << VSpace(footskip).asLyXCommand() << '\n';
1049         if (!columnsep.empty())
1050                 os << "\\columnsep "
1051                          << VSpace(columnsep).asLyXCommand() << '\n';
1052         os << "\\secnumdepth " << secnumdepth
1053            << "\n\\tocdepth " << tocdepth
1054            << "\n\\paragraph_separation "
1055            << string_paragraph_separation[paragraph_separation];
1056         if (!paragraph_separation)
1057                 os << "\n\\paragraph_indentation " << getIndentation().asLyXCommand();
1058         else
1059                 os << "\n\\defskip " << getDefSkip().asLyXCommand();
1060         os << "\n\\quotes_language "
1061            << string_quotes_language[quotes_language]
1062            << "\n\\papercolumns " << columns
1063            << "\n\\papersides " << sides
1064            << "\n\\paperpagestyle " << pagestyle << '\n';
1065         if (!listings_params.empty())
1066                 os << "\\listings_params \"" <<
1067                         InsetListingsParams(listings_params).encodedString() << "\"\n";
1068         for (int i = 0; i < 4; ++i) {
1069                 if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) {
1070                         if (user_defined_bullet(i).getFont() != -1) {
1071                                 os << "\\bullet " << i << " "
1072                                    << user_defined_bullet(i).getFont() << " "
1073                                    << user_defined_bullet(i).getCharacter() << " "
1074                                    << user_defined_bullet(i).getSize() << "\n";
1075                         }
1076                         else {
1077                                 // FIXME UNICODE
1078                                 os << "\\bulletLaTeX " << i << " \""
1079                                    << lyx::to_ascii(user_defined_bullet(i).getText())
1080                                    << "\"\n";
1081                         }
1082                 }
1083         }
1084
1085         os << "\\tracking_changes " << convert<string>(trackChanges) << '\n'
1086                  << "\\output_changes " << convert<string>(outputChanges) << '\n'
1087                  << "\\html_math_output " << html_math_output << '\n'
1088                  << "\\html_be_strict " << convert<string>(html_be_strict) << '\n';
1089
1090         if (html_math_img_scale != 1.0)
1091                 os << "\\html_math_img_scale " << convert<string>(html_math_img_scale) << '\n';
1092         if (!html_latex_start.empty())
1093                 os << "\\html_latex_start " << html_latex_start << '\n';
1094         if (!html_latex_end.empty())
1095                  os << "\\html_latex_end " << html_latex_end << '\n';
1096
1097         os << pimpl_->authorlist;
1098 }
1099
1100
1101 void BufferParams::validate(LaTeXFeatures & features) const
1102 {
1103         features.require(documentClass().requires());
1104
1105         if (outputChanges) {
1106                 bool dvipost    = LaTeXFeatures::isAvailable("dvipost");
1107                 bool xcolorulem = LaTeXFeatures::isAvailable("ulem") &&
1108                                   LaTeXFeatures::isAvailable("xcolor");
1109
1110                 switch (features.runparams().flavor) {
1111                 case OutputParams::LATEX:
1112                         if (dvipost) {
1113                                 features.require("ct-dvipost");
1114                                 features.require("dvipost");
1115                         } else if (xcolorulem) {
1116                                 features.require("ct-xcolor-ulem");
1117                                 features.require("ulem");
1118                                 features.require("xcolor");
1119                         } else {
1120                                 features.require("ct-none");
1121                         }
1122                         break;
1123                 case OutputParams::LUATEX:
1124                 case OutputParams::PDFLATEX:
1125                 case OutputParams::XETEX:
1126                         if (xcolorulem) {
1127                                 features.require("ct-xcolor-ulem");
1128                                 features.require("ulem");
1129                                 features.require("xcolor");
1130                                 // improves color handling in PDF output
1131                                 features.require("pdfcolmk");
1132                         } else {
1133                                 features.require("ct-none");
1134                         }
1135                         break;
1136                 default:
1137                         break;
1138                 }
1139         }
1140
1141         // Floats with 'Here definitely' as default setting.
1142         if (float_placement.find('H') != string::npos)
1143                 features.require("float");
1144
1145         // AMS Style is at document level
1146         if (use_amsmath == package_on
1147             || documentClass().provides("amsmath"))
1148                 features.require("amsmath");
1149         if (use_esint == package_on)
1150                 features.require("esint");
1151         if (use_mhchem == package_on)
1152                 features.require("mhchem");
1153         if (use_mathdots == package_on)
1154                 features.require("mathdots");
1155
1156         // Document-level line spacing
1157         if (spacing().getSpace() != Spacing::Single && !spacing().isDefault())
1158                 features.require("setspace");
1159
1160         // the bullet shapes are buffer level not paragraph level
1161         // so they are tested here
1162         for (int i = 0; i < 4; ++i) {
1163                 if (user_defined_bullet(i) == ITEMIZE_DEFAULTS[i])
1164                         continue;
1165                 int const font = user_defined_bullet(i).getFont();
1166                 if (font == 0) {
1167                         int const c = user_defined_bullet(i).getCharacter();
1168                         if (c == 16
1169                             || c == 17
1170                             || c == 25
1171                             || c == 26
1172                             || c == 31) {
1173                                 features.require("latexsym");
1174                         }
1175                 } else if (font == 1) {
1176                         features.require("amssymb");
1177                 } else if (font >= 2 && font <= 5) {
1178                         features.require("pifont");
1179                 }
1180         }
1181
1182         if (pdfoptions().use_hyperref) {
1183                 features.require("hyperref");
1184                 // due to interferences with babel and hyperref, the color package has to
1185                 // be loaded after hyperref when hyperref is used with the colorlinks
1186                 // option, see http://www.lyx.org/trac/ticket/5291
1187                 if (pdfoptions().colorlinks)
1188                         features.require("color");
1189         }
1190
1191         if (features.runparams().flavor == OutputParams::XETEX
1192             && useNonTeXFonts)
1193                 features.require("polyglossia");
1194
1195         if (language->lang() == "vietnamese")
1196                 features.require("vietnamese");
1197         else if (language->lang() == "japanese")
1198                 features.require("japanese");
1199 }
1200
1201
1202 bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
1203                               TexRow & texrow, FileName const & filepath) const
1204 {
1205         // http://www.tug.org/texmf-dist/doc/latex/base/fixltx2e.pdf
1206         // !! To use the Fix-cm package, load it before \documentclass, and use the command
1207         // \RequirePackage to do so, rather than the normal \usepackage
1208         // Do not to load any other package before the document class, unless you
1209         // have a thorough understanding of the LATEX internals and know exactly what you
1210         // are doing!
1211         if (features.mustProvide("fix-cm")) {
1212                 os << "\\RequirePackage{fix-cm}\n";
1213                 texrow.newline();
1214         }
1215
1216         os << "\\documentclass";
1217
1218         DocumentClass const & tclass = documentClass();
1219
1220         ostringstream clsoptions; // the document class options.
1221
1222         if (tokenPos(tclass.opt_fontsize(),
1223                      '|', fontsize) >= 0) {
1224                 // only write if existing in list (and not default)
1225                 clsoptions << fontsize << "pt,";
1226         }
1227
1228         // all paper sizes except of A4, A5, B5 and the US sizes need the
1229         // geometry package
1230         bool nonstandard_papersize = papersize != PAPER_DEFAULT
1231                 && papersize != PAPER_USLETTER
1232                 && papersize != PAPER_USLEGAL
1233                 && papersize != PAPER_USEXECUTIVE
1234                 && papersize != PAPER_A4
1235                 && papersize != PAPER_A5
1236                 && papersize != PAPER_B5;
1237
1238         if (!use_geometry) {
1239                 switch (papersize) {
1240                 case PAPER_A4:
1241                         clsoptions << "a4paper,";
1242                         break;
1243                 case PAPER_USLETTER:
1244                         clsoptions << "letterpaper,";
1245                         break;
1246                 case PAPER_A5:
1247                         clsoptions << "a5paper,";
1248                         break;
1249                 case PAPER_B5:
1250                         clsoptions << "b5paper,";
1251                         break;
1252                 case PAPER_USEXECUTIVE:
1253                         clsoptions << "executivepaper,";
1254                         break;
1255                 case PAPER_USLEGAL:
1256                         clsoptions << "legalpaper,";
1257                         break;
1258                 case PAPER_DEFAULT:
1259                 case PAPER_A0:
1260                 case PAPER_A1:
1261                 case PAPER_A2:
1262                 case PAPER_A3:
1263                 case PAPER_A6:
1264                 case PAPER_B0:
1265                 case PAPER_B1:
1266                 case PAPER_B2:
1267                 case PAPER_B3:
1268                 case PAPER_B4:
1269                 case PAPER_B6:
1270                 case PAPER_C0:
1271                 case PAPER_C1:
1272                 case PAPER_C2:
1273                 case PAPER_C3:
1274                 case PAPER_C4:
1275                 case PAPER_C5:
1276                 case PAPER_C6:
1277                 case PAPER_JISB0:
1278                 case PAPER_JISB1:
1279                 case PAPER_JISB2:
1280                 case PAPER_JISB3:
1281                 case PAPER_JISB4:
1282                 case PAPER_JISB5:
1283                 case PAPER_JISB6:
1284                 case PAPER_CUSTOM:
1285                         break;
1286                 }
1287         }
1288
1289         // if needed
1290         if (sides != tclass.sides()) {
1291                 switch (sides) {
1292                 case OneSide:
1293                         clsoptions << "oneside,";
1294                         break;
1295                 case TwoSides:
1296                         clsoptions << "twoside,";
1297                         break;
1298                 }
1299         }
1300
1301         // if needed
1302         if (columns != tclass.columns()) {
1303                 if (columns == 2)
1304                         clsoptions << "twocolumn,";
1305                 else
1306                         clsoptions << "onecolumn,";
1307         }
1308
1309         if (!use_geometry
1310             && orientation == ORIENTATION_LANDSCAPE)
1311                 clsoptions << "landscape,";
1312
1313         // language should be a parameter to \documentclass
1314         if (language->babel() == "hebrew"
1315             && default_language->babel() != "hebrew")
1316                 // This seems necessary
1317                 features.useLanguage(default_language);
1318
1319         ostringstream language_options;
1320         bool const use_babel = features.useBabel() && !tclass.provides("babel");
1321         bool const use_polyglossia = features.usePolyglossia();
1322         bool const global = lyxrc.language_global_options;
1323         if (use_babel || (use_polyglossia && global)) {
1324                 language_options << features.getLanguages();
1325                 if (!language->babel().empty()) {
1326                         if (!language_options.str().empty())
1327                                 language_options << ',';
1328                         language_options << language->babel();
1329                 }
1330                 if (global && !features.needBabelLangOptions())
1331                         clsoptions << language_options.str() << ',';
1332         }
1333
1334         // the predefined options from the layout
1335         if (use_default_options && !tclass.options().empty())
1336                 clsoptions << tclass.options() << ',';
1337
1338         // the user-defined options
1339         if (!options.empty()) {
1340                 clsoptions << options << ',';
1341         }
1342
1343         string strOptions(clsoptions.str());
1344         if (!strOptions.empty()) {
1345                 strOptions = rtrim(strOptions, ",");
1346                 // FIXME UNICODE
1347                 os << '[' << from_utf8(strOptions) << ']';
1348         }
1349
1350         os << '{' << from_ascii(tclass.latexname()) << "}\n";
1351         texrow.newline();
1352         // end of \documentclass defs
1353
1354         int nlines;
1355         // if we use fontspec, we have to load the AMS packages here
1356         string const ams = features.loadAMSPackages();
1357         if (useNonTeXFonts && !ams.empty()) {
1358                 os << from_ascii(ams);
1359                 nlines = int(count(ams.begin(), ams.end(), '\n'));
1360                 texrow.newlines(nlines);
1361         }
1362
1363         if (useNonTeXFonts) {
1364                 os << "\\usepackage{fontspec}\n";
1365                 texrow.newline();
1366         }
1367
1368         // font selection must be done before loading fontenc.sty
1369         string const fonts =
1370                 loadFonts(fonts_roman, fonts_sans, fonts_typewriter,
1371                           fonts_expert_sc, fonts_old_figures,
1372                           fonts_sans_scale, fonts_typewriter_scale,
1373                           useNonTeXFonts, features);
1374         if (!fonts.empty()) {
1375                 os << from_ascii(fonts);
1376                 nlines =
1377                         int(count(fonts.begin(), fonts.end(), '\n'));
1378                 texrow.newlines(nlines);
1379         }
1380         if (fonts_default_family != "default")
1381                 os << "\\renewcommand{\\familydefault}{\\"
1382                    << from_ascii(fonts_default_family) << "}\n";
1383
1384         // set font encoding
1385         // for arabic_arabi and farsi we also need to load the LAE and
1386         // LFE encoding
1387         // XeTeX and LuaTeX (with OS fonts) work without fontenc
1388         if (font_encoding() != "default" && language->lang() != "japanese"
1389             && !useNonTeXFonts && !tclass.provides("fontenc")) {
1390                 size_t fars = language_options.str().find("farsi");
1391                 size_t arab = language_options.str().find("arabic");
1392                 if (language->lang() == "arabic_arabi"
1393                         || language->lang() == "farsi" || fars != string::npos
1394                         || arab != string::npos) {
1395                         os << "\\usepackage[" << from_ascii(font_encoding())
1396                            << ",LFE,LAE]{fontenc}\n";
1397                         texrow.newline();
1398                 } else {
1399                         os << "\\usepackage[" << from_ascii(font_encoding())
1400                            << "]{fontenc}\n";
1401                         texrow.newline();
1402                 }
1403         }
1404
1405         // handle inputenc etc.
1406         writeEncodingPreamble(os, features, texrow);
1407
1408         // includeonly
1409         if (!features.runparams().includeall && !included_children_.empty()) {
1410                 os << "\\includeonly{";
1411                 list<string>::const_iterator it = included_children_.begin();
1412                 list<string>::const_iterator en = included_children_.end();
1413                 bool first = true;
1414                 for (; it != en; ++it) {
1415                         string incfile = *it;
1416                         FileName inc = makeAbsPath(incfile, filepath.absFileName());
1417                         string mangled = DocFileName(changeExtension(inc.absFileName(), ".tex")).
1418                         mangledFileName();
1419                         if (!features.runparams().nice)
1420                                 incfile = mangled;
1421                         // \includeonly doesn't want an extension
1422                         incfile = changeExtension(incfile, string());
1423                         incfile = support::latex_path(incfile);
1424                         if (!incfile.empty()) {
1425                                 if (!first)
1426                                         os << ",";
1427                                 os << from_utf8(incfile);
1428                         }
1429                         first = false;
1430                 }
1431                 os << "}\n";
1432         }
1433
1434         if (!listings_params.empty() || features.isRequired("listings")) {
1435                 os << "\\usepackage{listings}\n";
1436                 texrow.newline();
1437         }
1438         if (!listings_params.empty()) {
1439                 os << "\\lstset{";
1440                 // do not test validity because listings_params is
1441                 // supposed to be valid
1442                 string par =
1443                         InsetListingsParams(listings_params).separatedParams(true);
1444                 // we can't support all packages, but we should load the color package
1445                 if (par.find("\\color", 0) != string::npos)
1446                         features.require("color");
1447                 os << from_utf8(par);
1448                 // count the number of newlines
1449                 for (size_t i = 0; i < par.size(); ++i)
1450                         if (par[i] == '\n')
1451                                 texrow.newline();
1452                 os << "}\n";
1453                 texrow.newline();
1454         }
1455         if (!tclass.provides("geometry")
1456             && (use_geometry || nonstandard_papersize)) {
1457                 odocstringstream ods;
1458                 if (!getGraphicsDriver("geometry").empty())
1459                         ods << getGraphicsDriver("geometry");
1460                 if (orientation == ORIENTATION_LANDSCAPE)
1461                         ods << ",landscape";
1462                 switch (papersize) {
1463                 case PAPER_CUSTOM:
1464                         if (!paperwidth.empty())
1465                                 ods << ",paperwidth="
1466                                    << from_ascii(paperwidth);
1467                         if (!paperheight.empty())
1468                                 ods << ",paperheight="
1469                                    << from_ascii(paperheight);
1470                         break;
1471                 case PAPER_USLETTER:
1472                         ods << ",letterpaper";
1473                         break;
1474                 case PAPER_USLEGAL:
1475                         ods << ",legalpaper";
1476                         break;
1477                 case PAPER_USEXECUTIVE:
1478                         ods << ",executivepaper";
1479                         break;
1480                 case PAPER_A0:
1481                         ods << ",a0paper";
1482                         break;
1483                 case PAPER_A1:
1484                         ods << ",a1paper";
1485                         break;
1486                 case PAPER_A2:
1487                         ods << ",a2paper";
1488                         break;
1489                 case PAPER_A3:
1490                         ods << ",a3paper";
1491                         break;
1492                 case PAPER_A4:
1493                         ods << ",a4paper";
1494                         break;
1495                 case PAPER_A5:
1496                         ods << ",a5paper";
1497                         break;
1498                 case PAPER_A6:
1499                         ods << ",a6paper";
1500                         break;
1501                 case PAPER_B0:
1502                         ods << ",b0paper";
1503                         break;
1504                 case PAPER_B1:
1505                         ods << ",b1paper";
1506                         break;
1507                 case PAPER_B2:
1508                         ods << ",b2paper";
1509                         break;
1510                 case PAPER_B3:
1511                         ods << ",b3paper";
1512                         break;
1513                 case PAPER_B4:
1514                         ods << ",b4paper";
1515                         break;
1516                 case PAPER_B5:
1517                         ods << ",b5paper";
1518                         break;
1519                 case PAPER_B6:
1520                         ods << ",b6paper";
1521                         break;
1522                 case PAPER_C0:
1523                         ods << ",c0paper";
1524                         break;
1525                 case PAPER_C1:
1526                         ods << ",c1paper";
1527                         break;
1528                 case PAPER_C2:
1529                         ods << ",c2paper";
1530                         break;
1531                 case PAPER_C3:
1532                         ods << ",c3paper";
1533                         break;
1534                 case PAPER_C4:
1535                         ods << ",c4paper";
1536                         break;
1537                 case PAPER_C5:
1538                         ods << ",c5paper";
1539                         break;
1540                 case PAPER_C6:
1541                         ods << ",c6paper";
1542                         break;
1543                 case PAPER_JISB0:
1544                         ods << ",b0j";
1545                         break;
1546                 case PAPER_JISB1:
1547                         ods << ",b1j";
1548                         break;
1549                 case PAPER_JISB2:
1550                         ods << ",b2j";
1551                         break;
1552                 case PAPER_JISB3:
1553                         ods << ",b3j";
1554                         break;
1555                 case PAPER_JISB4:
1556                         ods << ",b4j";
1557                         break;
1558                 case PAPER_JISB5:
1559                         ods << ",b5j";
1560                         break;
1561                 case PAPER_JISB6:
1562                         ods << ",b6j";
1563                         break;
1564                 default:
1565                         // default papersize ie PAPER_DEFAULT
1566                         switch (lyxrc.default_papersize) {
1567                         case PAPER_DEFAULT: // keep compiler happy
1568                         case PAPER_USLETTER:
1569                                 ods << ",letterpaper";
1570                                 break;
1571                         case PAPER_USLEGAL:
1572                                 ods << ",legalpaper";
1573                                 break;
1574                         case PAPER_USEXECUTIVE:
1575                                 ods << ",executivepaper";
1576                                 break;
1577                         case PAPER_A3:
1578                                 ods << ",a3paper";
1579                                 break;
1580                         case PAPER_A4:
1581                                 ods << ",a4paper";
1582                                 break;
1583                         case PAPER_A5:
1584                                 ods << ",a5paper";
1585                                 break;
1586                         case PAPER_B5:
1587                                 ods << ",b5paper";
1588                                 break;
1589                         case PAPER_A0:
1590                         case PAPER_A1:
1591                         case PAPER_A2:
1592                         case PAPER_A6:
1593                         case PAPER_B0:
1594                         case PAPER_B1:
1595                         case PAPER_B2:
1596                         case PAPER_B3:
1597                         case PAPER_B4:
1598                         case PAPER_B6:
1599                         case PAPER_C0:
1600                         case PAPER_C1:
1601                         case PAPER_C2:
1602                         case PAPER_C3:
1603                         case PAPER_C4:
1604                         case PAPER_C5:
1605                         case PAPER_C6:
1606                         case PAPER_JISB0:
1607                         case PAPER_JISB1:
1608                         case PAPER_JISB2:
1609                         case PAPER_JISB3:
1610                         case PAPER_JISB4:
1611                         case PAPER_JISB5:
1612                         case PAPER_JISB6:
1613                         case PAPER_CUSTOM:
1614                                 break;
1615                         }
1616                 }
1617                 docstring const g_options = trim(ods.str(), ",");
1618                 os << "\\usepackage";
1619                 if (!g_options.empty())
1620                         os << '[' << g_options << ']';
1621                 os << "{geometry}\n";
1622                 texrow.newline();
1623                 // output this only if use_geometry is true
1624                 if (use_geometry) {
1625                         os << "\\geometry{verbose";
1626                         if (!topmargin.empty())
1627                                 os << ",tmargin=" << from_ascii(Length(topmargin).asLatexString());
1628                         if (!bottommargin.empty())
1629                                 os << ",bmargin=" << from_ascii(Length(bottommargin).asLatexString());
1630                         if (!leftmargin.empty())
1631                                 os << ",lmargin=" << from_ascii(Length(leftmargin).asLatexString());
1632                         if (!rightmargin.empty())
1633                                 os << ",rmargin=" << from_ascii(Length(rightmargin).asLatexString());
1634                         if (!headheight.empty())
1635                                 os << ",headheight=" << from_ascii(Length(headheight).asLatexString());
1636                         if (!headsep.empty())
1637                                 os << ",headsep=" << from_ascii(Length(headsep).asLatexString());
1638                         if (!footskip.empty())
1639                                 os << ",footskip=" << from_ascii(Length(footskip).asLatexString());
1640                         if (!columnsep.empty())
1641                                 os << ",columnsep=" << from_ascii(Length(columnsep).asLatexString());
1642                         os << "}\n";
1643                         texrow.newline();
1644                 }
1645         } else if (orientation == ORIENTATION_LANDSCAPE
1646                    || papersize != PAPER_DEFAULT) {
1647                 features.require("papersize");
1648         }
1649
1650         if (tokenPos(tclass.opt_pagestyle(),
1651                      '|', pagestyle) >= 0) {
1652                 if (pagestyle == "fancy") {
1653                         os << "\\usepackage{fancyhdr}\n";
1654                         texrow.newline();
1655                 }
1656                 os << "\\pagestyle{" << from_ascii(pagestyle) << "}\n";
1657                 texrow.newline();
1658         }
1659
1660         // only output when the background color is not default
1661         if (isbackgroundcolor == true) {
1662                 // only require color here, the background color will be defined
1663                 // in LaTeXFeatures.cpp to avoid interferences with the LaTeX
1664                 // package pdfpages
1665                 features.require("color");
1666                 features.require("pagecolor");
1667         }
1668
1669         // only output when the font color is not default
1670         if (isfontcolor == true) {
1671                 // only require color here, the font color will be defined
1672                 // in LaTeXFeatures.cpp to avoid interferences with the LaTeX
1673                 // package pdfpages
1674                 features.require("color");
1675                 features.require("fontcolor");
1676         }
1677
1678         // Only if class has a ToC hierarchy
1679         if (tclass.hasTocLevels()) {
1680                 if (secnumdepth != tclass.secnumdepth()) {
1681                         os << "\\setcounter{secnumdepth}{"
1682                            << secnumdepth
1683                            << "}\n";
1684                         texrow.newline();
1685                 }
1686                 if (tocdepth != tclass.tocdepth()) {
1687                         os << "\\setcounter{tocdepth}{"
1688                            << tocdepth
1689                            << "}\n";
1690                         texrow.newline();
1691                 }
1692         }
1693
1694         if (paragraph_separation) {
1695                 // when skip separation
1696                 switch (getDefSkip().kind()) {
1697                 case VSpace::SMALLSKIP:
1698                         os << "\\setlength{\\parskip}{\\smallskipamount}\n";
1699                         break;
1700                 case VSpace::MEDSKIP:
1701                         os << "\\setlength{\\parskip}{\\medskipamount}\n";
1702                         break;
1703                 case VSpace::BIGSKIP:
1704                         os << "\\setlength{\\parskip}{\\bigskipamount}\n";
1705                         break;
1706                 case VSpace::LENGTH:
1707                         os << "\\setlength{\\parskip}{"
1708                            << from_utf8(getDefSkip().length().asLatexString())
1709                            << "}\n";
1710                         break;
1711                 default: // should never happen // Then delete it.
1712                         os << "\\setlength{\\parskip}{\\medskipamount}\n";
1713                         break;
1714                 }
1715                 texrow.newline();
1716                 os << "\\setlength{\\parindent}{0pt}\n";
1717                 texrow.newline();
1718         } else {
1719                 // when separation by indentation
1720                 // only output something when a width is given
1721                 if (getIndentation().asLyXCommand() != "default") {
1722                         os << "\\setlength{\\parindent}{"
1723                                 << from_utf8(getIndentation().asLatexCommand())
1724                            << "}\n";
1725                         texrow.newline();
1726                 }
1727         }
1728
1729         // Now insert the LyX specific LaTeX commands...
1730         docstring lyxpreamble;
1731
1732         if (output_sync) {
1733                 if (!output_sync_macro.empty())
1734                         lyxpreamble += from_utf8(output_sync_macro) +"\n";
1735                 else if (features.runparams().flavor == OutputParams::LATEX)
1736                         lyxpreamble += "\\usepackage[active]{srcltx}\n";
1737                 else if (features.runparams().flavor == OutputParams::PDFLATEX)
1738                         lyxpreamble += "\\synctex=-1\n";
1739         }
1740
1741         // due to interferences with babel and hyperref, the color package has to
1742         // be loaded (when it is not already loaded) before babel when hyperref
1743         // is used with the colorlinks option, see
1744         // http://www.lyx.org/trac/ticket/5291
1745         // we decided therefore to load color always before babel, see
1746         // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg144349.html
1747         lyxpreamble += from_ascii(features.getColorOptions());
1748
1749         // If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them.
1750         if (use_babel
1751             && (features.isRequired("jurabib")
1752                 || features.isRequired("hyperref")
1753                 || features.isRequired("vietnamese")
1754                 || features.isRequired("japanese"))) {
1755                         // FIXME UNICODE
1756                         lyxpreamble += from_utf8(features.getBabelPresettings());
1757                         lyxpreamble += from_utf8(babelCall(language_options.str(),
1758                                                            features.needBabelLangOptions())) + '\n';
1759                         lyxpreamble += from_utf8(features.getBabelPostsettings());
1760         }
1761
1762         // The optional packages;
1763         lyxpreamble += from_ascii(features.getPackages());
1764
1765         // Additional Indices
1766         if (features.isRequired("splitidx")) {
1767                 IndicesList::const_iterator iit = indiceslist().begin();
1768                 IndicesList::const_iterator iend = indiceslist().end();
1769                 for (; iit != iend; ++iit) {
1770                         lyxpreamble += "\\newindex[";
1771                         lyxpreamble += iit->index();
1772                         lyxpreamble += "]{";
1773                         lyxpreamble += iit->shortcut();
1774                         lyxpreamble += "}\n";
1775                 }
1776         }
1777
1778         // Line spacing
1779         lyxpreamble += from_utf8(spacing().writePreamble(tclass.provides("SetSpace")));
1780
1781         // PDF support.
1782         // * Hyperref manual: "Make sure it comes last of your loaded
1783         //   packages, to give it a fighting chance of not being over-written,
1784         //   since its job is to redefine many LaTeX commands."
1785         // * Email from Heiko Oberdiek: "It is usually better to load babel
1786         //   before hyperref. Then hyperref has a chance to detect babel.
1787         // * Has to be loaded before the "LyX specific LaTeX commands" to
1788         //   avoid errors with algorithm floats.
1789         // use hyperref explicitly if it is required
1790         if (features.isRequired("hyperref")) {
1791                 // pass what we have to stream here, since we need
1792                 // to access the stream itself in PDFOptions.
1793                 os << lyxpreamble;
1794
1795                 int lines =
1796                         int(count(lyxpreamble.begin(), lyxpreamble.end(), '\n'));
1797
1798                 OutputParams tmp_params = features.runparams();
1799                 lines += pdfoptions().writeLaTeX(tmp_params, os,
1800                                         documentClass().provides("hyperref"));
1801                 texrow.newlines(lines);
1802                 // set back for the rest
1803                 lyxpreamble.clear();
1804                 // correctly break URLs with hyperref and dvi output
1805                 if (features.runparams().flavor == OutputParams::LATEX
1806                     && features.isAvailable("breakurl"))
1807                         lyxpreamble += "\\usepackage{breakurl}\n";
1808         } else if (features.isRequired("nameref"))
1809                 // hyperref loads this automatically
1810                 lyxpreamble += "\\usepackage{nameref}\n";
1811
1812         // Will be surrounded by \makeatletter and \makeatother when not empty
1813         docstring atlyxpreamble;
1814
1815         // Some macros LyX will need
1816         docstring tmppreamble(features.getMacros());
1817
1818         if (!tmppreamble.empty())
1819                 atlyxpreamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1820                         "LyX specific LaTeX commands.\n"
1821                         + tmppreamble + '\n';
1822
1823         // the text class specific preamble
1824         tmppreamble = features.getTClassPreamble();
1825         if (!tmppreamble.empty())
1826                 atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1827                         "Textclass specific LaTeX commands.\n"
1828                         + tmppreamble + '\n';
1829
1830         // suppress date if selected
1831         // use \@ifundefined because we cannot be sure that every document class
1832         // has a \date command
1833         if (suppress_date)
1834                 atlyxpreamble += "\\@ifundefined{date}{}{\\date{}}\n";
1835
1836         /* the user-defined preamble */
1837         if (!containsOnly(preamble, " \n\t"))
1838                 // FIXME UNICODE
1839                 atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1840                         "User specified LaTeX commands.\n"
1841                         + from_utf8(preamble) + '\n';
1842
1843         // subfig loads internally the LaTeX package "caption". As
1844         // caption is a very popular package, users will load it in
1845         // the preamble. Therefore we must load subfig behind the
1846         // user-defined preamble and check if the caption package was
1847         // loaded or not. For the case that caption is loaded before
1848         // subfig, there is the subfig option "caption=false". This
1849         // option also works when a koma-script class is used and
1850         // koma's own caption commands are used instead of caption. We
1851         // use \PassOptionsToPackage here because the user could have
1852         // already loaded subfig in the preamble.
1853         if (features.isRequired("subfig")) {
1854                 atlyxpreamble += "\\@ifundefined{showcaptionsetup}{}{%\n"
1855                         " \\PassOptionsToPackage{caption=false}{subfig}}\n"
1856                         "\\usepackage{subfig}\n";
1857         }
1858
1859         // Itemize bullet settings need to be last in case the user
1860         // defines their own bullets that use a package included
1861         // in the user-defined preamble -- ARRae
1862         // Actually it has to be done much later than that
1863         // since some packages like frenchb make modifications
1864         // at \begin{document} time -- JMarc
1865         docstring bullets_def;
1866         for (int i = 0; i < 4; ++i) {
1867                 if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) {
1868                         if (bullets_def.empty())
1869                                 bullets_def += "\\AtBeginDocument{\n";
1870                         bullets_def += "  \\def\\labelitemi";
1871                         switch (i) {
1872                                 // `i' is one less than the item to modify
1873                         case 0:
1874                                 break;
1875                         case 1:
1876                                 bullets_def += 'i';
1877                                 break;
1878                         case 2:
1879                                 bullets_def += "ii";
1880                                 break;
1881                         case 3:
1882                                 bullets_def += 'v';
1883                                 break;
1884                         }
1885                         bullets_def += '{' +
1886                                 user_defined_bullet(i).getText()
1887                                 + "}\n";
1888                 }
1889         }
1890
1891         if (!bullets_def.empty())
1892                 atlyxpreamble += bullets_def + "}\n\n";
1893
1894         if (!atlyxpreamble.empty())
1895                 lyxpreamble += "\n\\makeatletter\n"
1896                         + atlyxpreamble + "\\makeatother\n\n";
1897
1898         // We try to load babel late, in case it interferes with other packages.
1899         // Jurabib and Hyperref have to be called after babel, though.
1900         if (use_babel && !features.isRequired("jurabib")
1901             && !features.isRequired("hyperref")
1902             && !features.isRequired("vietnamese")
1903             && !features.isRequired("japanese")) {
1904                 // FIXME UNICODE
1905                 lyxpreamble += from_utf8(features.getBabelPresettings());
1906                 lyxpreamble += from_utf8(babelCall(language_options.str(),
1907                                                    features.needBabelLangOptions())) + '\n';
1908                 lyxpreamble += from_utf8(features.getBabelPostsettings());
1909         }
1910
1911         // xunicode needs to be loaded at least after amsmath, amssymb,
1912         // esint and the other packages that provide special glyphs
1913         if (features.runparams().flavor == OutputParams::XETEX)
1914                 lyxpreamble += "\\usepackage{xunicode}\n";
1915
1916         // Polyglossia must be loaded last
1917         if (use_polyglossia) {
1918                 // call the package
1919                 lyxpreamble += "\\usepackage{polyglossia}\n";
1920                 // set the main language
1921                 lyxpreamble += "\\setdefaultlanguage";
1922                 if (!language->polyglossiaOpts().empty())
1923                         lyxpreamble += "[" + from_ascii(language->polyglossiaOpts()) + "]";
1924                 lyxpreamble += "{" + from_ascii(language->polyglossia()) + "}\n";
1925                 // now setup the other languages
1926                 std::map<std::string, std::string> const polylangs =
1927                         features.getPolyglossiaLanguages();
1928                 for (std::map<std::string, std::string>::const_iterator mit = polylangs.begin();
1929                      mit != polylangs.end() ; ++mit) {
1930                         lyxpreamble += "\\setotherlanguage";
1931                         if (!mit->second.empty())
1932                                 lyxpreamble += "[" + from_ascii(mit->second) + "]";
1933                         lyxpreamble += "{" + from_ascii(mit->first) + "}\n";
1934                 }
1935         }
1936
1937         docstring const i18npreamble =
1938                 features.getTClassI18nPreamble(use_babel, use_polyglossia);
1939         if (!i18npreamble.empty())
1940                 lyxpreamble += i18npreamble + '\n';
1941
1942         nlines = int(count(lyxpreamble.begin(), lyxpreamble.end(), '\n'));
1943         texrow.newlines(nlines);
1944
1945         os << lyxpreamble;
1946
1947         return use_babel;
1948 }
1949
1950
1951 void BufferParams::useClassDefaults()
1952 {
1953         DocumentClass const & tclass = documentClass();
1954
1955         sides = tclass.sides();
1956         columns = tclass.columns();
1957         pagestyle = tclass.pagestyle();
1958         use_default_options = true;
1959         // Only if class has a ToC hierarchy
1960         if (tclass.hasTocLevels()) {
1961                 secnumdepth = tclass.secnumdepth();
1962                 tocdepth = tclass.tocdepth();
1963         }
1964 }
1965
1966
1967 bool BufferParams::hasClassDefaults() const
1968 {
1969         DocumentClass const & tclass = documentClass();
1970
1971         return sides == tclass.sides()
1972                 && columns == tclass.columns()
1973                 && pagestyle == tclass.pagestyle()
1974                 && use_default_options
1975                 && secnumdepth == tclass.secnumdepth()
1976                 && tocdepth == tclass.tocdepth();
1977 }
1978
1979
1980 DocumentClass const & BufferParams::documentClass() const
1981 {
1982         return *doc_class_;
1983 }
1984
1985
1986 DocumentClass const * BufferParams::documentClassPtr() const
1987 {
1988         return doc_class_;
1989 }
1990
1991
1992 void BufferParams::setDocumentClass(DocumentClass const * const tc)
1993 {
1994         // evil, but this function is evil
1995         doc_class_ = const_cast<DocumentClass *>(tc);
1996 }
1997
1998
1999 bool BufferParams::setBaseClass(string const & classname)
2000 {
2001         LYXERR(Debug::TCLASS, "setBaseClass: " << classname);
2002         LayoutFileList & bcl = LayoutFileList::get();
2003         if (!bcl.haveClass(classname)) {
2004                 docstring s =
2005                         bformat(_("The layout file:\n"
2006                                 "%1$s\n"
2007                                 "could not be found. A default textclass with default\n"
2008                                 "layouts will be used. LyX will not be able to produce\n"
2009                                 "correct output."),
2010                         from_utf8(classname));
2011                 frontend::Alert::error(_("Document class not found"), s);
2012                 bcl.addEmptyClass(classname);
2013         }
2014
2015         bool const success = bcl[classname].load();
2016         if (!success) {
2017                 docstring s =
2018                         bformat(_("Due to some error in it, the layout file:\n"
2019                                 "%1$s\n"
2020                                 "could not be loaded. A default textclass with default\n"
2021                                 "layouts will be used. LyX will not be able to produce\n"
2022                                 "correct output."),
2023                         from_utf8(classname));
2024                 frontend::Alert::error(_("Could not load class"), s);
2025                 bcl.addEmptyClass(classname);
2026         }
2027
2028         pimpl_->baseClass_ = classname;
2029         layout_modules_.adaptToBaseClass(baseClass(), removed_modules_);
2030         return true;
2031 }
2032
2033
2034 LayoutFile const * BufferParams::baseClass() const
2035 {
2036         if (LayoutFileList::get().haveClass(pimpl_->baseClass_))
2037                 return &(LayoutFileList::get()[pimpl_->baseClass_]);
2038         else
2039                 return 0;
2040 }
2041
2042
2043 LayoutFileIndex const & BufferParams::baseClassID() const
2044 {
2045         return pimpl_->baseClass_;
2046 }
2047
2048
2049 void BufferParams::makeDocumentClass()
2050 {
2051         if (!baseClass())
2052                 return;
2053
2054         doc_class_ = &(DocumentClassBundle::get().makeDocumentClass(*baseClass(), layout_modules_));
2055
2056         if (!local_layout.empty()) {
2057                 if (!doc_class_->read(local_layout, TextClass::MODULE)) {
2058                         docstring const msg = _("Error reading internal layout information");
2059                         frontend::Alert::warning(_("Read Error"), msg);
2060                 }
2061         }
2062 }
2063
2064
2065 bool BufferParams::moduleCanBeAdded(string const & modName) const
2066 {
2067         return layout_modules_.moduleCanBeAdded(modName, baseClass());
2068 }
2069
2070
2071 bool BufferParams::addLayoutModule(string const & modName)
2072 {
2073         LayoutModuleList::const_iterator it = layout_modules_.begin();
2074         LayoutModuleList::const_iterator end = layout_modules_.end();
2075         for (; it != end; it++)
2076                 if (*it == modName)
2077                         return false;
2078         layout_modules_.push_back(modName);
2079         return true;
2080 }
2081
2082
2083 Font const BufferParams::getFont() const
2084 {
2085         FontInfo f = documentClass().defaultfont();
2086         if (fonts_default_family == "rmdefault")
2087                 f.setFamily(ROMAN_FAMILY);
2088         else if (fonts_default_family == "sfdefault")
2089                 f.setFamily(SANS_FAMILY);
2090         else if (fonts_default_family == "ttdefault")
2091                 f.setFamily(TYPEWRITER_FAMILY);
2092         return Font(f, language);
2093 }
2094
2095
2096 void BufferParams::readPreamble(Lexer & lex)
2097 {
2098         if (lex.getString() != "\\begin_preamble")
2099                 lyxerr << "Error (BufferParams::readPreamble):"
2100                         "consistency check failed." << endl;
2101
2102         preamble = lex.getLongString("\\end_preamble");
2103 }
2104
2105
2106 void BufferParams::readLocalLayout(Lexer & lex)
2107 {
2108         if (lex.getString() != "\\begin_local_layout")
2109                 lyxerr << "Error (BufferParams::readLocalLayout):"
2110                         "consistency check failed." << endl;
2111
2112         local_layout = lex.getLongString("\\end_local_layout");
2113 }
2114
2115
2116 void BufferParams::readLanguage(Lexer & lex)
2117 {
2118         if (!lex.next()) return;
2119
2120         string const tmptok = lex.getString();
2121
2122         // check if tmptok is part of tex_babel in tex-defs.h
2123         language = languages.getLanguage(tmptok);
2124         if (!language) {
2125                 // Language tmptok was not found
2126                 language = default_language;
2127                 lyxerr << "Warning: Setting language `"
2128                        << tmptok << "' to `" << language->lang()
2129                        << "'." << endl;
2130         }
2131 }
2132
2133
2134 void BufferParams::readGraphicsDriver(Lexer & lex)
2135 {
2136         if (!lex.next())
2137                 return;
2138
2139         string const tmptok = lex.getString();
2140         // check if tmptok is part of tex_graphics in tex_defs.h
2141         int n = 0;
2142         while (true) {
2143                 string const test = tex_graphics[n++];
2144
2145                 if (test == tmptok) {
2146                         graphics_driver = tmptok;
2147                         break;
2148                 }
2149                 if (test.empty()) {
2150                         lex.printError(
2151                                 "Warning: graphics driver `$$Token' not recognized!\n"
2152                                 "         Setting graphics driver to `default'.\n");
2153                         graphics_driver = "default";
2154                         break;
2155                 }
2156         }
2157 }
2158
2159
2160 void BufferParams::readBullets(Lexer & lex)
2161 {
2162         if (!lex.next())
2163                 return;
2164
2165         int const index = lex.getInteger();
2166         lex.next();
2167         int temp_int = lex.getInteger();
2168         user_defined_bullet(index).setFont(temp_int);
2169         temp_bullet(index).setFont(temp_int);
2170         lex >> temp_int;
2171         user_defined_bullet(index).setCharacter(temp_int);
2172         temp_bullet(index).setCharacter(temp_int);
2173         lex >> temp_int;
2174         user_defined_bullet(index).setSize(temp_int);
2175         temp_bullet(index).setSize(temp_int);
2176 }
2177
2178
2179 void BufferParams::readBulletsLaTeX(Lexer & lex)
2180 {
2181         // The bullet class should be able to read this.
2182         if (!lex.next())
2183                 return;
2184         int const index = lex.getInteger();
2185         lex.next(true);
2186         docstring const temp_str = lex.getDocString();
2187
2188         user_defined_bullet(index).setText(temp_str);
2189         temp_bullet(index).setText(temp_str);
2190 }
2191
2192
2193 void BufferParams::readModules(Lexer & lex)
2194 {
2195         if (!lex.eatLine()) {
2196                 lyxerr << "Error (BufferParams::readModules):"
2197                                 "Unexpected end of input." << endl;
2198                 return;
2199         }
2200         while (true) {
2201                 string mod = lex.getString();
2202                 if (mod == "\\end_modules")
2203                         break;
2204                 addLayoutModule(mod);
2205                 lex.eatLine();
2206         }
2207 }
2208
2209
2210 void BufferParams::readRemovedModules(Lexer & lex)
2211 {
2212         if (!lex.eatLine()) {
2213                 lyxerr << "Error (BufferParams::readRemovedModules):"
2214                                 "Unexpected end of input." << endl;
2215                 return;
2216         }
2217         while (true) {
2218                 string mod = lex.getString();
2219                 if (mod == "\\end_removed_modules")
2220                         break;
2221                 removed_modules_.push_back(mod);
2222                 lex.eatLine();
2223         }
2224         // now we want to remove any removed modules that were previously
2225         // added. normally, that will be because default modules were added in
2226         // setBaseClass(), which gets called when \textclass is read at the
2227         // start of the read.
2228         list<string>::const_iterator rit = removed_modules_.begin();
2229         list<string>::const_iterator const ren = removed_modules_.end();
2230         for (; rit != ren; rit++) {
2231                 LayoutModuleList::iterator const mit = layout_modules_.begin();
2232                 LayoutModuleList::iterator const men = layout_modules_.end();
2233                 LayoutModuleList::iterator found = find(mit, men, *rit);
2234                 if (found == men)
2235                         continue;
2236                 layout_modules_.erase(found);
2237         }
2238 }
2239
2240
2241 void BufferParams::readIncludeonly(Lexer & lex)
2242 {
2243         if (!lex.eatLine()) {
2244                 lyxerr << "Error (BufferParams::readIncludeonly):"
2245                                 "Unexpected end of input." << endl;
2246                 return;
2247         }
2248         while (true) {
2249                 string child = lex.getString();
2250                 if (child == "\\end_includeonly")
2251                         break;
2252                 included_children_.push_back(child);
2253                 lex.eatLine();
2254         }
2255 }
2256
2257
2258 string BufferParams::paperSizeName(PapersizePurpose purpose) const
2259 {
2260         char real_papersize = papersize;
2261         if (real_papersize == PAPER_DEFAULT)
2262                 real_papersize = lyxrc.default_papersize;
2263
2264         switch (real_papersize) {
2265         case PAPER_DEFAULT:
2266                 // could be anything, so don't guess
2267                 return string();
2268         case PAPER_CUSTOM: {
2269                 if (purpose == XDVI && !paperwidth.empty() &&
2270                     !paperheight.empty()) {
2271                         // heightxwidth<unit>
2272                         string first = paperwidth;
2273                         string second = paperheight;
2274                         if (orientation == ORIENTATION_LANDSCAPE)
2275                                 first.swap(second);
2276                         // cut off unit.
2277                         return first.erase(first.length() - 2)
2278                                 + "x" + second;
2279                 }
2280                 return string();
2281         }
2282         case PAPER_A0:
2283                 // dvips and dvipdfm do not know this
2284                 if (purpose == DVIPS || purpose == DVIPDFM)
2285                         return string();
2286                 return "a0";
2287         case PAPER_A1:
2288                 if (purpose == DVIPS || purpose == DVIPDFM)
2289                         return string();
2290                 return "a1";
2291         case PAPER_A2:
2292                 if (purpose == DVIPS || purpose == DVIPDFM)
2293                         return string();
2294                 return "a2";
2295         case PAPER_A3:
2296                 return "a3";
2297         case PAPER_A4:
2298                 return "a4";
2299         case PAPER_A5:
2300                 return "a5";
2301         case PAPER_A6:
2302                 if (purpose == DVIPS || purpose == DVIPDFM)
2303                         return string();
2304                 return "a6";
2305         case PAPER_B0:
2306                 if (purpose == DVIPS || purpose == DVIPDFM)
2307                         return string();
2308                 return "b0";
2309         case PAPER_B1:
2310                 if (purpose == DVIPS || purpose == DVIPDFM)
2311                         return string();
2312                 return "b1";
2313         case PAPER_B2:
2314                 if (purpose == DVIPS || purpose == DVIPDFM)
2315                         return string();
2316                 return "b2";
2317         case PAPER_B3:
2318                 if (purpose == DVIPS || purpose == DVIPDFM)
2319                         return string();
2320                 return "b3";
2321         case PAPER_B4:
2322                 // dvipdfm does not know this
2323                 if (purpose == DVIPDFM)
2324                         return string();
2325                 return "b4";
2326         case PAPER_B5:
2327                 if (purpose == DVIPDFM)
2328                         return string();
2329                 return "b5";
2330         case PAPER_B6:
2331                 if (purpose == DVIPS || purpose == DVIPDFM)
2332                         return string();
2333                 return "b6";
2334         case PAPER_C0:
2335                 if (purpose == DVIPS || purpose == DVIPDFM)
2336                         return string();
2337                 return "c0";
2338         case PAPER_C1:
2339                 if (purpose == DVIPS || purpose == DVIPDFM)
2340                         return string();
2341                 return "c1";
2342         case PAPER_C2:
2343                 if (purpose == DVIPS || purpose == DVIPDFM)
2344                         return string();
2345                 return "c2";
2346         case PAPER_C3:
2347                 if (purpose == DVIPS || purpose == DVIPDFM)
2348                         return string();
2349                 return "c3";
2350         case PAPER_C4:
2351                 if (purpose == DVIPS || purpose == DVIPDFM)
2352                         return string();
2353                 return "c4";
2354         case PAPER_C5:
2355                 if (purpose == DVIPS || purpose == DVIPDFM)
2356                         return string();
2357                 return "c5";
2358         case PAPER_C6:
2359                 if (purpose == DVIPS || purpose == DVIPDFM)
2360                         return string();
2361                 return "c6";
2362         case PAPER_JISB0:
2363                 if (purpose == DVIPS || purpose == DVIPDFM)
2364                         return string();
2365                 return "jisb0";
2366         case PAPER_JISB1:
2367                 if (purpose == DVIPS || purpose == DVIPDFM)
2368                         return string();
2369                 return "jisb1";
2370         case PAPER_JISB2:
2371                 if (purpose == DVIPS || purpose == DVIPDFM)
2372                         return string();
2373                 return "jisb2";
2374         case PAPER_JISB3:
2375                 if (purpose == DVIPS || purpose == DVIPDFM)
2376                         return string();
2377                 return "jisb3";
2378         case PAPER_JISB4:
2379                 if (purpose == DVIPS || purpose == DVIPDFM)
2380                         return string();
2381                 return "jisb4";
2382         case PAPER_JISB5:
2383                 if (purpose == DVIPS || purpose == DVIPDFM)
2384                         return string();
2385                 return "jisb5";
2386         case PAPER_JISB6:
2387                 if (purpose == DVIPS || purpose == DVIPDFM)
2388                         return string();
2389                 return "jisb6";
2390         case PAPER_USEXECUTIVE:
2391                 // dvipdfm does not know this
2392                 if (purpose == DVIPDFM)
2393                         return string();
2394                 return "foolscap";
2395         case PAPER_USLEGAL:
2396                 return "legal";
2397         case PAPER_USLETTER:
2398         default:
2399                 if (purpose == XDVI)
2400                         return "us";
2401                 return "letter";
2402         }
2403 }
2404
2405
2406 string const BufferParams::dvips_options() const
2407 {
2408         string result;
2409
2410         if (use_geometry
2411             && papersize == PAPER_CUSTOM
2412             && !lyxrc.print_paper_dimension_flag.empty()
2413             && !paperwidth.empty()
2414             && !paperheight.empty()) {
2415                 // using a custom papersize
2416                 result = lyxrc.print_paper_dimension_flag;
2417                 result += ' ' + paperwidth;
2418                 result += ',' + paperheight;
2419         } else {
2420                 string const paper_option = paperSizeName(DVIPS);
2421                 if (!paper_option.empty() && (paper_option != "letter" ||
2422                     orientation != ORIENTATION_LANDSCAPE)) {
2423                         // dvips won't accept -t letter -t landscape.
2424                         // In all other cases, include the paper size
2425                         // explicitly.
2426                         result = lyxrc.print_paper_flag;
2427                         result += ' ' + paper_option;
2428                 }
2429         }
2430         if (orientation == ORIENTATION_LANDSCAPE &&
2431             papersize != PAPER_CUSTOM)
2432                 result += ' ' + lyxrc.print_landscape_flag;
2433         return result;
2434 }
2435
2436
2437 string const BufferParams::font_encoding() const
2438 {
2439         return (fontenc == "global") ? lyxrc.fontenc : fontenc;
2440 }
2441
2442
2443 string BufferParams::babelCall(string const & lang_opts, bool const langoptions) const
2444 {
2445         if (lyxrc.language_package_selection == LyXRC::LP_CUSTOM)
2446                 return lyxrc.language_custom_package;
2447         // suppress the babel call if there is no BabelName defined
2448         // for the document language in the lib/languages file and if no
2449         // other languages are used (lang_opts is then empty)
2450         if (lang_opts.empty())
2451                 return string();
2452         // either a specific language (AsBabelOptions setting in
2453         // lib/languages) or the prefs require the languages to
2454         // be submitted to babel itself (not the class).
2455         if (langoptions)
2456                 return "\\usepackage[" + lang_opts + "]{babel}";
2457         return "\\usepackage{babel}";
2458 }
2459
2460
2461 docstring BufferParams::getGraphicsDriver(string const & package) const
2462 {
2463         docstring result;
2464
2465         if (package == "geometry") {
2466                 if (graphics_driver == "dvips"
2467                     || graphics_driver == "dvipdfm"
2468                     || graphics_driver == "pdftex"
2469                     || graphics_driver == "vtex")
2470                         result = from_ascii(graphics_driver);
2471                 else if (graphics_driver == "dvipdfmx")
2472                         result = from_ascii("dvipdfm");
2473         }
2474
2475         return result;
2476 }
2477
2478
2479 void BufferParams::writeEncodingPreamble(odocstream & os,
2480                 LaTeXFeatures & features, TexRow & texrow) const
2481 {
2482         // XeTeX does not need this
2483         if (features.runparams().flavor == OutputParams::XETEX)
2484                 return;
2485         // LuaTeX neither, but with tex fonts, we need to load
2486         // the luainputenc package.
2487         if (features.runparams().flavor == OutputParams::LUATEX) {
2488                 if (!useNonTeXFonts) {
2489                         os << "\\usepackage[utf8]{luainputenc}\n";
2490                         texrow.newline();
2491                 }
2492                 return;
2493         }
2494         if (inputenc == "auto") {
2495                 string const doc_encoding =
2496                         language->encoding()->latexName();
2497                 Encoding::Package const package =
2498                         language->encoding()->package();
2499
2500                 // Create a list with all the input encodings used
2501                 // in the document
2502                 set<string> encodings =
2503                         features.getEncodingSet(doc_encoding);
2504
2505                 // If the "japanese" package (i.e. pLaTeX) is used,
2506                 // inputenc must be omitted.
2507                 // see http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129680.html
2508                 if (package == Encoding::japanese)
2509                      features.require("japanese");
2510
2511                 if ((!encodings.empty() || package == Encoding::inputenc)
2512                     && !features.isRequired("japanese")) {
2513                         os << "\\usepackage[";
2514                         set<string>::const_iterator it = encodings.begin();
2515                         set<string>::const_iterator const end = encodings.end();
2516                         if (it != end) {
2517                                 os << from_ascii(*it);
2518                                 ++it;
2519                         }
2520                         for (; it != end; ++it)
2521                                 os << ',' << from_ascii(*it);
2522                         if (package == Encoding::inputenc) {
2523                                 if (!encodings.empty())
2524                                         os << ',';
2525                                 os << from_ascii(doc_encoding);
2526                         }
2527                         os << "]{inputenc}\n";
2528                         texrow.newline();
2529                 }
2530                 if (package == Encoding::CJK || features.mustProvide("CJK")) {
2531                         if (language->encoding()->name() == "utf8-cjk"
2532                             && LaTeXFeatures::isAvailable("CJKutf8"))
2533                                 os << "\\usepackage{CJKutf8}\n";
2534                         else
2535                                 os << "\\usepackage{CJK}\n";
2536                         texrow.newline();
2537                 }
2538         } else if (inputenc != "default") {
2539                 switch (encoding().package()) {
2540                 case Encoding::none:
2541                 case Encoding::japanese:
2542                         break;
2543                 case Encoding::inputenc:
2544                         // do not load inputenc if japanese is used
2545                         if (features.isRequired("japanese"))
2546                                 break;
2547                         os << "\\usepackage[" << from_ascii(inputenc)
2548                            << "]{inputenc}\n";
2549                         texrow.newline();
2550                         break;
2551                 case Encoding::CJK:
2552                         if (encoding().name() == "utf8-cjk"
2553                             && LaTeXFeatures::isAvailable("CJKutf8"))
2554                                 os << "\\usepackage{CJKutf8}\n";
2555                         else
2556                                 os << "\\usepackage{CJK}\n";
2557                         texrow.newline();
2558                         break;
2559                 }
2560         }
2561
2562         // The encoding "armscii8" (for Armenian) is only available when
2563         // the package "armtex" is loaded.
2564         if (language->encoding()->latexName() == "armscii8"
2565             || inputenc == "armscii8") {
2566                 os << "\\usepackage{armtex}\n";
2567                 texrow.newline();
2568         }
2569 }
2570
2571
2572 string const BufferParams::parseFontName(string const & name) const
2573 {
2574         string mangled = name;
2575         size_t const idx = mangled.find('[');
2576         if (idx == string::npos || idx == 0)
2577                 return mangled;
2578         else
2579                 return mangled.substr(0, idx - 1);
2580 }
2581
2582
2583 string const BufferParams::loadFonts(string const & rm,
2584                                      string const & sf, string const & tt,
2585                                      bool const & sc, bool const & osf,
2586                                      int const & sfscale, int const & ttscale,
2587                                      bool const & use_systemfonts,
2588                                      LaTeXFeatures & features) const
2589 {
2590         /* The LaTeX font world is in a flux. In the PSNFSS font interface,
2591            several packages have been replaced by others, that might not
2592            be installed on every system. We have to take care for that
2593            (see psnfss.pdf). We try to support all psnfss fonts as well
2594            as the fonts that have become de facto standard in the LaTeX
2595            world (e.g. Latin Modern). We do not support obsolete fonts
2596            (like PSLatex). In general, it should be possible to mix any
2597            rm font with any sf or tt font, respectively. (JSpitzm)
2598            TODO:
2599                 -- separate math fonts.
2600         */
2601
2602         if (rm == "default" && sf == "default" && tt == "default")
2603                 //nothing to do
2604                 return string();
2605
2606         ostringstream os;
2607
2608         /* Fontspec (XeTeX, LuaTeX): we provide GUI support for oldstyle
2609          * numbers (Numbers=OldStyle) and sf/tt scaling. The Ligatures=TeX/
2610          * Mapping=tex-text option assures TeX ligatures (such as "--")
2611          * are resolved. Note that tt does not use these ligatures.
2612          * TODO:
2613          *    -- add more GUI options?
2614          *    -- add more fonts (fonts for other scripts)
2615          *    -- if there's a way to find out if a font really supports
2616          *       OldStyle, enable/disable the widget accordingly.
2617         */
2618         if (use_systemfonts) {
2619                 // "Mapping=tex-text" and "Ligatures=TeX" are equivalent.
2620                 // However, until v.2 (2010/07/11) fontspec only knew
2621                 // Mapping=tex-text (for XeTeX only); then "Ligatures=TeX"
2622                 // was introduced for both XeTeX and LuaTeX (LuaTeX
2623                 // didn't understand "Mapping=tex-text", while XeTeX
2624                 // understood both. With most recent versions, both
2625                 // variants are understood by both engines. However,
2626                 // we want to provide support for at least TeXLive 2009.
2627                 string const texmapping =
2628                         (features.runparams().flavor == OutputParams::XETEX) ?
2629                         "Mapping=tex-text" : "Ligatures=TeX";
2630                 if (rm != "default") {
2631                         os << "\\setmainfont[" << texmapping;
2632                         if (osf)
2633                                 os << ",Numbers=OldStyle";
2634                         os << "]{" << parseFontName(rm) << "}\n";
2635                 }
2636                 if (sf != "default") {
2637                         string const sans = parseFontName(sf);
2638                         if (sfscale != 100)
2639                                 os << "\\setsansfont[Scale="
2640                                    << float(sfscale) / 100
2641                                    << "," << texmapping << "]{"
2642                                    << sans << "}\n";
2643                         else
2644                                 os << "\\setsansfont[" << texmapping << "]{"
2645                                    << sans << "}\n";
2646                 }
2647                 if (tt != "default") {
2648                         string const mono = parseFontName(tt);
2649                         if (ttscale != 100)
2650                                 os << "\\setmonofont[Scale="
2651                                    << float(ttscale) / 100
2652                                    << "]{"
2653                                    << mono << "}\n";
2654                         else
2655                                 os << "\\setmonofont{"
2656                                    << mono << "}\n";
2657                 }
2658                 return os.str();
2659         }
2660
2661         // ROMAN FONTS
2662         // Computer Modern (must be explicitly selectable -- there might be classes
2663         // that define a different default font!
2664         if (rm == "cmr") {
2665                 os << "\\renewcommand{\\rmdefault}{cmr}\n";
2666                 // osf for Computer Modern needs eco.sty
2667                 if (osf)
2668                         os << "\\usepackage{eco}\n";
2669         }
2670         // Latin Modern Roman
2671         else if (rm == "lmodern")
2672                 os << "\\usepackage{lmodern}\n";
2673         // AE
2674         else if (rm == "ae") {
2675                 // not needed when using OT1 font encoding.
2676                 if (font_encoding() != "default")
2677                         os << "\\usepackage{ae,aecompl}\n";
2678         }
2679         // Times
2680         else if (rm == "times") {
2681                 // try to load the best available package
2682                 if (LaTeXFeatures::isAvailable("mathptmx"))
2683                         os << "\\usepackage{mathptmx}\n";
2684                 else if (LaTeXFeatures::isAvailable("mathptm"))
2685                         os << "\\usepackage{mathptm}\n";
2686                 else
2687                         os << "\\usepackage{times}\n";
2688         }
2689         // Palatino
2690         else if (rm == "palatino") {
2691                 // try to load the best available package
2692                 if (LaTeXFeatures::isAvailable("mathpazo")) {
2693                         os << "\\usepackage";
2694                         if (osf || sc) {
2695                                 os << '[';
2696                                 if (!osf)
2697                                         os << "sc";
2698                                 else
2699                                         // "osf" includes "sc"!
2700                                         os << "osf";
2701                                 os << ']';
2702                         }
2703                         os << "{mathpazo}\n";
2704                 }
2705                 else if (LaTeXFeatures::isAvailable("mathpple"))
2706                         os << "\\usepackage{mathpple}\n";
2707                 else
2708                         os << "\\usepackage{palatino}\n";
2709         }
2710         // Utopia
2711         else if (rm == "utopia") {
2712                 // fourier supersedes utopia.sty, but does
2713                 // not work with OT1 encoding.
2714                 if (LaTeXFeatures::isAvailable("fourier")
2715                     && font_encoding() != "default") {
2716                         os << "\\usepackage";
2717                         if (osf || sc) {
2718                                 os << '[';
2719                                 if (sc)
2720                                         os << "expert";
2721                                 if (osf && sc)
2722                                         os << ',';
2723                                 if (osf)
2724                                         os << "oldstyle";
2725                                 os << ']';
2726                         }
2727                         os << "{fourier}\n";
2728                 }
2729                 else
2730                         os << "\\usepackage{utopia}\n";
2731         }
2732         // Bera (complete fontset)
2733         else if (rm == "bera" && sf == "default" && tt == "default")
2734                 os << "\\usepackage{bera}\n";
2735         // everything else
2736         else if (rm != "default")
2737                 os << "\\usepackage" << "{" << rm << "}\n";
2738
2739         // SANS SERIF
2740         // Helvetica, Bera Sans
2741         if (sf == "helvet" || sf == "berasans") {
2742                 if (sfscale != 100)
2743                         os << "\\usepackage[scaled=" << float(sfscale) / 100
2744                            << "]{" << sf << "}\n";
2745                 else
2746                         os << "\\usepackage{" << sf << "}\n";
2747         }
2748         // Avant Garde
2749         else if (sf == "avant")
2750                 os << "\\usepackage{" << sf << "}\n";
2751         // Computer Modern, Latin Modern, CM Bright
2752         else if (sf != "default")
2753                 os << "\\renewcommand{\\sfdefault}{" << sf << "}\n";
2754
2755         // monospaced/typewriter
2756         // Courier, LuxiMono
2757         if (tt == "luximono" || tt == "beramono") {
2758                 if (ttscale != 100)
2759                         os << "\\usepackage[scaled=" << float(ttscale) / 100
2760                            << "]{" << tt << "}\n";
2761                 else
2762                         os << "\\usepackage{" << tt << "}\n";
2763         }
2764         // Courier
2765         else if (tt == "courier" )
2766                 os << "\\usepackage{" << tt << "}\n";
2767         // Computer Modern, Latin Modern, CM Bright
2768         else if (tt != "default")
2769                 os << "\\renewcommand{\\ttdefault}{" << tt << "}\n";
2770
2771         return os.str();
2772 }
2773
2774
2775 Encoding const & BufferParams::encoding() const
2776 {
2777         // FIXME: actually, we should check for the flavor
2778         // or runparams.isFullyUnicode() here:
2779         // This check will not work with XeTeX/LuaTeX and tex fonts.
2780         // Thus we have to reset the encoding in Buffer::makeLaTeXFile.
2781         if (useNonTeXFonts)
2782                 return *(encodings.fromLaTeXName("utf8-plain"));
2783         if (inputenc == "auto" || inputenc == "default")
2784                 return *language->encoding();
2785         Encoding const * const enc = encodings.fromLaTeXName(inputenc);
2786         if (enc)
2787                 return *enc;
2788         LYXERR0("Unknown inputenc value `" << inputenc
2789                << "'. Using `auto' instead.");
2790         return *language->encoding();
2791 }
2792
2793
2794 CiteEngine BufferParams::citeEngine() const
2795 {
2796         // FIXME the class should provide the numerical/
2797         // authoryear choice
2798         if (documentClass().provides("natbib")
2799             && cite_engine_ != ENGINE_NATBIB_NUMERICAL)
2800                 return ENGINE_NATBIB_AUTHORYEAR;
2801         return cite_engine_;
2802 }
2803
2804
2805 void BufferParams::setCiteEngine(CiteEngine cite_engine)
2806 {
2807         cite_engine_ = cite_engine;
2808 }
2809
2810 } // namespace lyx