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