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 of the User's Guide for\n"
 576                                                  "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         os << "\\documentclass";
1206
1207         DocumentClass const & tclass = documentClass();
1208
1209         ostringstream clsoptions; // the document class options.
1210
1211         if (tokenPos(tclass.opt_fontsize(),
1212                      '|', fontsize) >= 0) {
1213                 // only write if existing in list (and not default)
1214                 clsoptions << fontsize << "pt,";
1215         }
1216
1217         // all paper sizes except of A4, A5, B5 and the US sizes need the
1218         // geometry package
1219         bool nonstandard_papersize = papersize != PAPER_DEFAULT
1220                 && papersize != PAPER_USLETTER
1221                 && papersize != PAPER_USLEGAL
1222                 && papersize != PAPER_USEXECUTIVE
1223                 && papersize != PAPER_A4
1224                 && papersize != PAPER_A5
1225                 && papersize != PAPER_B5;
1226
1227         if (!use_geometry) {
1228                 switch (papersize) {
1229                 case PAPER_A4:
1230                         clsoptions << "a4paper,";
1231                         break;
1232                 case PAPER_USLETTER:
1233                         clsoptions << "letterpaper,";
1234                         break;
1235                 case PAPER_A5:
1236                         clsoptions << "a5paper,";
1237                         break;
1238                 case PAPER_B5:
1239                         clsoptions << "b5paper,";
1240                         break;
1241                 case PAPER_USEXECUTIVE:
1242                         clsoptions << "executivepaper,";
1243                         break;
1244                 case PAPER_USLEGAL:
1245                         clsoptions << "legalpaper,";
1246                         break;
1247                 case PAPER_DEFAULT:
1248                 case PAPER_A0:
1249                 case PAPER_A1:
1250                 case PAPER_A2:
1251                 case PAPER_A3:
1252                 case PAPER_A6:
1253                 case PAPER_B0:
1254                 case PAPER_B1:
1255                 case PAPER_B2:
1256                 case PAPER_B3:
1257                 case PAPER_B4:
1258                 case PAPER_B6:
1259                 case PAPER_C0:
1260                 case PAPER_C1:
1261                 case PAPER_C2:
1262                 case PAPER_C3:
1263                 case PAPER_C4:
1264                 case PAPER_C5:
1265                 case PAPER_C6:
1266                 case PAPER_JISB0:
1267                 case PAPER_JISB1:
1268                 case PAPER_JISB2:
1269                 case PAPER_JISB3:
1270                 case PAPER_JISB4:
1271                 case PAPER_JISB5:
1272                 case PAPER_JISB6:
1273                 case PAPER_CUSTOM:
1274                         break;
1275                 }
1276         }
1277
1278         // if needed
1279         if (sides != tclass.sides()) {
1280                 switch (sides) {
1281                 case OneSide:
1282                         clsoptions << "oneside,";
1283                         break;
1284                 case TwoSides:
1285                         clsoptions << "twoside,";
1286                         break;
1287                 }
1288         }
1289
1290         // if needed
1291         if (columns != tclass.columns()) {
1292                 if (columns == 2)
1293                         clsoptions << "twocolumn,";
1294                 else
1295                         clsoptions << "onecolumn,";
1296         }
1297
1298         if (!use_geometry
1299             && orientation == ORIENTATION_LANDSCAPE)
1300                 clsoptions << "landscape,";
1301
1302         // language should be a parameter to \documentclass
1303         if (language->babel() == "hebrew"
1304             && default_language->babel() != "hebrew")
1305                 // This seems necessary
1306                 features.useLanguage(default_language);
1307
1308         ostringstream language_options;
1309         bool const use_babel = features.useBabel() && !tclass.provides("babel");
1310         bool const use_polyglossia = features.usePolyglossia();
1311         bool const global = lyxrc.language_global_options;
1312         if (use_babel || (use_polyglossia && global)) {
1313                 language_options << features.getLanguages();
1314                 if (!language->babel().empty()) {
1315                         if (!language_options.str().empty())
1316                                 language_options << ',';
1317                         language_options << language->babel();
1318                 }
1319                 if (global && !features.needBabelLangOptions())
1320                         clsoptions << language_options.str() << ',';
1321         }
1322
1323         // the predefined options from the layout
1324         if (use_default_options && !tclass.options().empty())
1325                 clsoptions << tclass.options() << ',';
1326
1327         // the user-defined options
1328         if (!options.empty()) {
1329                 clsoptions << options << ',';
1330         }
1331
1332         string strOptions(clsoptions.str());
1333         if (!strOptions.empty()) {
1334                 strOptions = rtrim(strOptions, ",");
1335                 // FIXME UNICODE
1336                 os << '[' << from_utf8(strOptions) << ']';
1337         }
1338
1339         os << '{' << from_ascii(tclass.latexname()) << "}\n";
1340         texrow.newline();
1341         // end of \documentclass defs
1342
1343         if (useNonTeXFonts) {
1344                 os << "\\usepackage{fontspec}\n";
1345                 texrow.newline();
1346         }
1347
1348         // font selection must be done before loading fontenc.sty
1349         string const fonts =
1350                 loadFonts(fonts_roman, fonts_sans,
1351                           fonts_typewriter, fonts_expert_sc, fonts_old_figures,
1352                           fonts_sans_scale, fonts_typewriter_scale, useNonTeXFonts);
1353         if (!fonts.empty()) {
1354                 os << from_ascii(fonts);
1355                 texrow.newline();
1356         }
1357         if (fonts_default_family != "default")
1358                 os << "\\renewcommand{\\familydefault}{\\"
1359                    << from_ascii(fonts_default_family) << "}\n";
1360
1361         // set font encoding
1362         // for arabic_arabi and farsi we also need to load the LAE and
1363         // LFE encoding
1364         // XeTeX and LuaTeX (with OS fonts) work without fontenc
1365         if (font_encoding() != "default" && language->lang() != "japanese"
1366             && !useNonTeXFonts && !tclass.provides("fontenc")) {
1367                 size_t fars = language_options.str().find("farsi");
1368                 size_t arab = language_options.str().find("arabic");
1369                 if (language->lang() == "arabic_arabi"
1370                         || language->lang() == "farsi" || fars != string::npos
1371                         || arab != string::npos) {
1372                         os << "\\usepackage[" << from_ascii(font_encoding())
1373                            << ",LFE,LAE]{fontenc}\n";
1374                         texrow.newline();
1375                 } else {
1376                         os << "\\usepackage[" << from_ascii(font_encoding())
1377                            << "]{fontenc}\n";
1378                         texrow.newline();
1379                 }
1380         }
1381
1382         // handle inputenc etc.
1383         writeEncodingPreamble(os, features, texrow);
1384
1385         // includeonly
1386         if (!features.runparams().includeall && !included_children_.empty()) {
1387                 os << "\\includeonly{";
1388                 list<string>::const_iterator it = included_children_.begin();
1389                 list<string>::const_iterator en = included_children_.end();
1390                 bool first = true;
1391                 for (; it != en; ++it) {
1392                         string incfile = *it;
1393                         FileName inc = makeAbsPath(incfile, filepath.absFileName());
1394                         string mangled = DocFileName(changeExtension(inc.absFileName(), ".tex")).
1395                         mangledFileName();
1396                         if (!features.runparams().nice)
1397                                 incfile = mangled;
1398                         // \includeonly doesn't want an extension
1399                         incfile = changeExtension(incfile, string());
1400                         incfile = support::latex_path(incfile);
1401                         if (!incfile.empty()) {
1402                                 if (!first)
1403                                         os << ",";
1404                                 os << from_utf8(incfile);
1405                         }
1406                         first = false;
1407                 }
1408                 os << "}\n";
1409         }
1410
1411         if (!listings_params.empty() || features.isRequired("listings")) {
1412                 os << "\\usepackage{listings}\n";
1413                 texrow.newline();
1414         }
1415         if (!listings_params.empty()) {
1416                 os << "\\lstset{";
1417                 // do not test validity because listings_params is
1418                 // supposed to be valid
1419                 string par =
1420                         InsetListingsParams(listings_params).separatedParams(true);
1421                 // we can't support all packages, but we should load the color package
1422                 if (par.find("\\color", 0) != string::npos)
1423                         features.require("color");
1424                 os << from_utf8(par);
1425                 // count the number of newlines
1426                 for (size_t i = 0; i < par.size(); ++i)
1427                         if (par[i] == '\n')
1428                                 texrow.newline();
1429                 os << "}\n";
1430                 texrow.newline();
1431         }
1432         if (!tclass.provides("geometry")
1433             && (use_geometry || nonstandard_papersize)) {
1434                 odocstringstream ods;
1435                 if (!getGraphicsDriver("geometry").empty())
1436                         ods << getGraphicsDriver("geometry");
1437                 if (orientation == ORIENTATION_LANDSCAPE)
1438                         ods << ",landscape";
1439                 switch (papersize) {
1440                 case PAPER_CUSTOM:
1441                         if (!paperwidth.empty())
1442                                 ods << ",paperwidth="
1443                                    << from_ascii(paperwidth);
1444                         if (!paperheight.empty())
1445                                 ods << ",paperheight="
1446                                    << from_ascii(paperheight);
1447                         break;
1448                 case PAPER_USLETTER:
1449                         ods << ",letterpaper";
1450                         break;
1451                 case PAPER_USLEGAL:
1452                         ods << ",legalpaper";
1453                         break;
1454                 case PAPER_USEXECUTIVE:
1455                         ods << ",executivepaper";
1456                         break;
1457                 case PAPER_A0:
1458                         ods << ",a0paper";
1459                         break;
1460                 case PAPER_A1:
1461                         ods << ",a1paper";
1462                         break;
1463                 case PAPER_A2:
1464                         ods << ",a2paper";
1465                         break;
1466                 case PAPER_A3:
1467                         ods << ",a3paper";
1468                         break;
1469                 case PAPER_A4:
1470                         ods << ",a4paper";
1471                         break;
1472                 case PAPER_A5:
1473                         ods << ",a5paper";
1474                         break;
1475                 case PAPER_A6:
1476                         ods << ",a6paper";
1477                         break;
1478                 case PAPER_B0:
1479                         ods << ",b0paper";
1480                         break;
1481                 case PAPER_B1:
1482                         ods << ",b1paper";
1483                         break;
1484                 case PAPER_B2:
1485                         ods << ",b2paper";
1486                         break;
1487                 case PAPER_B3:
1488                         ods << ",b3paper";
1489                         break;
1490                 case PAPER_B4:
1491                         ods << ",b4paper";
1492                         break;
1493                 case PAPER_B5:
1494                         ods << ",b5paper";
1495                         break;
1496                 case PAPER_B6:
1497                         ods << ",b6paper";
1498                         break;
1499                 case PAPER_C0:
1500                         ods << ",c0paper";
1501                         break;
1502                 case PAPER_C1:
1503                         ods << ",c1paper";
1504                         break;
1505                 case PAPER_C2:
1506                         ods << ",c2paper";
1507                         break;
1508                 case PAPER_C3:
1509                         ods << ",c3paper";
1510                         break;
1511                 case PAPER_C4:
1512                         ods << ",c4paper";
1513                         break;
1514                 case PAPER_C5:
1515                         ods << ",c5paper";
1516                         break;
1517                 case PAPER_C6:
1518                         ods << ",c6paper";
1519                         break;
1520                 case PAPER_JISB0:
1521                         ods << ",b0j";
1522                         break;
1523                 case PAPER_JISB1:
1524                         ods << ",b1j";
1525                         break;
1526                 case PAPER_JISB2:
1527                         ods << ",b2j";
1528                         break;
1529                 case PAPER_JISB3:
1530                         ods << ",b3j";
1531                         break;
1532                 case PAPER_JISB4:
1533                         ods << ",b4j";
1534                         break;
1535                 case PAPER_JISB5:
1536                         ods << ",b5j";
1537                         break;
1538                 case PAPER_JISB6:
1539                         ods << ",b6j";
1540                         break;
1541                 default:
1542                         // default papersize ie PAPER_DEFAULT
1543                         switch (lyxrc.default_papersize) {
1544                         case PAPER_DEFAULT: // keep compiler happy
1545                         case PAPER_USLETTER:
1546                                 ods << ",letterpaper";
1547                                 break;
1548                         case PAPER_USLEGAL:
1549                                 ods << ",legalpaper";
1550                                 break;
1551                         case PAPER_USEXECUTIVE:
1552                                 ods << ",executivepaper";
1553                                 break;
1554                         case PAPER_A3:
1555                                 ods << ",a3paper";
1556                                 break;
1557                         case PAPER_A4:
1558                                 ods << ",a4paper";
1559                                 break;
1560                         case PAPER_A5:
1561                                 ods << ",a5paper";
1562                                 break;
1563                         case PAPER_B5:
1564                                 ods << ",b5paper";
1565                                 break;
1566                         case PAPER_A0:
1567                         case PAPER_A1:
1568                         case PAPER_A2:
1569                         case PAPER_A6:
1570                         case PAPER_B0:
1571                         case PAPER_B1:
1572                         case PAPER_B2:
1573                         case PAPER_B3:
1574                         case PAPER_B4:
1575                         case PAPER_B6:
1576                         case PAPER_C0:
1577                         case PAPER_C1:
1578                         case PAPER_C2:
1579                         case PAPER_C3:
1580                         case PAPER_C4:
1581                         case PAPER_C5:
1582                         case PAPER_C6:
1583                         case PAPER_JISB0:
1584                         case PAPER_JISB1:
1585                         case PAPER_JISB2:
1586                         case PAPER_JISB3:
1587                         case PAPER_JISB4:
1588                         case PAPER_JISB5:
1589                         case PAPER_JISB6:
1590                         case PAPER_CUSTOM:
1591                                 break;
1592                         }
1593                 }
1594                 docstring const g_options = trim(ods.str(), ",");
1595                 os << "\\usepackage";
1596                 if (!g_options.empty())
1597                         os << '[' << g_options << ']';
1598                 os << "{geometry}\n";
1599                 texrow.newline();
1600                 // output this only if use_geometry is true
1601                 if (use_geometry) {
1602                         os << "\\geometry{verbose";
1603                         if (!topmargin.empty())
1604                                 os << ",tmargin=" << from_ascii(Length(topmargin).asLatexString());
1605                         if (!bottommargin.empty())
1606                                 os << ",bmargin=" << from_ascii(Length(bottommargin).asLatexString());
1607                         if (!leftmargin.empty())
1608                                 os << ",lmargin=" << from_ascii(Length(leftmargin).asLatexString());
1609                         if (!rightmargin.empty())
1610                                 os << ",rmargin=" << from_ascii(Length(rightmargin).asLatexString());
1611                         if (!headheight.empty())
1612                                 os << ",headheight=" << from_ascii(Length(headheight).asLatexString());
1613                         if (!headsep.empty())
1614                                 os << ",headsep=" << from_ascii(Length(headsep).asLatexString());
1615                         if (!footskip.empty())
1616                                 os << ",footskip=" << from_ascii(Length(footskip).asLatexString());
1617                         if (!columnsep.empty())
1618                                 os << ",columnsep=" << from_ascii(Length(columnsep).asLatexString());
1619                         os << "}\n";
1620                         texrow.newline();
1621                 }
1622         } else if (orientation == ORIENTATION_LANDSCAPE
1623                    || papersize != PAPER_DEFAULT) {
1624                 features.require("papersize");
1625         }
1626
1627         if (tokenPos(tclass.opt_pagestyle(),
1628                      '|', pagestyle) >= 0) {
1629                 if (pagestyle == "fancy") {
1630                         os << "\\usepackage{fancyhdr}\n";
1631                         texrow.newline();
1632                 }
1633                 os << "\\pagestyle{" << from_ascii(pagestyle) << "}\n";
1634                 texrow.newline();
1635         }
1636
1637         // only output when the background color is not default
1638         if (isbackgroundcolor == true) {
1639                 // only require color here, the background color will be defined
1640                 // in LaTeXFeatures.cpp to avoid interferences with the LaTeX
1641                 // package pdfpages
1642                 features.require("color");
1643                 features.require("pagecolor");
1644         }
1645
1646         // only output when the font color is not default
1647         if (isfontcolor == true) {
1648                 // only require color here, the font color will be defined
1649                 // in LaTeXFeatures.cpp to avoid interferences with the LaTeX
1650                 // package pdfpages
1651                 features.require("color");
1652                 features.require("fontcolor");
1653         }
1654
1655         // Only if class has a ToC hierarchy
1656         if (tclass.hasTocLevels()) {
1657                 if (secnumdepth != tclass.secnumdepth()) {
1658                         os << "\\setcounter{secnumdepth}{"
1659                            << secnumdepth
1660                            << "}\n";
1661                         texrow.newline();
1662                 }
1663                 if (tocdepth != tclass.tocdepth()) {
1664                         os << "\\setcounter{tocdepth}{"
1665                            << tocdepth
1666                            << "}\n";
1667                         texrow.newline();
1668                 }
1669         }
1670
1671         if (paragraph_separation) {
1672                 // when skip separation
1673                 switch (getDefSkip().kind()) {
1674                 case VSpace::SMALLSKIP:
1675                         os << "\\setlength{\\parskip}{\\smallskipamount}\n";
1676                         break;
1677                 case VSpace::MEDSKIP:
1678                         os << "\\setlength{\\parskip}{\\medskipamount}\n";
1679                         break;
1680                 case VSpace::BIGSKIP:
1681                         os << "\\setlength{\\parskip}{\\bigskipamount}\n";
1682                         break;
1683                 case VSpace::LENGTH:
1684                         os << "\\setlength{\\parskip}{"
1685                            << from_utf8(getDefSkip().length().asLatexString())
1686                            << "}\n";
1687                         break;
1688                 default: // should never happen // Then delete it.
1689                         os << "\\setlength{\\parskip}{\\medskipamount}\n";
1690                         break;
1691                 }
1692                 texrow.newline();
1693                 os << "\\setlength{\\parindent}{0pt}\n";
1694                 texrow.newline();
1695         } else {
1696                 // when separation by indentation
1697                 // only output something when a width is given
1698                 if (getIndentation().asLyXCommand() != "default") {
1699                         os << "\\setlength{\\parindent}{"
1700                                 << from_utf8(getIndentation().asLatexCommand())
1701                            << "}\n";
1702                         texrow.newline();
1703                 }
1704         }
1705
1706         // Now insert the LyX specific LaTeX commands...
1707         docstring lyxpreamble;
1708
1709         if (output_sync) {
1710                 if (!output_sync_macro.empty())
1711                         lyxpreamble += from_utf8(output_sync_macro) +"\n";
1712                 else if (features.runparams().flavor == OutputParams::LATEX)
1713                         lyxpreamble += "\\usepackage[active]{srcltx}\n";
1714                 else if (features.runparams().flavor == OutputParams::PDFLATEX)
1715                         lyxpreamble += "\\synctex=-1\n";
1716         }
1717
1718         // due to interferences with babel and hyperref, the color package has to
1719         // be loaded (when it is not already loaded) before babel when hyperref
1720         // is used with the colorlinks option, see
1721         // http://www.lyx.org/trac/ticket/5291
1722         // we decided therefore to load color always before babel, see
1723         // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg144349.html
1724         lyxpreamble += from_ascii(features.getColorOptions());
1725
1726         // If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them.
1727         if (use_babel
1728             && (features.isRequired("jurabib")
1729                 || features.isRequired("hyperref")
1730                 || features.isRequired("vietnamese")
1731                 || features.isRequired("japanese"))) {
1732                         // FIXME UNICODE
1733                         lyxpreamble += from_utf8(features.getBabelPresettings());
1734                         lyxpreamble += from_utf8(babelCall(language_options.str(),
1735                                                            features.needBabelLangOptions())) + '\n';
1736                         lyxpreamble += from_utf8(features.getBabelPostsettings());
1737         }
1738
1739         // The optional packages;
1740         lyxpreamble += from_ascii(features.getPackages());
1741
1742         // Additional Indices
1743         if (features.isRequired("splitidx")) {
1744                 IndicesList::const_iterator iit = indiceslist().begin();
1745                 IndicesList::const_iterator iend = indiceslist().end();
1746                 for (; iit != iend; ++iit) {
1747                         lyxpreamble += "\\newindex[";
1748                         lyxpreamble += iit->index();
1749                         lyxpreamble += "]{";
1750                         lyxpreamble += iit->shortcut();
1751                         lyxpreamble += "}\n";
1752                 }
1753         }
1754
1755         // Line spacing
1756         lyxpreamble += from_utf8(spacing().writePreamble(tclass.provides("SetSpace")));
1757
1758         // PDF support.
1759         // * Hyperref manual: "Make sure it comes last of your loaded
1760         //   packages, to give it a fighting chance of not being over-written,
1761         //   since its job is to redefine many LaTeX commands."
1762         // * Email from Heiko Oberdiek: "It is usually better to load babel
1763         //   before hyperref. Then hyperref has a chance to detect babel.
1764         // * Has to be loaded before the "LyX specific LaTeX commands" to
1765         //   avoid errors with algorithm floats.
1766         // use hyperref explicitly if it is required
1767         if (features.isRequired("hyperref")) {
1768                 // pass what we have to stream here, since we need
1769                 // to access the stream itself in PDFOptions.
1770                 os << lyxpreamble;
1771
1772                 int lines =
1773                         int(count(lyxpreamble.begin(), lyxpreamble.end(), '\n'));
1774
1775                 OutputParams tmp_params = features.runparams();
1776                 lines += pdfoptions().writeLaTeX(tmp_params, os,
1777                                         documentClass().provides("hyperref"));
1778                 texrow.newlines(lines);
1779                 // set back for the rest
1780                 lyxpreamble.clear();
1781         } else if (features.isRequired("nameref"))
1782                 // hyperref loads this automatically
1783                 lyxpreamble += "\\usepackage{nameref}\n";
1784
1785         // Will be surrounded by \makeatletter and \makeatother when not empty
1786         docstring atlyxpreamble;
1787
1788         // Some macros LyX will need
1789         docstring tmppreamble(features.getMacros());
1790
1791         if (!tmppreamble.empty())
1792                 atlyxpreamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1793                         "LyX specific LaTeX commands.\n"
1794                         + tmppreamble + '\n';
1795
1796         // the text class specific preamble
1797         tmppreamble = features.getTClassPreamble();
1798         if (!tmppreamble.empty())
1799                 atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1800                         "Textclass specific LaTeX commands.\n"
1801                         + tmppreamble + '\n';
1802
1803         // suppress date if selected
1804         // use \@ifundefined because we cannot be sure that every document class
1805         // has a \date command
1806         if (suppress_date)
1807                 atlyxpreamble += "\\@ifundefined{date}{}{\\date{}}\n";
1808
1809         /* the user-defined preamble */
1810         if (!containsOnly(preamble, " \n\t"))
1811                 // FIXME UNICODE
1812                 atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1813                         "User specified LaTeX commands.\n"
1814                         + from_utf8(preamble) + '\n';
1815
1816         // subfig loads internally the LaTeX package "caption". As
1817         // caption is a very popular package, users will load it in
1818         // the preamble. Therefore we must load subfig behind the
1819         // user-defined preamble and check if the caption package was
1820         // loaded or not. For the case that caption is loaded before
1821         // subfig, there is the subfig option "caption=false". This
1822         // option also works when a koma-script class is used and
1823         // koma's own caption commands are used instead of caption. We
1824         // use \PassOptionsToPackage here because the user could have
1825         // already loaded subfig in the preamble.
1826         if (features.isRequired("subfig")) {
1827                 atlyxpreamble += "\\@ifundefined{showcaptionsetup}{}{%\n"
1828                         " \\PassOptionsToPackage{caption=false}{subfig}}\n"
1829                         "\\usepackage{subfig}\n";
1830         }
1831
1832         // Itemize bullet settings need to be last in case the user
1833         // defines their own bullets that use a package included
1834         // in the user-defined preamble -- ARRae
1835         // Actually it has to be done much later than that
1836         // since some packages like frenchb make modifications
1837         // at \begin{document} time -- JMarc
1838         docstring bullets_def;
1839         for (int i = 0; i < 4; ++i) {
1840                 if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) {
1841                         if (bullets_def.empty())
1842                                 bullets_def += "\\AtBeginDocument{\n";
1843                         bullets_def += "  \\def\\labelitemi";
1844                         switch (i) {
1845                                 // `i' is one less than the item to modify
1846                         case 0:
1847                                 break;
1848                         case 1:
1849                                 bullets_def += 'i';
1850                                 break;
1851                         case 2:
1852                                 bullets_def += "ii";
1853                                 break;
1854                         case 3:
1855                                 bullets_def += 'v';
1856                                 break;
1857                         }
1858                         bullets_def += '{' +
1859                                 user_defined_bullet(i).getText()
1860                                 + "}\n";
1861                 }
1862         }
1863
1864         if (!bullets_def.empty())
1865                 atlyxpreamble += bullets_def + "}\n\n";
1866
1867         if (!atlyxpreamble.empty())
1868                 lyxpreamble += "\n\\makeatletter\n"
1869                         + atlyxpreamble + "\\makeatother\n\n";
1870
1871         // We try to load babel late, in case it interferes with other packages.
1872         // Jurabib and Hyperref have to be called after babel, though.
1873         if (use_babel && !features.isRequired("jurabib")
1874             && !features.isRequired("hyperref")
1875             && !features.isRequired("vietnamese")
1876             && !features.isRequired("japanese")) {
1877                 // FIXME UNICODE
1878                 lyxpreamble += from_utf8(features.getBabelPresettings());
1879                 lyxpreamble += from_utf8(babelCall(language_options.str(),
1880                                                    features.needBabelLangOptions())) + '\n';
1881                 lyxpreamble += from_utf8(features.getBabelPostsettings());
1882         }
1883
1884         // xunicode needs to be loaded at least after amsmath, amssymb,
1885         // esint and the other packages that provide special glyphs
1886         if (features.runparams().flavor == OutputParams::XETEX)
1887                 lyxpreamble += "\\usepackage{xunicode}\n";
1888
1889         // Polyglossia must be loaded last
1890         if (use_polyglossia) {
1891                 // call the package
1892                 lyxpreamble += "\\usepackage{polyglossia}\n";
1893                 // set the main language
1894                 lyxpreamble += "\\setdefaultlanguage";
1895                 if (!language->polyglossiaOpts().empty())
1896                         lyxpreamble += "[" + from_ascii(language->polyglossiaOpts()) + "]";
1897                 lyxpreamble += "{" + from_ascii(language->polyglossia()) + "}\n";
1898                 // now setup the other languages
1899                 std::map<std::string, std::string> const polylangs =
1900                         features.getPolyglossiaLanguages();
1901                 for (std::map<std::string, std::string>::const_iterator mit = polylangs.begin();
1902                      mit != polylangs.end() ; ++mit) {
1903                         lyxpreamble += "\\setotherlanguage";
1904                         if (!mit->second.empty())
1905                                 lyxpreamble += "[" + from_ascii(mit->second) + "]";
1906                         lyxpreamble += "{" + from_ascii(mit->first) + "}\n";
1907                 }
1908         }
1909
1910         docstring const i18npreamble =
1911                 features.getTClassI18nPreamble(use_babel, use_polyglossia);
1912         if (!i18npreamble.empty())
1913                 lyxpreamble += i18npreamble + '\n';
1914
1915         int const nlines =
1916                 int(count(lyxpreamble.begin(), lyxpreamble.end(), '\n'));
1917         texrow.newlines(nlines);
1918
1919         os << lyxpreamble;
1920
1921         return use_babel;
1922 }
1923
1924
1925 void BufferParams::useClassDefaults()
1926 {
1927         DocumentClass const & tclass = documentClass();
1928
1929         sides = tclass.sides();
1930         columns = tclass.columns();
1931         pagestyle = tclass.pagestyle();
1932         use_default_options = true;
1933         // Only if class has a ToC hierarchy
1934         if (tclass.hasTocLevels()) {
1935                 secnumdepth = tclass.secnumdepth();
1936                 tocdepth = tclass.tocdepth();
1937         }
1938 }
1939
1940
1941 bool BufferParams::hasClassDefaults() const
1942 {
1943         DocumentClass const & tclass = documentClass();
1944
1945         return sides == tclass.sides()
1946                 && columns == tclass.columns()
1947                 && pagestyle == tclass.pagestyle()
1948                 && use_default_options
1949                 && secnumdepth == tclass.secnumdepth()
1950                 && tocdepth == tclass.tocdepth();
1951 }
1952
1953
1954 DocumentClass const & BufferParams::documentClass() const
1955 {
1956         return *doc_class_;
1957 }
1958
1959
1960 DocumentClass const * BufferParams::documentClassPtr() const
1961 {
1962         return doc_class_;
1963 }
1964
1965
1966 void BufferParams::setDocumentClass(DocumentClass const * const tc)
1967 {
1968         // evil, but this function is evil
1969         doc_class_ = const_cast<DocumentClass *>(tc);
1970 }
1971
1972
1973 bool BufferParams::setBaseClass(string const & classname)
1974 {
1975         LYXERR(Debug::TCLASS, "setBaseClass: " << classname);
1976         LayoutFileList & bcl = LayoutFileList::get();
1977         if (!bcl.haveClass(classname)) {
1978                 docstring s =
1979                         bformat(_("The layout file:\n"
1980                                 "%1$s\n"
1981                                 "could not be found. A default textclass with default\n"
1982                                 "layouts will be used. LyX will not be able to produce\n"
1983                                 "correct output."),
1984                         from_utf8(classname));
1985                 frontend::Alert::error(_("Document class not found"), s);
1986                 bcl.addEmptyClass(classname);
1987         }
1988
1989         bool const success = bcl[classname].load();
1990         if (!success) {
1991                 docstring s =
1992                         bformat(_("Due to some error in it, the layout file:\n"
1993                                 "%1$s\n"
1994                                 "could not be loaded. A default textclass with default\n"
1995                                 "layouts will be used. LyX will not be able to produce\n"
1996                                 "correct output."),
1997                         from_utf8(classname));
1998                 frontend::Alert::error(_("Could not load class"), s);
1999                 bcl.addEmptyClass(classname);
2000         }
2001
2002         pimpl_->baseClass_ = classname;
2003         layout_modules_.adaptToBaseClass(baseClass(), removed_modules_);
2004         return true;
2005 }
2006
2007
2008 LayoutFile const * BufferParams::baseClass() const
2009 {
2010         if (LayoutFileList::get().haveClass(pimpl_->baseClass_))
2011                 return &(LayoutFileList::get()[pimpl_->baseClass_]);
2012         else
2013                 return 0;
2014 }
2015
2016
2017 LayoutFileIndex const & BufferParams::baseClassID() const
2018 {
2019         return pimpl_->baseClass_;
2020 }
2021
2022
2023 void BufferParams::makeDocumentClass()
2024 {
2025         if (!baseClass())
2026                 return;
2027
2028         doc_class_ = &(DocumentClassBundle::get().makeDocumentClass(*baseClass(), layout_modules_));
2029
2030         if (!local_layout.empty()) {
2031                 if (!doc_class_->read(local_layout, TextClass::MODULE)) {
2032                         docstring const msg = _("Error reading internal layout information");
2033                         frontend::Alert::warning(_("Read Error"), msg);
2034                 }
2035         }
2036 }
2037
2038
2039 bool BufferParams::moduleCanBeAdded(string const & modName) const
2040 {
2041         return layout_modules_.moduleCanBeAdded(modName, baseClass());
2042 }
2043
2044
2045 bool BufferParams::addLayoutModule(string const & modName)
2046 {
2047         LayoutModuleList::const_iterator it = layout_modules_.begin();
2048         LayoutModuleList::const_iterator end = layout_modules_.end();
2049         for (; it != end; it++)
2050                 if (*it == modName)
2051                         return false;
2052         layout_modules_.push_back(modName);
2053         return true;
2054 }
2055
2056
2057 Font const BufferParams::getFont() const
2058 {
2059         FontInfo f = documentClass().defaultfont();
2060         if (fonts_default_family == "rmdefault")
2061                 f.setFamily(ROMAN_FAMILY);
2062         else if (fonts_default_family == "sfdefault")
2063                 f.setFamily(SANS_FAMILY);
2064         else if (fonts_default_family == "ttdefault")
2065                 f.setFamily(TYPEWRITER_FAMILY);
2066         return Font(f, language);
2067 }
2068
2069
2070 void BufferParams::readPreamble(Lexer & lex)
2071 {
2072         if (lex.getString() != "\\begin_preamble")
2073                 lyxerr << "Error (BufferParams::readPreamble):"
2074                         "consistency check failed." << endl;
2075
2076         preamble = lex.getLongString("\\end_preamble");
2077 }
2078
2079
2080 void BufferParams::readLocalLayout(Lexer & lex)
2081 {
2082         if (lex.getString() != "\\begin_local_layout")
2083                 lyxerr << "Error (BufferParams::readLocalLayout):"
2084                         "consistency check failed." << endl;
2085
2086         local_layout = lex.getLongString("\\end_local_layout");
2087 }
2088
2089
2090 void BufferParams::readLanguage(Lexer & lex)
2091 {
2092         if (!lex.next()) return;
2093
2094         string const tmptok = lex.getString();
2095
2096         // check if tmptok is part of tex_babel in tex-defs.h
2097         language = languages.getLanguage(tmptok);
2098         if (!language) {
2099                 // Language tmptok was not found
2100                 language = default_language;
2101                 lyxerr << "Warning: Setting language `"
2102                        << tmptok << "' to `" << language->lang()
2103                        << "'." << endl;
2104         }
2105 }
2106
2107
2108 void BufferParams::readGraphicsDriver(Lexer & lex)
2109 {
2110         if (!lex.next())
2111                 return;
2112
2113         string const tmptok = lex.getString();
2114         // check if tmptok is part of tex_graphics in tex_defs.h
2115         int n = 0;
2116         while (true) {
2117                 string const test = tex_graphics[n++];
2118
2119                 if (test == tmptok) {
2120                         graphics_driver = tmptok;
2121                         break;
2122                 }
2123                 if (test.empty()) {
2124                         lex.printError(
2125                                 "Warning: graphics driver `$$Token' not recognized!\n"
2126                                 "         Setting graphics driver to `default'.\n");
2127                         graphics_driver = "default";
2128                         break;
2129                 }
2130         }
2131 }
2132
2133
2134 void BufferParams::readBullets(Lexer & lex)
2135 {
2136         if (!lex.next())
2137                 return;
2138
2139         int const index = lex.getInteger();
2140         lex.next();
2141         int temp_int = lex.getInteger();
2142         user_defined_bullet(index).setFont(temp_int);
2143         temp_bullet(index).setFont(temp_int);
2144         lex >> temp_int;
2145         user_defined_bullet(index).setCharacter(temp_int);
2146         temp_bullet(index).setCharacter(temp_int);
2147         lex >> temp_int;
2148         user_defined_bullet(index).setSize(temp_int);
2149         temp_bullet(index).setSize(temp_int);
2150 }
2151
2152
2153 void BufferParams::readBulletsLaTeX(Lexer & lex)
2154 {
2155         // The bullet class should be able to read this.
2156         if (!lex.next())
2157                 return;
2158         int const index = lex.getInteger();
2159         lex.next(true);
2160         docstring const temp_str = lex.getDocString();
2161
2162         user_defined_bullet(index).setText(temp_str);
2163         temp_bullet(index).setText(temp_str);
2164 }
2165
2166
2167 void BufferParams::readModules(Lexer & lex)
2168 {
2169         if (!lex.eatLine()) {
2170                 lyxerr << "Error (BufferParams::readModules):"
2171                                 "Unexpected end of input." << endl;
2172                 return;
2173         }
2174         while (true) {
2175                 string mod = lex.getString();
2176                 if (mod == "\\end_modules")
2177                         break;
2178                 addLayoutModule(mod);
2179                 lex.eatLine();
2180         }
2181 }
2182
2183
2184 void BufferParams::readRemovedModules(Lexer & lex)
2185 {
2186         if (!lex.eatLine()) {
2187                 lyxerr << "Error (BufferParams::readRemovedModules):"
2188                                 "Unexpected end of input." << endl;
2189                 return;
2190         }
2191         while (true) {
2192                 string mod = lex.getString();
2193                 if (mod == "\\end_removed_modules")
2194                         break;
2195                 removed_modules_.push_back(mod);
2196                 lex.eatLine();
2197         }
2198         // now we want to remove any removed modules that were previously
2199         // added. normally, that will be because default modules were added in
2200         // setBaseClass(), which gets called when \textclass is read at the
2201         // start of the read.
2202         list<string>::const_iterator rit = removed_modules_.begin();
2203         list<string>::const_iterator const ren = removed_modules_.end();
2204         for (; rit != ren; rit++) {
2205                 LayoutModuleList::iterator const mit = layout_modules_.begin();
2206                 LayoutModuleList::iterator const men = layout_modules_.end();
2207                 LayoutModuleList::iterator found = find(mit, men, *rit);
2208                 if (found == men)
2209                         continue;
2210                 layout_modules_.erase(found);
2211         }
2212 }
2213
2214
2215 void BufferParams::readIncludeonly(Lexer & lex)
2216 {
2217         if (!lex.eatLine()) {
2218                 lyxerr << "Error (BufferParams::readIncludeonly):"
2219                                 "Unexpected end of input." << endl;
2220                 return;
2221         }
2222         while (true) {
2223                 string child = lex.getString();
2224                 if (child == "\\end_includeonly")
2225                         break;
2226                 included_children_.push_back(child);
2227                 lex.eatLine();
2228         }
2229 }
2230
2231
2232 string BufferParams::paperSizeName(PapersizePurpose purpose) const
2233 {
2234         char real_papersize = papersize;
2235         if (real_papersize == PAPER_DEFAULT)
2236                 real_papersize = lyxrc.default_papersize;
2237
2238         switch (real_papersize) {
2239         case PAPER_DEFAULT:
2240                 // could be anything, so don't guess
2241                 return string();
2242         case PAPER_CUSTOM: {
2243                 if (purpose == XDVI && !paperwidth.empty() &&
2244                     !paperheight.empty()) {
2245                         // heightxwidth<unit>
2246                         string first = paperwidth;
2247                         string second = paperheight;
2248                         if (orientation == ORIENTATION_LANDSCAPE)
2249                                 first.swap(second);
2250                         // cut off unit.
2251                         return first.erase(first.length() - 2)
2252                                 + "x" + second;
2253                 }
2254                 return string();
2255         }
2256         case PAPER_A0:
2257                 // dvips and dvipdfm do not know this
2258                 if (purpose == DVIPS || purpose == DVIPDFM)
2259                         return string();
2260                 return "a0";
2261         case PAPER_A1:
2262                 if (purpose == DVIPS || purpose == DVIPDFM)
2263                         return string();
2264                 return "a1";
2265         case PAPER_A2:
2266                 if (purpose == DVIPS || purpose == DVIPDFM)
2267                         return string();
2268                 return "a2";
2269         case PAPER_A3:
2270                 return "a3";
2271         case PAPER_A4:
2272                 return "a4";
2273         case PAPER_A5:
2274                 return "a5";
2275         case PAPER_A6:
2276                 if (purpose == DVIPS || purpose == DVIPDFM)
2277                         return string();
2278                 return "a6";
2279         case PAPER_B0:
2280                 if (purpose == DVIPS || purpose == DVIPDFM)
2281                         return string();
2282                 return "b0";
2283         case PAPER_B1:
2284                 if (purpose == DVIPS || purpose == DVIPDFM)
2285                         return string();
2286                 return "b1";
2287         case PAPER_B2:
2288                 if (purpose == DVIPS || purpose == DVIPDFM)
2289                         return string();
2290                 return "b2";
2291         case PAPER_B3:
2292                 if (purpose == DVIPS || purpose == DVIPDFM)
2293                         return string();
2294                 return "b3";
2295         case PAPER_B4:
2296                 // dvipdfm does not know this
2297                 if (purpose == DVIPDFM)
2298                         return string();
2299                 return "b4";
2300         case PAPER_B5:
2301                 if (purpose == DVIPDFM)
2302                         return string();
2303                 return "b5";
2304         case PAPER_B6:
2305                 if (purpose == DVIPS || purpose == DVIPDFM)
2306                         return string();
2307                 return "b6";
2308         case PAPER_C0:
2309                 if (purpose == DVIPS || purpose == DVIPDFM)
2310                         return string();
2311                 return "c0";
2312         case PAPER_C1:
2313                 if (purpose == DVIPS || purpose == DVIPDFM)
2314                         return string();
2315                 return "c1";
2316         case PAPER_C2:
2317                 if (purpose == DVIPS || purpose == DVIPDFM)
2318                         return string();
2319                 return "c2";
2320         case PAPER_C3:
2321                 if (purpose == DVIPS || purpose == DVIPDFM)
2322                         return string();
2323                 return "c3";
2324         case PAPER_C4:
2325                 if (purpose == DVIPS || purpose == DVIPDFM)
2326                         return string();
2327                 return "c4";
2328         case PAPER_C5:
2329                 if (purpose == DVIPS || purpose == DVIPDFM)
2330                         return string();
2331                 return "c5";
2332         case PAPER_C6:
2333                 if (purpose == DVIPS || purpose == DVIPDFM)
2334                         return string();
2335                 return "c6";
2336         case PAPER_JISB0:
2337                 if (purpose == DVIPS || purpose == DVIPDFM)
2338                         return string();
2339                 return "jisb0";
2340         case PAPER_JISB1:
2341                 if (purpose == DVIPS || purpose == DVIPDFM)
2342                         return string();
2343                 return "jisb1";
2344         case PAPER_JISB2:
2345                 if (purpose == DVIPS || purpose == DVIPDFM)
2346                         return string();
2347                 return "jisb2";
2348         case PAPER_JISB3:
2349                 if (purpose == DVIPS || purpose == DVIPDFM)
2350                         return string();
2351                 return "jisb3";
2352         case PAPER_JISB4:
2353                 if (purpose == DVIPS || purpose == DVIPDFM)
2354                         return string();
2355                 return "jisb4";
2356         case PAPER_JISB5:
2357                 if (purpose == DVIPS || purpose == DVIPDFM)
2358                         return string();
2359                 return "jisb5";
2360         case PAPER_JISB6:
2361                 if (purpose == DVIPS || purpose == DVIPDFM)
2362                         return string();
2363                 return "jisb6";
2364         case PAPER_USEXECUTIVE:
2365                 // dvipdfm does not know this
2366                 if (purpose == DVIPDFM)
2367                         return string();
2368                 return "foolscap";
2369         case PAPER_USLEGAL:
2370                 return "legal";
2371         case PAPER_USLETTER:
2372         default:
2373                 if (purpose == XDVI)
2374                         return "us";
2375                 return "letter";
2376         }
2377 }
2378
2379
2380 string const BufferParams::dvips_options() const
2381 {
2382         string result;
2383
2384         if (use_geometry
2385             && papersize == PAPER_CUSTOM
2386             && !lyxrc.print_paper_dimension_flag.empty()
2387             && !paperwidth.empty()
2388             && !paperheight.empty()) {
2389                 // using a custom papersize
2390                 result = lyxrc.print_paper_dimension_flag;
2391                 result += ' ' + paperwidth;
2392                 result += ',' + paperheight;
2393         } else {
2394                 string const paper_option = paperSizeName(DVIPS);
2395                 if (!paper_option.empty() && (paper_option != "letter" ||
2396                     orientation != ORIENTATION_LANDSCAPE)) {
2397                         // dvips won't accept -t letter -t landscape.
2398                         // In all other cases, include the paper size
2399                         // explicitly.
2400                         result = lyxrc.print_paper_flag;
2401                         result += ' ' + paper_option;
2402                 }
2403         }
2404         if (orientation == ORIENTATION_LANDSCAPE &&
2405             papersize != PAPER_CUSTOM)
2406                 result += ' ' + lyxrc.print_landscape_flag;
2407         return result;
2408 }
2409
2410
2411 string const BufferParams::font_encoding() const
2412 {
2413         return (fontenc == "global") ? lyxrc.fontenc : fontenc;
2414 }
2415
2416
2417 string BufferParams::babelCall(string const & lang_opts, bool const langoptions) const
2418 {
2419         if (lyxrc.language_package_selection == LyXRC::LP_CUSTOM)
2420                 return lyxrc.language_custom_package;
2421         // suppress the babel call if there is no BabelName defined
2422         // for the document language in the lib/languages file and if no
2423         // other languages are used (lang_opts is then empty)
2424         if (lang_opts.empty())
2425                 return string();
2426         // either a specific language (AsBabelOptions setting in
2427         // lib/languages) or the prefs require the languages to
2428         // be submitted to babel itself (not the class).
2429         if (langoptions)
2430                 return "\\usepackage[" + lang_opts + "]{babel}";
2431         return "\\usepackage{babel}";
2432 }
2433
2434
2435 docstring BufferParams::getGraphicsDriver(string const & package) const
2436 {
2437         docstring result;
2438
2439         if (package == "geometry") {
2440                 if (graphics_driver == "dvips"
2441                     || graphics_driver == "dvipdfm"
2442                     || graphics_driver == "pdftex"
2443                     || graphics_driver == "vtex")
2444                         result = from_ascii(graphics_driver);
2445                 else if (graphics_driver == "dvipdfmx")
2446                         result = from_ascii("dvipdfm");
2447         }
2448
2449         return result;
2450 }
2451
2452
2453 void BufferParams::writeEncodingPreamble(odocstream & os,
2454                 LaTeXFeatures & features, TexRow & texrow) const
2455 {
2456         // XeTeX does not need this
2457         if (features.runparams().flavor == OutputParams::XETEX)
2458                 return;
2459         // LuaTeX neither, but with tex fonts, we need to load
2460         // the luainputenc package.
2461         if (features.runparams().flavor == OutputParams::LUATEX) {
2462                 if (!useNonTeXFonts) {
2463                         os << "\\usepackage[utf8]{luainputenc}\n";
2464                         texrow.newline();
2465                 }
2466                 return;
2467         }
2468         if (inputenc == "auto") {
2469                 string const doc_encoding =
2470                         language->encoding()->latexName();
2471                 Encoding::Package const package =
2472                         language->encoding()->package();
2473
2474                 // Create a list with all the input encodings used
2475                 // in the document
2476                 set<string> encodings =
2477                         features.getEncodingSet(doc_encoding);
2478
2479                 // If the "japanese" package (i.e. pLaTeX) is used,
2480                 // inputenc must be omitted.
2481                 // see http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129680.html
2482                 if (package == Encoding::japanese)
2483                      features.require("japanese");
2484
2485                 if ((!encodings.empty() || package == Encoding::inputenc)
2486                     && !features.isRequired("japanese")) {
2487                         os << "\\usepackage[";
2488                         set<string>::const_iterator it = encodings.begin();
2489                         set<string>::const_iterator const end = encodings.end();
2490                         if (it != end) {
2491                                 os << from_ascii(*it);
2492                                 ++it;
2493                         }
2494                         for (; it != end; ++it)
2495                                 os << ',' << from_ascii(*it);
2496                         if (package == Encoding::inputenc) {
2497                                 if (!encodings.empty())
2498                                         os << ',';
2499                                 os << from_ascii(doc_encoding);
2500                         }
2501                         os << "]{inputenc}\n";
2502                         texrow.newline();
2503                 }
2504                 if (package == Encoding::CJK || features.mustProvide("CJK")) {
2505                         if (language->encoding()->name() == "utf8-cjk"
2506                             && LaTeXFeatures::isAvailable("CJKutf8"))
2507                                 os << "\\usepackage{CJKutf8}\n";
2508                         else
2509                                 os << "\\usepackage{CJK}\n";
2510                         texrow.newline();
2511                 }
2512         } else if (inputenc != "default") {
2513                 switch (encoding().package()) {
2514                 case Encoding::none:
2515                 case Encoding::japanese:
2516                         break;
2517                 case Encoding::inputenc:
2518                         // do not load inputenc if japanese is used
2519                         if (features.isRequired("japanese"))
2520                                 break;
2521                         os << "\\usepackage[" << from_ascii(inputenc)
2522                            << "]{inputenc}\n";
2523                         texrow.newline();
2524                         break;
2525                 case Encoding::CJK:
2526                         if (encoding().name() == "utf8-cjk"
2527                             && LaTeXFeatures::isAvailable("CJKutf8"))
2528                                 os << "\\usepackage{CJKutf8}\n";
2529                         else
2530                                 os << "\\usepackage{CJK}\n";
2531                         texrow.newline();
2532                         break;
2533                 }
2534         }
2535
2536         // The encoding "armscii8" (for Armenian) is only available when
2537         // the package "armtex" is loaded.
2538         if (language->encoding()->latexName() == "armscii8"
2539             || inputenc == "armscii8") {
2540                 os << "\\usepackage{armtex}\n";
2541                 texrow.newline();
2542         }
2543 }
2544
2545
2546 string const BufferParams::parseFontName(string const & name) const
2547 {
2548         string mangled = name;
2549         size_t const idx = mangled.find('[');
2550         if (idx == string::npos || idx == 0)
2551                 return mangled;
2552         else
2553                 return mangled.substr(0, idx - 1);
2554 }
2555
2556
2557 string const BufferParams::loadFonts(string const & rm,
2558                                      string const & sf, string const & tt,
2559                                      bool const & sc, bool const & osf,
2560                                      int const & sfscale, int const & ttscale,
2561                                      bool const & use_systemfonts) const
2562 {
2563         /* The LaTeX font world is in a flux. In the PSNFSS font interface,
2564            several packages have been replaced by others, that might not
2565            be installed on every system. We have to take care for that
2566            (see psnfss.pdf). We try to support all psnfss fonts as well
2567            as the fonts that have become de facto standard in the LaTeX
2568            world (e.g. Latin Modern). We do not support obsolete fonts
2569            (like PSLatex). In general, it should be possible to mix any
2570            rm font with any sf or tt font, respectively. (JSpitzm)
2571            TODO:
2572                 -- separate math fonts.
2573         */
2574
2575         if (rm == "default" && sf == "default" && tt == "default")
2576                 //nothing to do
2577                 return string();
2578
2579         ostringstream os;
2580
2581         if (use_systemfonts) {
2582                 if (rm != "default") {
2583                         os << "\\setmainfont[Mapping=tex-text";
2584                         if (osf)
2585                                 os << ",Numbers=OldStyle";
2586                         os << "]{" << parseFontName(rm) << "}\n";
2587                 }
2588                 if (sf != "default") {
2589                         string const sans = parseFontName(sf);
2590                         if (sfscale != 100)
2591                                 os << "\\setsansfont[Scale="
2592                                    << float(sfscale) / 100
2593                                    << ",Mapping=tex-text]{"
2594                                    << sans << "}\n";
2595                         else
2596                                 os << "\\setsansfont[Mapping=tex-text]{"
2597                                    << sans << "}\n";
2598                 }
2599                 if (tt != "default") {
2600                         string const mono = parseFontName(tt);
2601                         if (ttscale != 100)
2602                                 os << "\\setmonofont[Scale="
2603                                    << float(sfscale) / 100
2604                                    << "]{"
2605                                    << mono << "}\n";
2606                         else
2607                                 os << "\\setmonofont[Mapping=tex-text]{"
2608                                    << mono << "}\n";
2609                 }
2610                 return os.str();
2611         }
2612
2613         // ROMAN FONTS
2614         // Computer Modern (must be explicitly selectable -- there might be classes
2615         // that define a different default font!
2616         if (rm == "cmr") {
2617                 os << "\\renewcommand{\\rmdefault}{cmr}\n";
2618                 // osf for Computer Modern needs eco.sty
2619                 if (osf)
2620                         os << "\\usepackage{eco}\n";
2621         }
2622         // Latin Modern Roman
2623         else if (rm == "lmodern")
2624                 os << "\\usepackage{lmodern}\n";
2625         // AE
2626         else if (rm == "ae") {
2627                 // not needed when using OT1 font encoding.
2628                 if (font_encoding() != "default")
2629                         os << "\\usepackage{ae,aecompl}\n";
2630         }
2631         // Times
2632         else if (rm == "times") {
2633                 // try to load the best available package
2634                 if (LaTeXFeatures::isAvailable("mathptmx"))
2635                         os << "\\usepackage{mathptmx}\n";
2636                 else if (LaTeXFeatures::isAvailable("mathptm"))
2637                         os << "\\usepackage{mathptm}\n";
2638                 else
2639                         os << "\\usepackage{times}\n";
2640         }
2641         // Palatino
2642         else if (rm == "palatino") {
2643                 // try to load the best available package
2644                 if (LaTeXFeatures::isAvailable("mathpazo")) {
2645                         os << "\\usepackage";
2646                         if (osf || sc) {
2647                                 os << '[';
2648                                 if (!osf)
2649                                         os << "sc";
2650                                 else
2651                                         // "osf" includes "sc"!
2652                                         os << "osf";
2653                                 os << ']';
2654                         }
2655                         os << "{mathpazo}\n";
2656                 }
2657                 else if (LaTeXFeatures::isAvailable("mathpple"))
2658                         os << "\\usepackage{mathpple}\n";
2659                 else
2660                         os << "\\usepackage{palatino}\n";
2661         }
2662         // Utopia
2663         else if (rm == "utopia") {
2664                 // fourier supersedes utopia.sty, but does
2665                 // not work with OT1 encoding.
2666                 if (LaTeXFeatures::isAvailable("fourier")
2667                     && font_encoding() != "default") {
2668                         os << "\\usepackage";
2669                         if (osf || sc) {
2670                                 os << '[';
2671                                 if (sc)
2672                                         os << "expert";
2673                                 if (osf && sc)
2674                                         os << ',';
2675                                 if (osf)
2676                                         os << "oldstyle";
2677                                 os << ']';
2678                         }
2679                         os << "{fourier}\n";
2680                 }
2681                 else
2682                         os << "\\usepackage{utopia}\n";
2683         }
2684         // Bera (complete fontset)
2685         else if (rm == "bera" && sf == "default" && tt == "default")
2686                 os << "\\usepackage{bera}\n";
2687         // everything else
2688         else if (rm != "default")
2689                 os << "\\usepackage" << "{" << rm << "}\n";
2690
2691         // SANS SERIF
2692         // Helvetica, Bera Sans
2693         if (sf == "helvet" || sf == "berasans") {
2694                 if (sfscale != 100)
2695                         os << "\\usepackage[scaled=" << float(sfscale) / 100
2696                            << "]{" << sf << "}\n";
2697                 else
2698                         os << "\\usepackage{" << sf << "}\n";
2699         }
2700         // Avant Garde
2701         else if (sf == "avant")
2702                 os << "\\usepackage{" << sf << "}\n";
2703         // Computer Modern, Latin Modern, CM Bright
2704         else if (sf != "default")
2705                 os << "\\renewcommand{\\sfdefault}{" << sf << "}\n";
2706
2707         // monospaced/typewriter
2708         // Courier, LuxiMono
2709         if (tt == "luximono" || tt == "beramono") {
2710                 if (ttscale != 100)
2711                         os << "\\usepackage[scaled=" << float(ttscale) / 100
2712                            << "]{" << tt << "}\n";
2713                 else
2714                         os << "\\usepackage{" << tt << "}\n";
2715         }
2716         // Courier
2717         else if (tt == "courier" )
2718                 os << "\\usepackage{" << tt << "}\n";
2719         // Computer Modern, Latin Modern, CM Bright
2720         else if (tt != "default")
2721                 os << "\\renewcommand{\\ttdefault}{" << tt << "}\n";
2722
2723         return os.str();
2724 }
2725
2726
2727 Encoding const & BufferParams::encoding() const
2728 {
2729         // FIXME: actually, we should check for the flavor
2730         // or runparams.isFullyUnicode() here:
2731         // This check will not work with XeTeX/LuaTeX and tex fonts.
2732         // Thus we have to reset the encoding in Buffer::makeLaTeXFile.
2733         if (useNonTeXFonts)
2734                 return *(encodings.fromLaTeXName("utf8-plain"));
2735         if (inputenc == "auto" || inputenc == "default")
2736                 return *language->encoding();
2737         Encoding const * const enc = encodings.fromLaTeXName(inputenc);
2738         if (enc)
2739                 return *enc;
2740         LYXERR0("Unknown inputenc value `" << inputenc
2741                << "'. Using `auto' instead.");
2742         return *language->encoding();
2743 }
2744
2745
2746 CiteEngine BufferParams::citeEngine() const
2747 {
2748         // FIXME the class should provide the numerical/
2749         // authoryear choice
2750         if (documentClass().provides("natbib")
2751             && cite_engine_ != ENGINE_NATBIB_NUMERICAL)
2752                 return ENGINE_NATBIB_AUTHORYEAR;
2753         return cite_engine_;
2754 }
2755
2756
2757 void BufferParams::setCiteEngine(CiteEngine cite_engine)
2758 {
2759         cite_engine_ = cite_engine;
2760 }
2761
2762 } // namespace lyx