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 "Encoding.h"
  27 #include "Language.h"
  28 #include "LaTeXFeatures.h"
  29 #include "ModuleList.h"
  30 #include "Font.h"
  31 #include "Lexer.h"
  32 #include "LyXRC.h"
  33 #include "OutputParams.h"
  34 #include "Spacing.h"
  35 #include "TexRow.h"
  36 #include "VSpace.h"
  37 #include "PDFOptions.h"
  38
  39 #include "frontends/alert.h"
  40
  41 #include "insets/InsetListingsParams.h"
  42
  43 #include "support/convert.h"
  44 #include "support/debug.h"
  45 #include "support/docstream.h"
  46 #include "support/FileName.h"
  47 #include "support/filetools.h"
  48 #include "support/gettext.h"
  49 #include "support/Messages.h"
  50 #include "support/Translator.h"
  51 #include "support/lstrings.h"
  52
  53 #include <algorithm>
  54 #include <sstream>
  55
  56 using namespace std;
  57 using namespace lyx::support;
  58
  59
  60 static char const * const string_paragraph_separation[] = {
  61         "indent", "skip", ""
  62 };
  63
  64
  65 static char const * const string_quotes_language[] = {
  66         "english", "swedish", "german", "polish", "french", "danish", ""
  67 };
  68
  69
  70 static char const * const string_papersize[] = {
  71         "default", "custom", "letterpaper", "legalpaper", "executivepaper",
  72         "a3paper", "a4paper", "a5paper", "b3paper", "b4paper", "b5paper", ""
  73 };
  74
  75
  76 static char const * const string_orientation[] = {
  77         "portrait", "landscape", ""
  78 };
  79
  80
  81 static char const * const string_footnotekinds[] = {
  82         "footnote", "margin", "fig", "tab", "alg", "wide-fig", "wide-tab", ""
  83 };
  84
  85
  86 static char const * const tex_graphics[] = {
  87         "default", "dvialw", "dvilaser", "dvipdf", "dvipdfm", "dvipdfmx",
  88         "dvips", "dvipsone", "dvitops", "dviwin", "dviwindo", "dvi2ps", "emtex",
  89         "ln", "oztex", "pctexhp", "pctexps", "pctexwin", "pctex32", "pdftex",
  90         "psprint", "pubps", "tcidvi", "textures", "truetex", "vtex", "xdvi",
  91         "xetex", "none", ""
  92 };
  93
  94
  95 namespace lyx {
  96
  97 // Local translators
  98 namespace {
  99
 100 // Paragraph separation
 101 typedef Translator<string, BufferParams::ParagraphSeparation> ParSepTranslator;
 102
 103
 104 ParSepTranslator const init_parseptranslator()
 105 {
 106         ParSepTranslator translator
 107                 (string_paragraph_separation[0], BufferParams::ParagraphIndentSeparation);
 108         translator.addPair(string_paragraph_separation[1], BufferParams::ParagraphSkipSeparation);
 109         return translator;
 110 }
 111
 112
 113 ParSepTranslator const & parseptranslator()
 114 {
 115         static ParSepTranslator translator = init_parseptranslator();
 116         return translator;
 117 }
 118
 119
 120 // Quotes language
 121 typedef Translator<string, InsetQuotes::QuoteLanguage> QuotesLangTranslator;
 122
 123
 124 QuotesLangTranslator const init_quoteslangtranslator()
 125 {
 126         QuotesLangTranslator translator
 127                 (string_quotes_language[0], InsetQuotes::EnglishQuotes);
 128         translator.addPair(string_quotes_language[1], InsetQuotes::SwedishQuotes);
 129         translator.addPair(string_quotes_language[2], InsetQuotes::GermanQuotes);
 130         translator.addPair(string_quotes_language[3], InsetQuotes::PolishQuotes);
 131         translator.addPair(string_quotes_language[4], InsetQuotes::FrenchQuotes);
 132         translator.addPair(string_quotes_language[5], InsetQuotes::DanishQuotes);
 133         return translator;
 134 }
 135
 136
 137 QuotesLangTranslator const & quoteslangtranslator()
 138 {
 139         static QuotesLangTranslator translator = init_quoteslangtranslator();
 140         return translator;
 141 }
 142
 143
 144 // Paper size
 145 typedef Translator<string, PAPER_SIZE> PaperSizeTranslator;
 146
 147
 148 static PaperSizeTranslator initPaperSizeTranslator()
 149 {
 150         PaperSizeTranslator translator(string_papersize[0], PAPER_DEFAULT);
 151         translator.addPair(string_papersize[1], PAPER_CUSTOM);
 152         translator.addPair(string_papersize[2], PAPER_USLETTER);
 153         translator.addPair(string_papersize[3], PAPER_USLEGAL);
 154         translator.addPair(string_papersize[4], PAPER_USEXECUTIVE);
 155         translator.addPair(string_papersize[5], PAPER_A3);
 156         translator.addPair(string_papersize[6], PAPER_A4);
 157         translator.addPair(string_papersize[7], PAPER_A5);
 158         translator.addPair(string_papersize[8], PAPER_B3);
 159         translator.addPair(string_papersize[9], PAPER_B4);
 160         translator.addPair(string_papersize[10], PAPER_B5);
 161         return translator;
 162 }
 163
 164
 165 PaperSizeTranslator const & papersizetranslator()
 166 {
 167         static PaperSizeTranslator translator = initPaperSizeTranslator();
 168         return translator;
 169 }
 170
 171
 172 // Paper orientation
 173 typedef Translator<string, PAPER_ORIENTATION> PaperOrientationTranslator;
 174
 175
 176 PaperOrientationTranslator const init_paperorientationtranslator()
 177 {
 178         PaperOrientationTranslator translator(string_orientation[0], ORIENTATION_PORTRAIT);
 179         translator.addPair(string_orientation[1], ORIENTATION_LANDSCAPE);
 180         return translator;
 181 }
 182
 183
 184 PaperOrientationTranslator const & paperorientationtranslator()
 185 {
 186         static PaperOrientationTranslator translator = init_paperorientationtranslator();
 187         return translator;
 188 }
 189
 190
 191 // Page sides
 192 typedef Translator<int, PageSides> SidesTranslator;
 193
 194
 195 SidesTranslator const init_sidestranslator()
 196 {
 197         SidesTranslator translator(1, OneSide);
 198         translator.addPair(2, TwoSides);
 199         return translator;
 200 }
 201
 202
 203 SidesTranslator const & sidestranslator()
 204 {
 205         static SidesTranslator translator = init_sidestranslator();
 206         return translator;
 207 }
 208
 209
 210 // LaTeX packages
 211 typedef Translator<int, BufferParams::Package> PackageTranslator;
 212
 213
 214 PackageTranslator const init_packagetranslator()
 215 {
 216         PackageTranslator translator(0, BufferParams::package_off);
 217         translator.addPair(1, BufferParams::package_auto);
 218         translator.addPair(2, BufferParams::package_on);
 219         return translator;
 220 }
 221
 222
 223 PackageTranslator const & packagetranslator()
 224 {
 225         static PackageTranslator translator = init_packagetranslator();
 226         return translator;
 227 }
 228
 229
 230 // Cite engine
 231 typedef Translator<string, CiteEngine> CiteEngineTranslator;
 232
 233
 234 CiteEngineTranslator const init_citeenginetranslator()
 235 {
 236         CiteEngineTranslator translator("basic", ENGINE_BASIC);
 237         translator.addPair("natbib_numerical", ENGINE_NATBIB_NUMERICAL);
 238         translator.addPair("natbib_authoryear", ENGINE_NATBIB_AUTHORYEAR);
 239         translator.addPair("jurabib", ENGINE_JURABIB);
 240         return translator;
 241 }
 242
 243
 244 CiteEngineTranslator const & citeenginetranslator()
 245 {
 246         static CiteEngineTranslator translator = init_citeenginetranslator();
 247         return translator;
 248 }
 249
 250
 251 // Spacing
 252 typedef Translator<string, Spacing::Space> SpaceTranslator;
 253
 254
 255 SpaceTranslator const init_spacetranslator()
 256 {
 257         SpaceTranslator translator("default", Spacing::Default);
 258         translator.addPair("single", Spacing::Single);
 259         translator.addPair("onehalf", Spacing::Onehalf);
 260         translator.addPair("double", Spacing::Double);
 261         translator.addPair("other", Spacing::Other);
 262         return translator;
 263 }
 264
 265
 266 SpaceTranslator const & spacetranslator()
 267 {
 268         static SpaceTranslator translator = init_spacetranslator();
 269         return translator;
 270 }
 271
 272
 273 } // anon namespace
 274
 275
 276 class BufferParams::Impl
 277 {
 278 public:
 279         Impl();
 280
 281         AuthorList authorlist;
 282         BranchList branchlist;
 283         Bullet temp_bullets[4];
 284         Bullet user_defined_bullets[4];
 285         Spacing spacing;
 286         /** This is the amount of space used for paragraph_separation "skip",
 287          * and for detached paragraphs in "indented" documents.
 288          */
 289         VSpace defskip;
 290         PDFOptions pdfoptions;
 291         LayoutFileIndex baseClass_;
 292 };
 293
 294
 295 BufferParams::Impl::Impl()
 296         : defskip(VSpace::MEDSKIP), baseClass_(string(""))
 297 {
 298         // set initial author
 299         // FIXME UNICODE
 300         authorlist.record(Author(from_utf8(lyxrc.user_name), from_utf8(lyxrc.user_email)));
 301 }
 302
 303
 304 BufferParams::Impl *
 305 BufferParams::MemoryTraits::clone(BufferParams::Impl const * ptr)
 306 {
 307         LASSERT(ptr, /**/);
 308
 309         return new BufferParams::Impl(*ptr);
 310 }
 311
 312
 313 void BufferParams::MemoryTraits::destroy(BufferParams::Impl * ptr)
 314 {
 315         delete ptr;
 316 }
 317
 318
 319 BufferParams::BufferParams()
 320         : pimpl_(new Impl)
 321 {
 322         setBaseClass(defaultBaseclass());
 323         makeDocumentClass();
 324         paragraph_separation = ParagraphIndentSeparation;
 325         quotes_language = InsetQuotes::EnglishQuotes;
 326         fontsize = "default";
 327
 328         /*  PaperLayout */
 329         papersize = PAPER_DEFAULT;
 330         orientation = ORIENTATION_PORTRAIT;
 331         use_geometry = false;
 332         use_amsmath = package_auto;
 333         use_esint = package_auto;
 334         cite_engine_ = ENGINE_BASIC;
 335         use_bibtopic = false;
 336         trackChanges = false;
 337         outputChanges = false;
 338         secnumdepth = 3;
 339         tocdepth = 3;
 340         language = default_language;
 341         fontsRoman = "default";
 342         fontsSans = "default";
 343         fontsTypewriter = "default";
 344         fontsDefaultFamily = "default";
 345         fontsSC = false;
 346         fontsOSF = false;
 347         fontsSansScale = 100;
 348         fontsTypewriterScale = 100;
 349         inputenc = "auto";
 350         graphicsDriver = "default";
 351         sides = OneSide;
 352         columns = 1;
 353         listings_params = string();
 354         pagestyle = "default";
 355         compressed = false;
 356         for (int iter = 0; iter < 4; ++iter) {
 357                 user_defined_bullet(iter) = ITEMIZE_DEFAULTS[iter];
 358                 temp_bullet(iter) = ITEMIZE_DEFAULTS[iter];
 359         }
 360 }
 361
 362
 363 docstring BufferParams::B_(string const & l10n) const
 364 {
 365         LASSERT(language, /**/);
 366         return getMessages(language->code()).get(l10n);
 367 }
 368
 369
 370 AuthorList & BufferParams::authors()
 371 {
 372         return pimpl_->authorlist;
 373 }
 374
 375
 376 AuthorList const & BufferParams::authors() const
 377 {
 378         return pimpl_->authorlist;
 379 }
 380
 381
 382 BranchList & BufferParams::branchlist()
 383 {
 384         return pimpl_->branchlist;
 385 }
 386
 387
 388 BranchList const & BufferParams::branchlist() const
 389 {
 390         return pimpl_->branchlist;
 391 }
 392
 393
 394 Bullet & BufferParams::temp_bullet(lyx::size_type const index)
 395 {
 396         LASSERT(index < 4, /**/);
 397         return pimpl_->temp_bullets[index];
 398 }
 399
 400
 401 Bullet const & BufferParams::temp_bullet(lyx::size_type const index) const
 402 {
 403         LASSERT(index < 4, /**/);
 404         return pimpl_->temp_bullets[index];
 405 }
 406
 407
 408 Bullet & BufferParams::user_defined_bullet(lyx::size_type const index)
 409 {
 410         LASSERT(index < 4, /**/);
 411         return pimpl_->user_defined_bullets[index];
 412 }
 413
 414
 415 Bullet const & BufferParams::user_defined_bullet(lyx::size_type const index) const
 416 {
 417         LASSERT(index < 4, /**/);
 418         return pimpl_->user_defined_bullets[index];
 419 }
 420
 421
 422 Spacing & BufferParams::spacing()
 423 {
 424         return pimpl_->spacing;
 425 }
 426
 427
 428 Spacing const & BufferParams::spacing() const
 429 {
 430         return pimpl_->spacing;
 431 }
 432
 433
 434 PDFOptions & BufferParams::pdfoptions()
 435 {
 436         return pimpl_->pdfoptions;
 437 }
 438
 439
 440 PDFOptions const & BufferParams::pdfoptions() const
 441 {
 442         return pimpl_->pdfoptions;
 443 }
 444
 445
 446 VSpace const & BufferParams::getDefSkip() const
 447 {
 448         return pimpl_->defskip;
 449 }
 450
 451
 452 void BufferParams::setDefSkip(VSpace const & vs)
 453 {
 454         pimpl_->defskip = vs;
 455 }
 456
 457
 458 string BufferParams::readToken(Lexer & lex, string const & token,
 459         FileName const & filepath)
 460 {
 461         if (token == "\\textclass") {
 462                 lex.next();
 463                 string const classname = lex.getString();
 464                 // if there exists a local layout file, ignore the system one
 465                 // NOTE: in this case, the textclass (.cls file) is assumed to be available.
 466                 string tcp;
 467                 LayoutFileList & bcl = LayoutFileList::get();
 468                 if (tcp.empty() && !filepath.empty())
 469                         tcp = bcl.addLocalLayout(classname, filepath.absFilename());
 470                 if (!tcp.empty())
 471                         setBaseClass(tcp);
 472                 else
 473                         setBaseClass(classname);
 474                 // We assume that a tex class exists for local or unknown layouts so this warning
 475                 // will only be given for system layouts.
 476                 if (!baseClass()->isTeXClassAvailable()) {
 477                         docstring const msg =
 478                                 bformat(_("The layout file requested by this document,\n"
 479                                                  "%1$s.layout,\n"
 480                                                  "is not usable. This is probably because a LaTeX\n"
 481                                                  "class or style file required by it is not\n"
 482                                                  "available. See the Customization documentation\n"
 483                                                  "for more information.\n"), from_utf8(classname));
 484                         frontend::Alert::warning(_("Document class not available"),
 485                                        msg + _("LyX will not be able to produce output."));
 486                 }
 487         } else if (token == "\\begin_preamble") {
 488                 readPreamble(lex);
 489         } else if (token == "\\begin_local_layout") {
 490                 readLocalLayout(lex);
 491         } else if (token == "\\begin_modules") {
 492                 readModules(lex);
 493         } else if (token == "\\begin_removed_modules") {
 494                 readRemovedModules(lex);
 495         } else if (token == "\\options") {
 496                 lex.eatLine();
 497                 options = lex.getString();
 498         } else if (token == "\\master") {
 499                 lex.eatLine();
 500                 master = lex.getString();
 501         } else if (token == "\\language") {
 502                 readLanguage(lex);
 503         } else if (token == "\\inputencoding") {
 504                 lex >> inputenc;
 505         } else if (token == "\\graphics") {
 506                 readGraphicsDriver(lex);
 507         } else if (token == "\\font_roman") {
 508                 lex >> fontsRoman;
 509         } else if (token == "\\font_sans") {
 510                 lex >> fontsSans;
 511         } else if (token == "\\font_typewriter") {
 512                 lex >> fontsTypewriter;
 513         } else if (token == "\\font_default_family") {
 514                 lex >> fontsDefaultFamily;
 515         } else if (token == "\\font_sc") {
 516                 lex >> fontsSC;
 517         } else if (token == "\\font_osf") {
 518                 lex >> fontsOSF;
 519         } else if (token == "\\font_sf_scale") {
 520                 lex >> fontsSansScale;
 521         } else if (token == "\\font_tt_scale") {
 522                 lex >> fontsTypewriterScale;
 523         } else if (token == "\\font_cjk") {
 524                 lex >> fontsCJK;
 525         } else if (token == "\\paragraph_separation") {
 526                 string parsep;
 527                 lex >> parsep;
 528                 paragraph_separation = parseptranslator().find(parsep);
 529         } else if (token == "\\defskip") {
 530                 lex.next();
 531                 string defskip = lex.getString();
 532                 if (defskip == "defskip")
 533                         // this is invalid
 534                         defskip = "medskip";
 535                 pimpl_->defskip = VSpace(defskip);
 536         } else if (token == "\\quotes_language") {
 537                 string quotes_lang;
 538                 lex >> quotes_lang;
 539                 quotes_language = quoteslangtranslator().find(quotes_lang);
 540         } else if (token == "\\papersize") {
 541                 string ppsize;
 542                 lex >> ppsize;
 543                 papersize = papersizetranslator().find(ppsize);
 544         } else if (token == "\\use_geometry") {
 545                 lex >> use_geometry;
 546         } else if (token == "\\use_amsmath") {
 547                 int use_ams;
 548                 lex >> use_ams;
 549                 use_amsmath = packagetranslator().find(use_ams);
 550         } else if (token == "\\use_esint") {
 551                 int useesint;
 552                 lex >> useesint;
 553                 use_esint = packagetranslator().find(useesint);
 554         } else if (token == "\\cite_engine") {
 555                 string engine;
 556                 lex >> engine;
 557                 cite_engine_ = citeenginetranslator().find(engine);
 558         } else if (token == "\\use_bibtopic") {
 559                 lex >> use_bibtopic;
 560         } else if (token == "\\tracking_changes") {
 561                 lex >> trackChanges;
 562         } else if (token == "\\output_changes") {
 563                 lex >> outputChanges;
 564         } else if (token == "\\branch") {
 565                 lex.next();
 566                 docstring branch = lex.getDocString();
 567                 branchlist().add(branch);
 568                 while (true) {
 569                         lex.next();
 570                         string const tok = lex.getString();
 571                         if (tok == "\\end_branch")
 572                                 break;
 573                         Branch * branch_ptr = branchlist().find(branch);
 574                         if (tok == "\\selected") {
 575                                 lex.next();
 576                                 if (branch_ptr)
 577                                         branch_ptr->setSelected(lex.getInteger());
 578                         }
 579                         // not yet operational
 580                         if (tok == "\\color") {
 581                                 lex.eatLine();
 582                                 string color = lex.getString();
 583                                 if (branch_ptr)
 584                                         branch_ptr->setColor(color);
 585                                 // Update also the Color table:
 586                                 if (color == "none")
 587                                         color = lcolor.getX11Name(Color_background);
 588                                 // FIXME UNICODE
 589                                 lcolor.setColor(to_utf8(branch), color);
 590
 591                         }
 592                 }
 593         } else if (token == "\\author") {
 594                 lex.eatLine();
 595                 istringstream ss(lex.getString());
 596                 Author a;
 597                 ss >> a;
 598                 author_map.push_back(pimpl_->authorlist.record(a));
 599         } else if (token == "\\paperorientation") {
 600                 string orient;
 601                 lex >> orient;
 602                 orientation = paperorientationtranslator().find(orient);
 603         } else if (token == "\\paperwidth") {
 604                 lex >> paperwidth;
 605         } else if (token == "\\paperheight") {
 606                 lex >> paperheight;
 607         } else if (token == "\\leftmargin") {
 608                 lex >> leftmargin;
 609         } else if (token == "\\topmargin") {
 610                 lex >> topmargin;
 611         } else if (token == "\\rightmargin") {
 612                 lex >> rightmargin;
 613         } else if (token == "\\bottommargin") {
 614                 lex >> bottommargin;
 615         } else if (token == "\\headheight") {
 616                 lex >> headheight;
 617         } else if (token == "\\headsep") {
 618                 lex >> headsep;
 619         } else if (token == "\\footskip") {
 620                 lex >> footskip;
 621         } else if (token == "\\columnsep") {
 622                 lex >> columnsep;
 623         } else if (token == "\\paperfontsize") {
 624                 lex >> fontsize;
 625         } else if (token == "\\papercolumns") {
 626                 lex >> columns;
 627         } else if (token == "\\listings_params") {
 628                 string par;
 629                 lex >> par;
 630                 listings_params = InsetListingsParams(par).params();
 631         } else if (token == "\\papersides") {
 632                 int psides;
 633                 lex >> psides;
 634                 sides = sidestranslator().find(psides);
 635         } else if (token == "\\paperpagestyle") {
 636                 lex >> pagestyle;
 637         } else if (token == "\\bullet") {
 638                 readBullets(lex);
 639         } else if (token == "\\bulletLaTeX") {
 640                 readBulletsLaTeX(lex);
 641         } else if (token == "\\secnumdepth") {
 642                 lex >> secnumdepth;
 643         } else if (token == "\\tocdepth") {
 644                 lex >> tocdepth;
 645         } else if (token == "\\spacing") {
 646                 string nspacing;
 647                 lex >> nspacing;
 648                 string tmp_val;
 649                 if (nspacing == "other") {
 650                         lex >> tmp_val;
 651                 }
 652                 spacing().set(spacetranslator().find(nspacing), tmp_val);
 653         } else if (token == "\\float_placement") {
 654                 lex >> float_placement;
 655
 656         } else if (prefixIs(token, "\\pdf_") || token == "\\use_hyperref") {
 657                 string toktmp = pdfoptions().readToken(lex, token);
 658                 if (!toktmp.empty()) {
 659                         lyxerr << "PDFOptions::readToken(): Unknown token: " <<
 660                                 toktmp << endl;
 661                         return toktmp;
 662                 }
 663         } else {
 664                 lyxerr << "BufferParams::readToken(): Unknown token: " <<
 665                         token << endl;
 666                 return token;
 667         }
 668
 669         return string();
 670 }
 671
 672
 673 void BufferParams::writeFile(ostream & os) const
 674 {
 675         // The top of the file is written by the buffer.
 676         // Prints out the buffer info into the .lyx file given by file
 677
 678         // the textclass
 679         os << "\\textclass " << baseClass()->name() << '\n';
 680
 681         // then the preamble
 682         if (!preamble.empty()) {
 683                 // remove '\n' from the end of preamble
 684                 string const tmppreamble = rtrim(preamble, "\n");
 685                 os << "\\begin_preamble\n"
 686                    << tmppreamble
 687                    << "\n\\end_preamble\n";
 688         }
 689
 690         // the options
 691         if (!options.empty()) {
 692                 os << "\\options " << options << '\n';
 693         }
 694
 695         // the master document
 696         if (!master.empty()) {
 697                 os << "\\master " << master << '\n';
 698         }
 699
 700         // removed modules
 701         if (!removedModules_.empty()) {
 702                 os << "\\begin_removed_modules" << '\n';
 703                 set<string>::const_iterator it = removedModules_.begin();
 704                 set<string>::const_iterator en = removedModules_.end();
 705                 for (; it != en; it++)
 706                         os << *it << '\n';
 707                 os << "\\end_removed_modules" << '\n';
 708         }
 709
 710         // the modules
 711         if (!layoutModules_.empty()) {
 712                 os << "\\begin_modules" << '\n';
 713                 LayoutModuleList::const_iterator it = layoutModules_.begin();
 714                 LayoutModuleList::const_iterator en = layoutModules_.end();
 715                 for (; it != en; it++)
 716                         os << *it << '\n';
 717                 os << "\\end_modules" << '\n';
 718         }
 719
 720         // local layout information
 721         if (!local_layout.empty()) {
 722                 // remove '\n' from the end
 723                 string const tmplocal = rtrim(local_layout, "\n");
 724                 os << "\\begin_local_layout\n"
 725                    << tmplocal
 726                    << "\n\\end_local_layout\n";
 727         }
 728
 729         // then the text parameters
 730         if (language != ignore_language)
 731                 os << "\\language " << language->lang() << '\n';
 732         os << "\\inputencoding " << inputenc
 733            << "\n\\font_roman " << fontsRoman
 734            << "\n\\font_sans " << fontsSans
 735            << "\n\\font_typewriter " << fontsTypewriter
 736            << "\n\\font_default_family " << fontsDefaultFamily
 737            << "\n\\font_sc " << convert<string>(fontsSC)
 738            << "\n\\font_osf " << convert<string>(fontsOSF)
 739            << "\n\\font_sf_scale " << fontsSansScale
 740            << "\n\\font_tt_scale " << fontsTypewriterScale
 741            << '\n';
 742         if (!fontsCJK.empty()) {
 743                 os << "\\font_cjk " << fontsCJK << '\n';
 744         }
 745         os << "\n\\graphics " << graphicsDriver << '\n';
 746
 747         if (!float_placement.empty()) {
 748                 os << "\\float_placement " << float_placement << '\n';
 749         }
 750         os << "\\paperfontsize " << fontsize << '\n';
 751
 752         spacing().writeFile(os);
 753         pdfoptions().writeFile(os);
 754
 755         os << "\\papersize " << string_papersize[papersize]
 756            << "\n\\use_geometry " << convert<string>(use_geometry)
 757            << "\n\\use_amsmath " << use_amsmath
 758            << "\n\\use_esint " << use_esint
 759            << "\n\\cite_engine " << citeenginetranslator().find(cite_engine_)
 760            << "\n\\use_bibtopic " << convert<string>(use_bibtopic)
 761            << "\n\\paperorientation " << string_orientation[orientation]
 762            << '\n';
 763
 764         BranchList::const_iterator it = branchlist().begin();
 765         BranchList::const_iterator end = branchlist().end();
 766         for (; it != end; ++it) {
 767                 os << "\\branch " << to_utf8(it->branch())
 768                    << "\n\\selected " << it->isSelected()
 769                    << "\n\\color " << lyx::X11hexname(it->color())
 770                    << "\n\\end_branch"
 771                    << "\n";
 772         }
 773
 774         if (!paperwidth.empty())
 775                 os << "\\paperwidth "
 776                    << VSpace(paperwidth).asLyXCommand() << '\n';
 777         if (!paperheight.empty())
 778                 os << "\\paperheight "
 779                    << VSpace(paperheight).asLyXCommand() << '\n';
 780         if (!leftmargin.empty())
 781                 os << "\\leftmargin "
 782                    << VSpace(leftmargin).asLyXCommand() << '\n';
 783         if (!topmargin.empty())
 784                 os << "\\topmargin "
 785                    << VSpace(topmargin).asLyXCommand() << '\n';
 786         if (!rightmargin.empty())
 787                 os << "\\rightmargin "
 788                    << VSpace(rightmargin).asLyXCommand() << '\n';
 789         if (!bottommargin.empty())
 790                 os << "\\bottommargin "
 791                    << VSpace(bottommargin).asLyXCommand() << '\n';
 792         if (!headheight.empty())
 793                 os << "\\headheight "
 794                    << VSpace(headheight).asLyXCommand() << '\n';
 795         if (!headsep.empty())
 796                 os << "\\headsep "
 797                    << VSpace(headsep).asLyXCommand() << '\n';
 798         if (!footskip.empty())
 799                 os << "\\footskip "
 800                    << VSpace(footskip).asLyXCommand() << '\n';
 801         if (!columnsep.empty())
 802                 os << "\\columnsep "
 803                          << VSpace(columnsep).asLyXCommand() << '\n';
 804         os << "\\secnumdepth " << secnumdepth
 805            << "\n\\tocdepth " << tocdepth
 806            << "\n\\paragraph_separation "
 807            << string_paragraph_separation[paragraph_separation]
 808            << "\n\\defskip " << getDefSkip().asLyXCommand()
 809            << "\n\\quotes_language "
 810            << string_quotes_language[quotes_language]
 811            << "\n\\papercolumns " << columns
 812            << "\n\\papersides " << sides
 813            << "\n\\paperpagestyle " << pagestyle << '\n';
 814         if (!listings_params.empty())
 815                 os << "\\listings_params \"" <<
 816                         InsetListingsParams(listings_params).encodedString() << "\"\n";
 817         for (int i = 0; i < 4; ++i) {
 818                 if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) {
 819                         if (user_defined_bullet(i).getFont() != -1) {
 820                                 os << "\\bullet " << i << " "
 821                                    << user_defined_bullet(i).getFont() << " "
 822                                    << user_defined_bullet(i).getCharacter() << " "
 823                                    << user_defined_bullet(i).getSize() << "\n";
 824                         }
 825                         else {
 826                                 // FIXME UNICODE
 827                                 os << "\\bulletLaTeX " << i << " \""
 828                                    << lyx::to_ascii(user_defined_bullet(i).getText())
 829                                    << "\"\n";
 830                         }
 831                 }
 832         }
 833
 834         os << "\\tracking_changes " << convert<string>(trackChanges) << "\n";
 835         os << "\\output_changes " << convert<string>(outputChanges) << "\n";
 836
 837         AuthorList::Authors::const_iterator a_it = pimpl_->authorlist.begin();
 838         AuthorList::Authors::const_iterator a_end = pimpl_->authorlist.end();
 839         for (; a_it != a_end; ++a_it) {
 840                 if (a_it->second.used())
 841                         os << "\\author " << a_it->second << "\n";
 842                 else
 843                         os << "\\author " << Author() << "\n";
 844         }
 845 }
 846
 847
 848 void BufferParams::validate(LaTeXFeatures & features) const
 849 {
 850         features.require(documentClass().requires());
 851
 852         if (outputChanges) {
 853                 bool dvipost    = LaTeXFeatures::isAvailable("dvipost");
 854                 bool xcolorsoul = LaTeXFeatures::isAvailable("soul") &&
 855                                   LaTeXFeatures::isAvailable("xcolor");
 856
 857                 switch (features.runparams().flavor) {
 858                 case OutputParams::LATEX:
 859                         if (dvipost) {
 860                                 features.require("ct-dvipost");
 861                                 features.require("dvipost");
 862                         } else if (xcolorsoul) {
 863                                 features.require("ct-xcolor-soul");
 864                                 features.require("soul");
 865                                 features.require("xcolor");
 866                         } else {
 867                                 features.require("ct-none");
 868                         }
 869                         break;
 870                 case OutputParams::PDFLATEX:
 871                         if (xcolorsoul) {
 872                                 features.require("ct-xcolor-soul");
 873                                 features.require("soul");
 874                                 features.require("xcolor");
 875                                 // improves color handling in PDF output
 876                                 features.require("pdfcolmk");
 877                         } else {
 878                                 features.require("ct-none");
 879                         }
 880                         break;
 881                 default:
 882                         break;
 883                 }
 884         }
 885
 886         // Floats with 'Here definitely' as default setting.
 887         if (float_placement.find('H') != string::npos)
 888                 features.require("float");
 889
 890         // AMS Style is at document level
 891         if (use_amsmath == package_on
 892             || documentClass().provides("amsmath"))
 893                 features.require("amsmath");
 894         if (use_esint == package_on)
 895                 features.require("esint");
 896
 897         // Document-level line spacing
 898         if (spacing().getSpace() != Spacing::Single && !spacing().isDefault())
 899                 features.require("setspace");
 900
 901         // the bullet shapes are buffer level not paragraph level
 902         // so they are tested here
 903         for (int i = 0; i < 4; ++i) {
 904                 if (user_defined_bullet(i) == ITEMIZE_DEFAULTS[i])
 905                         continue;
 906                 int const font = user_defined_bullet(i).getFont();
 907                 if (font == 0) {
 908                         int const c = user_defined_bullet(i).getCharacter();
 909                         if (c == 16
 910                             || c == 17
 911                             || c == 25
 912                             || c == 26
 913                             || c == 31) {
 914                                 features.require("latexsym");
 915                         }
 916                 } else if (font == 1) {
 917                         features.require("amssymb");
 918                 } else if (font >= 2 && font <= 5) {
 919                         features.require("pifont");
 920                 }
 921         }
 922
 923         if (pdfoptions().use_hyperref) {
 924                 features.require("hyperref");
 925                 // due to interferences with babel and hyperref, the color package has to
 926                 // be loaded after hyperref when hyperref is used with the colorlinks
 927                 // option, see http://bugzilla.lyx.org/show_bug.cgi?id=5291
 928                 if (pdfoptions().colorlinks)
 929                         features.require("color");
 930         }
 931
 932         if (language->lang() == "vietnamese")
 933                 features.require("vietnamese");
 934         else if (language->lang() == "japanese")
 935                 features.require("japanese");
 936 }
 937
 938
 939 bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features,
 940                               TexRow & texrow) const
 941 {
 942         os << "\\documentclass";
 943
 944         DocumentClass const & tclass = documentClass();
 945
 946         ostringstream clsoptions; // the document class options.
 947
 948         if (tokenPos(tclass.opt_fontsize(),
 949                      '|', fontsize) >= 0) {
 950                 // only write if existing in list (and not default)
 951                 clsoptions << fontsize << "pt,";
 952         }
 953
 954         // custom, A3, B3 and B4 paper sizes need geometry
 955         bool nonstandard_papersize = papersize == PAPER_B3
 956                 || papersize == PAPER_B4
 957                 || papersize == PAPER_A3
 958                 || papersize == PAPER_CUSTOM;
 959
 960         if (!use_geometry) {
 961                 switch (papersize) {
 962                 case PAPER_A4:
 963                         clsoptions << "a4paper,";
 964                         break;
 965                 case PAPER_USLETTER:
 966                         clsoptions << "letterpaper,";
 967                         break;
 968                 case PAPER_A5:
 969                         clsoptions << "a5paper,";
 970                         break;
 971                 case PAPER_B5:
 972                         clsoptions << "b5paper,";
 973                         break;
 974                 case PAPER_USEXECUTIVE:
 975                         clsoptions << "executivepaper,";
 976                         break;
 977                 case PAPER_USLEGAL:
 978                         clsoptions << "legalpaper,";
 979                         break;
 980                 case PAPER_DEFAULT:
 981                 case PAPER_A3:
 982                 case PAPER_B3:
 983                 case PAPER_B4:
 984                 case PAPER_CUSTOM:
 985                         break;
 986                 }
 987         }
 988
 989         // if needed
 990         if (sides != tclass.sides()) {
 991                 switch (sides) {
 992                 case OneSide:
 993                         clsoptions << "oneside,";
 994                         break;
 995                 case TwoSides:
 996                         clsoptions << "twoside,";
 997                         break;
 998                 }
 999         }
1000
1001         // if needed
1002         if (columns != tclass.columns()) {
1003                 if (columns == 2)
1004                         clsoptions << "twocolumn,";
1005                 else
1006                         clsoptions << "onecolumn,";
1007         }
1008
1009         if (!use_geometry
1010             && orientation == ORIENTATION_LANDSCAPE)
1011                 clsoptions << "landscape,";
1012
1013         // language should be a parameter to \documentclass
1014         if (language->babel() == "hebrew"
1015             && default_language->babel() != "hebrew")
1016                 // This seems necessary
1017                 features.useLanguage(default_language);
1018
1019         ostringstream language_options;
1020         bool const use_babel = features.useBabel();
1021         if (use_babel) {
1022                 language_options << features.getLanguages();
1023                 if (!language->babel().empty()) {
1024                         if (!language_options.str().empty())
1025                                 language_options << ',';
1026                         language_options << language->babel();
1027                 }
1028                 // if Vietnamese is used, babel must directly be loaded
1029                 // with language options, not in the class options, see
1030                 // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129417.html
1031                 size_t viet = language_options.str().find("vietnam");
1032                 // viet = string::npos when not found
1033                 // if Japanese is used, babel must directly be loaded
1034                 // with language options, not in the class options, see
1035                 // http://bugzilla.lyx.org/show_bug.cgi?id=4597#c4
1036                 size_t japan = language_options.str().find("japanese");
1037                 // japan = string::npos when not found
1038                 if (lyxrc.language_global_options
1039                         && !language_options.str().empty()
1040                         && viet == string::npos && japan == string::npos)
1041                         clsoptions << language_options.str() << ',';
1042         }
1043
1044         // the user-defined options
1045         if (!options.empty()) {
1046                 clsoptions << options << ',';
1047         }
1048
1049         string strOptions(clsoptions.str());
1050         if (!strOptions.empty()) {
1051                 strOptions = rtrim(strOptions, ",");
1052                 // FIXME UNICODE
1053                 os << '[' << from_utf8(strOptions) << ']';
1054         }
1055
1056         os << '{' << from_ascii(tclass.latexname()) << "}\n";
1057         texrow.newline();
1058         // end of \documentclass defs
1059
1060         // font selection must be done before loading fontenc.sty
1061         string const fonts =
1062                 loadFonts(fontsRoman, fontsSans,
1063                           fontsTypewriter, fontsSC, fontsOSF,
1064                           fontsSansScale, fontsTypewriterScale);
1065         if (!fonts.empty()) {
1066                 os << from_ascii(fonts);
1067                 texrow.newline();
1068         }
1069         if (fontsDefaultFamily != "default")
1070                 os << "\\renewcommand{\\familydefault}{\\"
1071                    << from_ascii(fontsDefaultFamily) << "}\n";
1072
1073         // set font encoding
1074         // this one is not per buffer
1075         // for arabic_arabi and farsi we also need to load the LAE and
1076         // LFE encoding
1077         if (lyxrc.fontenc != "default" && language->lang() != "japanese") {
1078                 if (language->lang() == "arabic_arabi"
1079                     || language->lang() == "farsi") {
1080                         os << "\\usepackage[" << from_ascii(lyxrc.fontenc)
1081                            << ",LFE,LAE]{fontenc}\n";
1082                         texrow.newline();
1083                 } else {
1084                         os << "\\usepackage[" << from_ascii(lyxrc.fontenc)
1085                            << "]{fontenc}\n";
1086                         texrow.newline();
1087                 }
1088         }
1089
1090         // handle inputenc etc.
1091         writeEncodingPreamble(os, features, texrow);
1092
1093         if (!listings_params.empty() || features.isRequired("listings")) {
1094                 os << "\\usepackage{listings}\n";
1095                 texrow.newline();
1096         }
1097         if (!listings_params.empty()) {
1098                 os << "\\lstset{";
1099                 // do not test validity because listings_params is
1100                 // supposed to be valid
1101                 string par =
1102                         InsetListingsParams(listings_params).separatedParams(true);
1103                 // we can't support all packages, but we should load the color package
1104                 if (par.find("\\color", 0) != string::npos)
1105                         features.require("color");
1106                 os << from_utf8(par);
1107                 // count the number of newlines
1108                 for (size_t i = 0; i < par.size(); ++i)
1109                         if (par[i] == '\n')
1110                                 texrow.newline();
1111                 os << "}\n";
1112                 texrow.newline();
1113         }
1114         if (use_geometry || nonstandard_papersize) {
1115                 os << "\\usepackage{geometry}\n";
1116                 texrow.newline();
1117                 os << "\\geometry{verbose";
1118                 if (orientation == ORIENTATION_LANDSCAPE)
1119                         os << ",landscape";
1120                 switch (papersize) {
1121                 case PAPER_CUSTOM:
1122                         if (!paperwidth.empty())
1123                                 os << ",paperwidth="
1124                                    << from_ascii(paperwidth);
1125                         if (!paperheight.empty())
1126                                 os << ",paperheight="
1127                                    << from_ascii(paperheight);
1128                         break;
1129                 case PAPER_USLETTER:
1130                         os << ",letterpaper";
1131                         break;
1132                 case PAPER_USLEGAL:
1133                         os << ",legalpaper";
1134                         break;
1135                 case PAPER_USEXECUTIVE:
1136                         os << ",executivepaper";
1137                         break;
1138                 case PAPER_A3:
1139                         os << ",a3paper";
1140                         break;
1141                 case PAPER_A4:
1142                         os << ",a4paper";
1143                         break;
1144                 case PAPER_A5:
1145                         os << ",a5paper";
1146                         break;
1147                 case PAPER_B3:
1148                         os << ",b3paper";
1149                         break;
1150                 case PAPER_B4:
1151                         os << ",b4paper";
1152                         break;
1153                 case PAPER_B5:
1154                         os << ",b5paper";
1155                         break;
1156                 default:
1157                         // default papersize ie PAPER_DEFAULT
1158                         switch (lyxrc.default_papersize) {
1159                         case PAPER_DEFAULT: // keep compiler happy
1160                         case PAPER_USLETTER:
1161                                 os << ",letterpaper";
1162                                 break;
1163                         case PAPER_USLEGAL:
1164                                 os << ",legalpaper";
1165                                 break;
1166                         case PAPER_USEXECUTIVE:
1167                                 os << ",executivepaper";
1168                                 break;
1169                         case PAPER_A3:
1170                                 os << ",a3paper";
1171                                 break;
1172                         case PAPER_A4:
1173                                 os << ",a4paper";
1174                                 break;
1175                         case PAPER_A5:
1176                                 os << ",a5paper";
1177                                 break;
1178                         case PAPER_B5:
1179                                 os << ",b5paper";
1180                                 break;
1181                         case PAPER_B3:
1182                         case PAPER_B4:
1183                         case PAPER_CUSTOM:
1184                                 break;
1185                         }
1186                 }
1187                 if (!topmargin.empty())
1188                         os << ",tmargin=" << from_ascii(Length(topmargin).asLatexString());
1189                 if (!bottommargin.empty())
1190                         os << ",bmargin=" << from_ascii(Length(bottommargin).asLatexString());
1191                 if (!leftmargin.empty())
1192                         os << ",lmargin=" << from_ascii(Length(leftmargin).asLatexString());
1193                 if (!rightmargin.empty())
1194                         os << ",rmargin=" << from_ascii(Length(rightmargin).asLatexString());
1195                 if (!headheight.empty())
1196                         os << ",headheight=" << from_ascii(Length(headheight).asLatexString());
1197                 if (!headsep.empty())
1198                         os << ",headsep=" << from_ascii(Length(headsep).asLatexString());
1199                 if (!footskip.empty())
1200                         os << ",footskip=" << from_ascii(Length(footskip).asLatexString());
1201                 if (!columnsep.empty())
1202                         os << ",columnsep=" << from_ascii(Length(columnsep).asLatexString());
1203                 os << "}\n";
1204                 texrow.newline();
1205         } else if (orientation == ORIENTATION_LANDSCAPE) {
1206                 features.require("papersize");
1207         }
1208
1209         if (tokenPos(tclass.opt_pagestyle(),
1210                      '|', pagestyle) >= 0) {
1211                 if (pagestyle == "fancy") {
1212                         os << "\\usepackage{fancyhdr}\n";
1213                         texrow.newline();
1214                 }
1215                 os << "\\pagestyle{" << from_ascii(pagestyle) << "}\n";
1216                 texrow.newline();
1217         }
1218
1219         // Only if class has a ToC hierarchy
1220         if (tclass.hasTocLevels()) {
1221                 if (secnumdepth != tclass.secnumdepth()) {
1222                         os << "\\setcounter{secnumdepth}{"
1223                            << secnumdepth
1224                            << "}\n";
1225                         texrow.newline();
1226                 }
1227                 if (tocdepth != tclass.tocdepth()) {
1228                         os << "\\setcounter{tocdepth}{"
1229                            << tocdepth
1230                            << "}\n";
1231                         texrow.newline();
1232                 }
1233         }
1234
1235         if (paragraph_separation) {
1236                 switch (getDefSkip().kind()) {
1237                 case VSpace::SMALLSKIP:
1238                         os << "\\setlength{\\parskip}{\\smallskipamount}\n";
1239                         break;
1240                 case VSpace::MEDSKIP:
1241                         os << "\\setlength{\\parskip}{\\medskipamount}\n";
1242                         break;
1243                 case VSpace::BIGSKIP:
1244                         os << "\\setlength{\\parskip}{\\bigskipamount}\n";
1245                         break;
1246                 case VSpace::LENGTH:
1247                         os << "\\setlength{\\parskip}{"
1248                            << from_utf8(getDefSkip().length().asLatexString())
1249                            << "}\n";
1250                         break;
1251                 default: // should never happen // Then delete it.
1252                         os << "\\setlength{\\parskip}{\\medskipamount}\n";
1253                         break;
1254                 }
1255                 texrow.newline();
1256
1257                 os << "\\setlength{\\parindent}{0pt}\n";
1258                 texrow.newline();
1259         }
1260
1261         // Now insert the LyX specific LaTeX commands...
1262         docstring lyxpreamble;
1263
1264         // due to interferences with babel and hyperref, the color package has to
1265         // be loaded (when it is not already loaded) before babel when hyperref
1266         // is used with the colorlinks option, see
1267         // http://bugzilla.lyx.org/show_bug.cgi?id=5291
1268         // we decided therefore to load color always before babel, see
1269         // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg144349.html
1270         lyxpreamble += from_ascii(features.getColorOptions());
1271
1272         // If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them.
1273         if (use_babel
1274                 && (features.isRequired("jurabib")
1275                         || features.isRequired("hyperref")
1276                         || features.isRequired("vietnamese")
1277                         || features.isRequired("japanese") ) ) {
1278                                 // FIXME UNICODE
1279                                 lyxpreamble += from_utf8(babelCall(language_options.str())) + '\n';
1280                                 lyxpreamble += from_utf8(features.getBabelOptions()) + '\n';
1281         }
1282
1283         // The optional packages;
1284         lyxpreamble += from_ascii(features.getPackages());
1285
1286         // Line spacing
1287         lyxpreamble += from_utf8(spacing().writePreamble(tclass.provides("SetSpace")));
1288
1289         // PDF support.
1290         // * Hyperref manual: "Make sure it comes last of your loaded
1291         //   packages, to give it a fighting chance of not being over-written,
1292         //   since its job is to redefine many LATEX commands."
1293         // * Email from Heiko Oberdiek: "It is usually better to load babel
1294         //   before hyperref. Then hyperref has a chance to detect babel.
1295         // * Has to be loaded before the "LyX specific LaTeX commands" to
1296         //   avoid errors with algorithm floats.
1297         // use hyperref explicitely when it is required
1298         if (features.isRequired("hyperref")) {
1299                 odocstringstream oss;
1300                 pdfoptions().writeLaTeX(oss, documentClass().provides("hyperref"));
1301                 lyxpreamble += oss.str();
1302         }
1303
1304         // Will be surrounded by \makeatletter and \makeatother when needed
1305         docstring atlyxpreamble;
1306
1307         // Some macros LyX will need
1308         docstring tmppreamble(from_ascii(features.getMacros()));
1309
1310         if (!tmppreamble.empty())
1311                 atlyxpreamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1312                         "LyX specific LaTeX commands.\n"
1313                         + tmppreamble + '\n';
1314
1315         // the text class specific preamble
1316         tmppreamble = features.getTClassPreamble();
1317         if (!tmppreamble.empty())
1318                 atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1319                         "Textclass specific LaTeX commands.\n"
1320                         + tmppreamble + '\n';
1321
1322         /* the user-defined preamble */
1323         if (!preamble.empty())
1324                 // FIXME UNICODE
1325                 atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1326                         "User specified LaTeX commands.\n"
1327                         + from_utf8(preamble) + '\n';
1328
1329         // subfig loads internally the LaTeX package "caption". As
1330         // caption is a very popular package, users will load it in
1331         // the preamble. Therefore we must load subfig behind the
1332         // user-defined preamble and check if the caption package was
1333         // loaded or not. For the case that caption is loaded before
1334         // subfig, there is the subfig option "caption=false". This
1335         // option also works when a koma-script class is used and
1336         // koma's own caption commands are used instead of caption. We
1337         // use \PassOptionsToPackage here because the user could have
1338         // already loaded subfig in the preamble.
1339         if (features.isRequired("subfig")) {
1340                 atlyxpreamble += "\\@ifundefined{showcaptionsetup}{}{%\n"
1341                         " \\PassOptionsToPackage{caption=false}{subfig}}\n"
1342                         "\\usepackage{subfig}\n";
1343         }
1344
1345         // Itemize bullet settings need to be last in case the user
1346         // defines their own bullets that use a package included
1347         // in the user-defined preamble -- ARRae
1348         // Actually it has to be done much later than that
1349         // since some packages like frenchb make modifications
1350         // at \begin{document} time -- JMarc
1351         docstring bullets_def;
1352         for (int i = 0; i < 4; ++i) {
1353                 if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) {
1354                         if (bullets_def.empty())
1355                                 bullets_def += "\\AtBeginDocument{\n";
1356                         bullets_def += "  \\def\\labelitemi";
1357                         switch (i) {
1358                                 // `i' is one less than the item to modify
1359                         case 0:
1360                                 break;
1361                         case 1:
1362                                 bullets_def += 'i';
1363                                 break;
1364                         case 2:
1365                                 bullets_def += "ii";
1366                                 break;
1367                         case 3:
1368                                 bullets_def += 'v';
1369                                 break;
1370                         }
1371                         bullets_def += '{' +
1372                                 user_defined_bullet(i).getText()
1373                                 + "}\n";
1374                 }
1375         }
1376
1377         if (!bullets_def.empty())
1378                 atlyxpreamble += bullets_def + "}\n\n";
1379
1380         if (atlyxpreamble.find(from_ascii("@")) != docstring::npos)
1381                 lyxpreamble += "\n\\makeatletter\n"
1382                         + atlyxpreamble + "\\makeatother\n\n";
1383         else
1384                 lyxpreamble += '\n' + atlyxpreamble;
1385
1386         // We try to load babel late, in case it interferes with other packages.
1387         // Jurabib and Hyperref have to be called after babel, though.
1388         if (use_babel && !features.isRequired("jurabib")
1389             && !features.isRequired("hyperref")
1390             && !features.isRequired("vietnamese")
1391             && !features.isRequired("japanese")) {
1392                 // FIXME UNICODE
1393                 lyxpreamble += from_utf8(babelCall(language_options.str())) + '\n';
1394                 lyxpreamble += from_utf8(features.getBabelOptions()) + '\n';
1395         }
1396
1397         int const nlines =
1398                 int(count(lyxpreamble.begin(), lyxpreamble.end(), '\n'));
1399         for (int j = 0; j != nlines; ++j) {
1400                 texrow.newline();
1401         }
1402
1403         os << lyxpreamble;
1404         return use_babel;
1405 }
1406
1407
1408 void BufferParams::useClassDefaults()
1409 {
1410         DocumentClass const & tclass = documentClass();
1411
1412         sides = tclass.sides();
1413         columns = tclass.columns();
1414         pagestyle = tclass.pagestyle();
1415         options = tclass.options();
1416         // Only if class has a ToC hierarchy
1417         if (tclass.hasTocLevels()) {
1418                 secnumdepth = tclass.secnumdepth();
1419                 tocdepth = tclass.tocdepth();
1420         }
1421 }
1422
1423
1424 bool BufferParams::hasClassDefaults() const
1425 {
1426         DocumentClass const & tclass = documentClass();
1427
1428         return sides == tclass.sides()
1429                 && columns == tclass.columns()
1430                 && pagestyle == tclass.pagestyle()
1431                 && options == tclass.options()
1432                 && secnumdepth == tclass.secnumdepth()
1433                 && tocdepth == tclass.tocdepth();
1434 }
1435
1436
1437 DocumentClass const & BufferParams::documentClass() const
1438 {
1439         return *doc_class_;
1440 }
1441
1442
1443 DocumentClass const * BufferParams::documentClassPtr() const {
1444         return doc_class_;
1445 }
1446
1447
1448 void BufferParams::setDocumentClass(DocumentClass const * const tc) {
1449         // evil, but this function is evil
1450         doc_class_ = const_cast<DocumentClass *>(tc);
1451 }
1452
1453
1454 bool BufferParams::setBaseClass(string const & classname)
1455 {
1456         LYXERR(Debug::TCLASS, "setBaseClass: " << classname);
1457         LayoutFileList & bcl = LayoutFileList::get();
1458         if (!bcl.haveClass(classname)) {
1459                 docstring s =
1460                         bformat(_("The document class %1$s could not be found. "
1461                                 "A default textclass with default layouts will be used. "
1462                                 "LyX might not be able to produce output unless a correct "
1463                                 "textclass is selected from the document settings dialog."),
1464                         from_utf8(classname));
1465                 frontend::Alert::error(_("Document class not found"), s);
1466                 bcl.addEmptyClass(classname);
1467         }
1468
1469         bool const success = bcl[classname].load();
1470         if (!success) {
1471                 docstring s =
1472                         bformat(_("The document class %1$s could not be loaded."),
1473                         from_utf8(classname));
1474                 frontend::Alert::error(_("Could not load class"), s);
1475                 return false;
1476         }
1477
1478         pimpl_->baseClass_ = classname;
1479
1480         // add any required modules not already in use
1481         set<string> const & mods = baseClass()->defaultModules();
1482         set<string>::const_iterator mit = mods.begin();
1483         set<string>::const_iterator men = mods.end();
1484         for (; mit != men; mit++) {
1485                 string const & modName = *mit;
1486                 // see if we're already in use
1487                 if (find(layoutModules_.begin(), layoutModules_.end(), modName) !=
1488                     layoutModules_.end()) {
1489                         LYXERR(Debug::TCLASS, "Default module `" << modName <<
1490                                         "' not added because already used.");
1491                         continue;
1492                 }
1493                 // make sure the user hasn't removed it
1494                 if (find(removedModules_.begin(), removedModules_.end(), modName) !=
1495                     removedModules_.end()) {
1496                         LYXERR(Debug::TCLASS, "Default module `" << modName <<
1497                                         "' not added because removed by user.");
1498                         continue;
1499                 }
1500                 // Now we want to check the list of selected modules to see if any of them
1501                 // exclude this one.
1502                 bool foundit = false;
1503                 // so iterate over the selected modules...
1504                 LayoutModuleList::const_iterator lit = layoutModules_.begin();
1505                 LayoutModuleList::const_iterator len = layoutModules_.end();
1506                 for (; lit != len; lit++) {
1507                         LyXModule * lm = moduleList[*lit];
1508                         if (!lm)
1509                                 continue;
1510                         vector<string> const & exc = lm->getExcludedModules();
1511                         // ...and see if this one excludes us.
1512                         if (find(exc.begin(), exc.end(), modName) != exc.end()) {
1513                                 foundit = true;
1514                                 LYXERR(Debug::TCLASS, "Default module `" << modName <<
1515                                                 "' not added because excluded by loaded module `" <<
1516                                                 *lit << "'.");
1517                                 break;
1518                         }
1519                 }
1520                 if (!foundit) {
1521                         LYXERR(Debug::TCLASS, "Default module `" << modName << "' added.");
1522                         layoutModules_.push_back(modName);
1523                 }
1524         }
1525         return true;
1526 }
1527
1528
1529 LayoutFile const * BufferParams::baseClass() const
1530 {
1531         if (LayoutFileList::get().haveClass(pimpl_->baseClass_))
1532                 return &(LayoutFileList::get()[pimpl_->baseClass_]);
1533         else
1534                 return 0;
1535 }
1536
1537
1538 LayoutFileIndex const & BufferParams::baseClassID() const
1539 {
1540         return pimpl_->baseClass_;
1541 }
1542
1543
1544 void BufferParams::makeDocumentClass()
1545 {
1546         if (!baseClass())
1547                 return;
1548
1549         doc_class_ = &(DocumentClassBundle::get().newClass(*baseClass()));
1550
1551         // FIXME It might be worth loading the children's modules here,
1552         // just as we load their bibliographies and such, instead of just
1553         // doing a check in InsetInclude.
1554         LayoutModuleList::const_iterator it = layoutModules_.begin();
1555         for (; it != layoutModules_.end(); it++) {
1556                 string const modName = *it;
1557                 LyXModule * lm = moduleList[modName];
1558                 if (!lm) {
1559                         docstring const msg =
1560                                 bformat(_("The module %1$s has been requested by\n"
1561                                         "this document but has not been found in the list of\n"
1562                                         "available modules. If you recently installed it, you\n"
1563                                         "probably need to reconfigure LyX.\n"), from_utf8(modName));
1564                         frontend::Alert::warning(_("Module not available"),
1565                                         msg + _("Some layouts may not be available."));
1566                         LYXERR0("BufferParams::makeDocumentClass(): Module " <<
1567                                         modName << " requested but not found in module list.");
1568                         continue;
1569                 }
1570                 if (!lm->isAvailable()) {
1571                         docstring const msg =
1572                                                 bformat(_("The module %1$s requires a package that is\n"
1573                                                 "not available in your LaTeX installation. LaTeX output\n"
1574                                                 "may not be possible.\n"), from_utf8(modName));
1575                         frontend::Alert::warning(_("Package not available"), msg);
1576                 }
1577                 FileName layout_file = libFileSearch("layouts", lm->getFilename());
1578                 if (!doc_class_->read(layout_file, TextClass::MODULE)) {
1579                         docstring const msg =
1580                                 bformat(_("Error reading module %1$s\n"), from_utf8(modName));
1581                         frontend::Alert::warning(_("Read Error"), msg);
1582                 }
1583         }
1584         if (!local_layout.empty()) {
1585                 if (!doc_class_->read(local_layout, TextClass::MODULE)) {
1586                         docstring const msg = _("Error reading internal layout information");
1587                         frontend::Alert::warning(_("Read Error"), msg);
1588                 }
1589         }
1590 }
1591
1592
1593 bool BufferParams::addLayoutModule(string const & modName)
1594 {
1595         LayoutModuleList::const_iterator it = layoutModules_.begin();
1596         LayoutModuleList::const_iterator end = layoutModules_.end();
1597         for (; it != end; it++)
1598                 if (*it == modName)
1599                         return false;
1600         layoutModules_.push_back(modName);
1601         return true;
1602 }
1603
1604
1605 Font const BufferParams::getFont() const
1606 {
1607         FontInfo f = documentClass().defaultfont();
1608         if (fontsDefaultFamily == "rmdefault")
1609                 f.setFamily(ROMAN_FAMILY);
1610         else if (fontsDefaultFamily == "sfdefault")
1611                 f.setFamily(SANS_FAMILY);
1612         else if (fontsDefaultFamily == "ttdefault")
1613                 f.setFamily(TYPEWRITER_FAMILY);
1614         return Font(f, language);
1615 }
1616
1617
1618 void BufferParams::readPreamble(Lexer & lex)
1619 {
1620         if (lex.getString() != "\\begin_preamble")
1621                 lyxerr << "Error (BufferParams::readPreamble):"
1622                         "consistency check failed." << endl;
1623
1624         preamble = lex.getLongString("\\end_preamble");
1625 }
1626
1627
1628 void BufferParams::readLocalLayout(Lexer & lex)
1629 {
1630         if (lex.getString() != "\\begin_local_layout")
1631                 lyxerr << "Error (BufferParams::readLocalLayout):"
1632                         "consistency check failed." << endl;
1633
1634         local_layout = lex.getLongString("\\end_local_layout");
1635 }
1636
1637
1638 void BufferParams::readLanguage(Lexer & lex)
1639 {
1640         if (!lex.next()) return;
1641
1642         string const tmptok = lex.getString();
1643
1644         // check if tmptok is part of tex_babel in tex-defs.h
1645         language = languages.getLanguage(tmptok);
1646         if (!language) {
1647                 // Language tmptok was not found
1648                 language = default_language;
1649                 lyxerr << "Warning: Setting language `"
1650                        << tmptok << "' to `" << language->lang()
1651                        << "'." << endl;
1652         }
1653 }
1654
1655
1656 void BufferParams::readGraphicsDriver(Lexer & lex)
1657 {
1658         if (!lex.next())
1659                 return;
1660
1661         string const tmptok = lex.getString();
1662         // check if tmptok is part of tex_graphics in tex_defs.h
1663         int n = 0;
1664         while (true) {
1665                 string const test = tex_graphics[n++];
1666
1667                 if (test == tmptok) {
1668                         graphicsDriver = tmptok;
1669                         break;
1670                 }
1671                 if (test.empty()) {
1672                         lex.printError(
1673                                 "Warning: graphics driver `$$Token' not recognized!\n"
1674                                 "         Setting graphics driver to `default'.\n");
1675                         graphicsDriver = "default";
1676                         break;
1677                 }
1678         }
1679 }
1680
1681
1682 void BufferParams::readBullets(Lexer & lex)
1683 {
1684         if (!lex.next())
1685                 return;
1686
1687         int const index = lex.getInteger();
1688         lex.next();
1689         int temp_int = lex.getInteger();
1690         user_defined_bullet(index).setFont(temp_int);
1691         temp_bullet(index).setFont(temp_int);
1692         lex >> temp_int;
1693         user_defined_bullet(index).setCharacter(temp_int);
1694         temp_bullet(index).setCharacter(temp_int);
1695         lex >> temp_int;
1696         user_defined_bullet(index).setSize(temp_int);
1697         temp_bullet(index).setSize(temp_int);
1698 }
1699
1700
1701 void BufferParams::readBulletsLaTeX(Lexer & lex)
1702 {
1703         // The bullet class should be able to read this.
1704         if (!lex.next())
1705                 return;
1706         int const index = lex.getInteger();
1707         lex.next(true);
1708         docstring const temp_str = lex.getDocString();
1709
1710         user_defined_bullet(index).setText(temp_str);
1711         temp_bullet(index).setText(temp_str);
1712 }
1713
1714
1715 void BufferParams::readModules(Lexer & lex)
1716 {
1717         if (!lex.eatLine()) {
1718                 lyxerr << "Error (BufferParams::readModules):"
1719                                 "Unexpected end of input." << endl;
1720                 return;
1721         }
1722         while (true) {
1723                 string mod = lex.getString();
1724                 if (mod == "\\end_modules")
1725                         break;
1726                 addLayoutModule(mod);
1727                 lex.eatLine();
1728         }
1729 }
1730
1731
1732 void BufferParams::readRemovedModules(Lexer & lex)
1733 {
1734         if (!lex.eatLine()) {
1735                 lyxerr << "Error (BufferParams::readRemovedModules):"
1736                                 "Unexpected end of input." << endl;
1737                 return;
1738         }
1739         while (true) {
1740                 string mod = lex.getString();
1741                 if (mod == "\\end_removed_modules")
1742                         break;
1743                 removedModules_.insert(mod);
1744                 lex.eatLine();
1745         }
1746         // now we want to remove any removed modules that were previously
1747         // added. normally, that will be because default modules were added in
1748         // setBaseClass(), which gets called when \textclass is read at the
1749         // start of the read.
1750         set<string>::const_iterator rit = removedModules_.begin();
1751         set<string>::const_iterator const ren = removedModules_.end();
1752         for (; rit != ren; rit++) {
1753                 LayoutModuleList::iterator const mit = layoutModules_.begin();
1754                 LayoutModuleList::iterator const men = layoutModules_.end();
1755                 LayoutModuleList::iterator found = find(mit, men, *rit);
1756                 if (found == men)
1757                         continue;
1758                 layoutModules_.erase(found);
1759         }
1760 }
1761
1762
1763 string BufferParams::paperSizeName(PapersizePurpose purpose) const
1764 {
1765         char real_papersize = papersize;
1766         if (real_papersize == PAPER_DEFAULT)
1767                 real_papersize = lyxrc.default_papersize;
1768
1769         switch (real_papersize) {
1770         case PAPER_DEFAULT:
1771                 // could be anything, so don't guess
1772                 return string();
1773         case PAPER_CUSTOM: {
1774                 if (purpose == XDVI && !paperwidth.empty() &&
1775                     !paperheight.empty()) {
1776                         // heightxwidth<unit>
1777                         string first = paperwidth;
1778                         string second = paperheight;
1779                         if (orientation == ORIENTATION_LANDSCAPE)
1780                                 first.swap(second);
1781                         // cut off unit.
1782                         return first.erase(first.length() - 2)
1783                                 + "x" + second;
1784                 }
1785                 return string();
1786         }
1787         case PAPER_A3:
1788                 return "a3";
1789         case PAPER_A4:
1790                 return "a4";
1791         case PAPER_A5:
1792                 return "a5";
1793         case PAPER_B3:
1794                 // dvips and dvipdfm do not know this
1795                 if (purpose == DVIPS || purpose == DVIPDFM)
1796                         return string();
1797                 return "b3";
1798         case PAPER_B4:
1799                 // dvipdfm does not know this
1800                 if (purpose == DVIPDFM)
1801                         return string();
1802                 return "b4";
1803         case PAPER_B5:
1804                 // dvipdfm does not know this
1805                 if (purpose == DVIPDFM)
1806                         return string();
1807                 return "b5";
1808         case PAPER_USEXECUTIVE:
1809                 // dvipdfm does not know this
1810                 if (purpose == DVIPDFM)
1811                         return string();
1812                 return "foolscap";
1813         case PAPER_USLEGAL:
1814                 return "legal";
1815         case PAPER_USLETTER:
1816         default:
1817                 if (purpose == XDVI)
1818                         return "us";
1819                 return "letter";
1820         }
1821 }
1822
1823
1824 string const BufferParams::dvips_options() const
1825 {
1826         string result;
1827
1828         if (use_geometry
1829             && papersize == PAPER_CUSTOM
1830             && !lyxrc.print_paper_dimension_flag.empty()
1831             && !paperwidth.empty()
1832             && !paperheight.empty()) {
1833                 // using a custom papersize
1834                 result = lyxrc.print_paper_dimension_flag;
1835                 result += ' ' + paperwidth;
1836                 result += ',' + paperheight;
1837         } else {
1838                 string const paper_option = paperSizeName(DVIPS);
1839                 if (!paper_option.empty() && (paper_option != "letter" ||
1840                     orientation != ORIENTATION_LANDSCAPE)) {
1841                         // dvips won't accept -t letter -t landscape.
1842                         // In all other cases, include the paper size
1843                         // explicitly.
1844                         result = lyxrc.print_paper_flag;
1845                         result += ' ' + paper_option;
1846                 }
1847         }
1848         if (orientation == ORIENTATION_LANDSCAPE &&
1849             papersize != PAPER_CUSTOM)
1850                 result += ' ' + lyxrc.print_landscape_flag;
1851         return result;
1852 }
1853
1854
1855 string BufferParams::babelCall(string const & lang_opts) const
1856 {
1857         string lang_pack = lyxrc.language_package;
1858         if (lang_pack != "\\usepackage{babel}")
1859                 return lang_pack;
1860         // suppress the babel call when there is no babel language defined
1861         // for the document language in the lib/languages file and if no
1862         // other languages are used (lang_opts is then empty)
1863         if (lang_opts.empty())
1864                 return string();
1865         // If Vietnamese is used, babel must directly be loaded with the
1866         // language options, see
1867         // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129417.html
1868         size_t viet = lang_opts.find("vietnam");
1869         // viet = string::npos when not found
1870         // If Japanese is used, babel must directly be loaded with the
1871         // language options, see
1872         // http://bugzilla.lyx.org/show_bug.cgi?id=4597#c4
1873         size_t japan = lang_opts.find("japanese");
1874         // japan = string::npos when not found
1875         if (!lyxrc.language_global_options || viet != string::npos || japan != string::npos)
1876                 return "\\usepackage[" + lang_opts + "]{babel}";
1877         return lang_pack;
1878 }
1879
1880
1881 void BufferParams::writeEncodingPreamble(odocstream & os,
1882                 LaTeXFeatures & features, TexRow & texrow) const
1883 {
1884         if (inputenc == "auto") {
1885                 string const doc_encoding =
1886                         language->encoding()->latexName();
1887                 Encoding::Package const package =
1888                         language->encoding()->package();
1889
1890                 // Create a list with all the input encodings used
1891                 // in the document
1892                 set<string> encodings =
1893                         features.getEncodingSet(doc_encoding);
1894
1895                 // If the "japanese" package (i.e. pLaTeX) is used,
1896                 // inputenc must be omitted.
1897                 // see http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg129680.html
1898                 if (package == Encoding::japanese)
1899                      features.require("japanese");
1900
1901                 if ((!encodings.empty() || package == Encoding::inputenc)
1902                     && !features.isRequired("japanese")) {
1903                         os << "\\usepackage[";
1904                         set<string>::const_iterator it = encodings.begin();
1905                         set<string>::const_iterator const end = encodings.end();
1906                         if (it != end) {
1907                                 os << from_ascii(*it);
1908                                 ++it;
1909                         }
1910                         for (; it != end; ++it)
1911                                 os << ',' << from_ascii(*it);
1912                         if (package == Encoding::inputenc) {
1913                                 if (!encodings.empty())
1914                                         os << ',';
1915                                 os << from_ascii(doc_encoding);
1916                         }
1917                         os << "]{inputenc}\n";
1918                         texrow.newline();
1919                 }
1920                 if (package == Encoding::CJK || features.mustProvide("CJK")) {
1921                         os << "\\usepackage{CJK}\n";
1922                         texrow.newline();
1923                 }
1924         } else if (inputenc != "default") {
1925                 switch (encoding().package()) {
1926                 case Encoding::none:
1927                 case Encoding::japanese:
1928                         break;
1929                 case Encoding::inputenc:
1930                         // do not load inputenc if japanese is used
1931                         if (features.isRequired("japanese"))
1932                                 break;
1933                         os << "\\usepackage[" << from_ascii(inputenc)
1934                            << "]{inputenc}\n";
1935                         texrow.newline();
1936                         break;
1937                 case Encoding::CJK:
1938                         os << "\\usepackage{CJK}\n";
1939                         texrow.newline();
1940                         break;
1941                 }
1942         }
1943
1944         // The encoding "armscii8" (for Armenian) is only available when
1945         // the package "armtex" is loaded.
1946         if (language->encoding()->latexName() == "armscii8"
1947             || inputenc == "armscii8") {
1948                 os << "\\usepackage{armtex}\n";
1949                 texrow.newline();
1950         }
1951 }
1952
1953
1954 string const BufferParams::loadFonts(string const & rm,
1955                                      string const & sf, string const & tt,
1956                                      bool const & sc, bool const & osf,
1957                                      int const & sfscale, int const & ttscale) const
1958 {
1959         /* The LaTeX font world is in a flux. In the PSNFSS font interface,
1960            several packages have been replaced by others, that might not
1961            be installed on every system. We have to take care for that
1962            (see psnfss.pdf). We try to support all psnfss fonts as well
1963            as the fonts that have become de facto standard in the LaTeX
1964            world (e.g. Latin Modern). We do not support obsolete fonts
1965            (like PSLatex). In general, it should be possible to mix any
1966            rm font with any sf or tt font, respectively. (JSpitzm)
1967            TODO:
1968                 -- separate math fonts.
1969         */
1970
1971         if (rm == "default" && sf == "default" && tt == "default")
1972                 //nothing to do
1973                 return string();
1974
1975         ostringstream os;
1976
1977         // ROMAN FONTS
1978         // Computer Modern (must be explicitely selectable -- there might be classes
1979         // that define a different default font!
1980         if (rm == "cmr") {
1981                 os << "\\renewcommand{\\rmdefault}{cmr}\n";
1982                 // osf for Computer Modern needs eco.sty
1983                 if (osf)
1984                         os << "\\usepackage{eco}\n";
1985         }
1986         // Latin Modern Roman
1987         else if (rm == "lmodern")
1988                 os << "\\usepackage{lmodern}\n";
1989         // AE
1990         else if (rm == "ae") {
1991                 // not needed when using OT1 font encoding.
1992                 if (lyxrc.fontenc != "default")
1993                         os << "\\usepackage{ae,aecompl}\n";
1994         }
1995         // Times
1996         else if (rm == "times") {
1997                 // try to load the best available package
1998                 if (LaTeXFeatures::isAvailable("mathptmx"))
1999                         os << "\\usepackage{mathptmx}\n";
2000                 else if (LaTeXFeatures::isAvailable("mathptm"))
2001                         os << "\\usepackage{mathptm}\n";
2002                 else
2003                         os << "\\usepackage{times}\n";
2004         }
2005         // Palatino
2006         else if (rm == "palatino") {
2007                 // try to load the best available package
2008                 if (LaTeXFeatures::isAvailable("mathpazo")) {
2009                         os << "\\usepackage";
2010                         if (osf || sc) {
2011                                 os << '[';
2012                                 if (!osf)
2013                                         os << "sc";
2014                                 else
2015                                         // "osf" includes "sc"!
2016                                         os << "osf";
2017                                 os << ']';
2018                         }
2019                         os << "{mathpazo}\n";
2020                 }
2021                 else if (LaTeXFeatures::isAvailable("mathpple"))
2022                         os << "\\usepackage{mathpple}\n";
2023                 else
2024                         os << "\\usepackage{palatino}\n";
2025         }
2026         // Utopia
2027         else if (rm == "utopia") {
2028                 // fourier supersedes utopia.sty, but does
2029                 // not work with OT1 encoding.
2030                 if (LaTeXFeatures::isAvailable("fourier")
2031                     && lyxrc.fontenc != "default") {
2032                         os << "\\usepackage";
2033                         if (osf || sc) {
2034                                 os << '[';
2035                                 if (sc)
2036                                         os << "expert";
2037                                 if (osf && sc)
2038                                         os << ',';
2039                                 if (osf)
2040                                         os << "oldstyle";
2041                                 os << ']';
2042                         }
2043                         os << "{fourier}\n";
2044                 }
2045                 else
2046                         os << "\\usepackage{utopia}\n";
2047         }
2048         // Bera (complete fontset)
2049         else if (rm == "bera" && sf == "default" && tt == "default")
2050                 os << "\\usepackage{bera}\n";
2051         // everything else
2052         else if (rm != "default")
2053                 os << "\\usepackage" << "{" << rm << "}\n";
2054
2055         // SANS SERIF
2056         // Helvetica, Bera Sans
2057         if (sf == "helvet" || sf == "berasans") {
2058                 if (sfscale != 100)
2059                         os << "\\usepackage[scaled=" << float(sfscale) / 100
2060                            << "]{" << sf << "}\n";
2061                 else
2062                         os << "\\usepackage{" << sf << "}\n";
2063         }
2064         // Avant Garde
2065         else if (sf == "avant")
2066                 os << "\\usepackage{" << sf << "}\n";
2067         // Computer Modern, Latin Modern, CM Bright
2068         else if (sf != "default")
2069                 os << "\\renewcommand{\\sfdefault}{" << sf << "}\n";
2070
2071         // monospaced/typewriter
2072         // Courier, LuxiMono
2073         if (tt == "luximono" || tt == "beramono") {
2074                 if (ttscale != 100)
2075                         os << "\\usepackage[scaled=" << float(ttscale) / 100
2076                            << "]{" << tt << "}\n";
2077                 else
2078                         os << "\\usepackage{" << tt << "}\n";
2079         }
2080         // Courier
2081         else if (tt == "courier" )
2082                 os << "\\usepackage{" << tt << "}\n";
2083         // Computer Modern, Latin Modern, CM Bright
2084         else if (tt != "default")
2085                 os << "\\renewcommand{\\ttdefault}{" << tt << "}\n";
2086
2087         return os.str();
2088 }
2089
2090
2091 Encoding const & BufferParams::encoding() const
2092 {
2093         if (inputenc == "auto" || inputenc == "default")
2094                 return *language->encoding();
2095         Encoding const * const enc = encodings.fromLaTeXName(inputenc);
2096         if (enc)
2097                 return *enc;
2098         LYXERR0("Unknown inputenc value `" << inputenc
2099                << "'. Using `auto' instead.");
2100         return *language->encoding();
2101 }
2102
2103
2104 CiteEngine BufferParams::citeEngine() const
2105 {
2106         // FIXME the class should provide the numerical/
2107         // authoryear choice
2108         if (documentClass().provides("natbib")
2109             && cite_engine_ != ENGINE_NATBIB_NUMERICAL)
2110                 return ENGINE_NATBIB_AUTHORYEAR;
2111         return cite_engine_;
2112 }
2113
2114
2115 void BufferParams::setCiteEngine(CiteEngine cite_engine)
2116 {
2117         cite_engine_ = cite_engine;
2118 }
2119
2120 } // namespace lyx