X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbufferparams.C;h=dff424a9af00d7cb4d0b5cae3fedd22f7e08c9f9;hb=024275f0690b41634e26dabe8758e3dc6cd31ee2;hp=4e5d89f43bd3d4aef0a4b363f0d5900cb4741853;hpb=0e9bd2e87dbf1f2791cead146f114b555d2ca86d;p=lyx.git diff --git a/src/bufferparams.C b/src/bufferparams.C index 4e5d89f43b..dff424a9af 100644 --- a/src/bufferparams.C +++ b/src/bufferparams.C @@ -1,106 +1,440 @@ -/* This file is part of - * ====================================================== +/** + * \file bufferparams.C + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. * - * LyX, The Document Processor + * \author Alfredo Braunstein + * \author Lars Gullik Bjønnes + * \author Jean-Marc Lasgouttes + * \author John Levon + * \author André Pönitz + * \author Martin Vermeer * - * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. - * - * ====================================================== */ + * Full author contact details are available in file CREDITS. + */ #include #include "bufferparams.h" -#include "tex-strings.h" -#include "encoding.h" -#include "layout.h" -#include "vspace.h" + +#include "author.h" +#include "BranchList.h" +#include "Bullet.h" #include "debug.h" -#include "lyxrc.h" +#include "encoding.h" +#include "gettext.h" #include "language.h" -#include "lyxtextclasslist.h" +#include "LaTeXFeatures.h" +#include "LColor.h" +#include "lyxfont.h" #include "lyxlex.h" -#include "Lsstream.h" -#include "author.h" -#include "gettext.h" +#include "lyxrc.h" +#include "lyxtextclasslist.h" +#include "outputparams.h" +#include "tex-strings.h" +#include "Spacing.h" +#include "texrow.h" +#include "vspace.h" + +#include "frontends/Alert.h" #include "support/lyxalgo.h" // for lyx::count -#include "support/lyxlib.h" -#include "support/lstrings.h" -#include "support/types.h" +#include "support/convert.h" +#include "support/translator.h" -#include "frontends/Alert.h" +#include -#include -#include +#include + + +namespace lyx { + +using support::bformat; +using support::rtrim; +using support::tokenPos; -using std::ostream; using std::endl; +using std::string; +using std::istringstream; +using std::ostream; +using std::ostringstream; using std::pair; -#ifdef WITH_WARNINGS -#warning Do we need this horrible thing? (JMarc) -#endif -bool use_babel; +namespace Alert = lyx::frontend::Alert; + + +// Local translators +namespace { + +// Paragraph separation +typedef Translator ParSepTranslator; + + +ParSepTranslator const init_parseptranslator() +{ + ParSepTranslator translator(string_paragraph_separation[0], BufferParams::PARSEP_INDENT); + translator.addPair(string_paragraph_separation[1], BufferParams::PARSEP_SKIP); + return translator; +} + + +ParSepTranslator const & parseptranslator() +{ + static ParSepTranslator translator = init_parseptranslator(); + return translator; +} + + +// Quotes language +typedef Translator QuotesLangTranslator; + + +QuotesLangTranslator const init_quoteslangtranslator() +{ + QuotesLangTranslator translator(string_quotes_language[0], InsetQuotes::EnglishQ); + translator.addPair(string_quotes_language[1], InsetQuotes::SwedishQ); + translator.addPair(string_quotes_language[2], InsetQuotes::GermanQ); + translator.addPair(string_quotes_language[3], InsetQuotes::PolishQ); + translator.addPair(string_quotes_language[4], InsetQuotes::FrenchQ); + translator.addPair(string_quotes_language[5], InsetQuotes::DanishQ); + return translator; +} + + +QuotesLangTranslator const & quoteslangtranslator() +{ + static QuotesLangTranslator translator = init_quoteslangtranslator(); + return translator; +} + + +// Paper size +typedef Translator PaperSizeTranslator; + + +PaperSizeTranslator const init_papersizetranslator() +{ + PaperSizeTranslator translator(string_papersize[0], PAPER_DEFAULT); + translator.addPair(string_papersize[1], PAPER_CUSTOM); + translator.addPair(string_papersize[2], PAPER_USLETTER); + translator.addPair(string_papersize[3], PAPER_USLEGAL); + translator.addPair(string_papersize[4], PAPER_USEXECUTIVE); + translator.addPair(string_papersize[5], PAPER_A3); + translator.addPair(string_papersize[6], PAPER_A4); + translator.addPair(string_papersize[7], PAPER_A5); + translator.addPair(string_papersize[8], PAPER_B3); + translator.addPair(string_papersize[9], PAPER_B4); + translator.addPair(string_papersize[10], PAPER_B5); + return translator; +} + + +PaperSizeTranslator const & papersizetranslator() +{ + static PaperSizeTranslator translator = init_papersizetranslator(); + return translator; +} + + +// Paper orientation +typedef Translator PaperOrientationTranslator; + + +PaperOrientationTranslator const init_paperorientationtranslator() +{ + PaperOrientationTranslator translator(string_orientation[0], ORIENTATION_PORTRAIT); + translator.addPair(string_orientation[1], ORIENTATION_LANDSCAPE); + return translator; +} + + +PaperOrientationTranslator const & paperorientationtranslator() +{ + static PaperOrientationTranslator translator = init_paperorientationtranslator(); + return translator; +} + + +// Page sides +typedef Translator SidesTranslator; + + +SidesTranslator const init_sidestranslator() +{ + SidesTranslator translator(1, LyXTextClass::OneSide); + translator.addPair(2, LyXTextClass::TwoSides); + return translator; +} + + +SidesTranslator const & sidestranslator() +{ + static SidesTranslator translator = init_sidestranslator(); + return translator; +} + + +// LaTeX packages +typedef Translator PackageTranslator; + + +PackageTranslator const init_packagetranslator() +{ + PackageTranslator translator(0, BufferParams::package_off); + translator.addPair(1, BufferParams::package_auto); + translator.addPair(2, BufferParams::package_on); + return translator; +} + + +PackageTranslator const & packagetranslator() +{ + static PackageTranslator translator = init_packagetranslator(); + return translator; +} + + +// Cite engine +typedef Translator CiteEngineTranslator; + + +CiteEngineTranslator const init_citeenginetranslator() +{ + CiteEngineTranslator translator("basic", biblio::ENGINE_BASIC); + translator.addPair("natbib_numerical", biblio::ENGINE_NATBIB_NUMERICAL); + translator.addPair("natbib_authoryear", biblio::ENGINE_NATBIB_AUTHORYEAR); + translator.addPair("jurabib", biblio::ENGINE_JURABIB); + return translator; +} + + +CiteEngineTranslator const & citeenginetranslator() +{ + static CiteEngineTranslator translator = init_citeenginetranslator(); + return translator; +} + + +// Spacing +typedef Translator SpaceTranslator; + + +SpaceTranslator const init_spacetranslator() +{ + SpaceTranslator translator("default", Spacing::Default); + translator.addPair("single", Spacing::Single); + translator.addPair("onehalf", Spacing::Onehalf); + translator.addPair("double", Spacing::Double); + translator.addPair("other", Spacing::Other); + return translator; +} + + +SpaceTranslator const & spacetranslator() +{ + static SpaceTranslator translator = init_spacetranslator(); + return translator; +} + +// ends annonym namespace +} + + +class BufferParams::Impl +{ +public: + Impl(); + + AuthorList authorlist; + BranchList branchlist; + boost::array temp_bullets; + boost::array user_defined_bullets; + Spacing spacing; + /** This is the amount of space used for paragraph_separation "skip", + * and for detached paragraphs in "indented" documents. + */ + VSpace defskip; +}; + + +BufferParams::Impl::Impl() + : defskip(VSpace::MEDSKIP) +{ + // set initial author + // FIXME UNICODE + authorlist.record(Author(from_utf8(lyxrc.user_name), from_utf8(lyxrc.user_email))); +} + + +BufferParams::Impl * +BufferParams::MemoryTraits::clone(BufferParams::Impl const * ptr) +{ + BOOST_ASSERT(ptr); + + return new BufferParams::Impl(*ptr); +} + + +void BufferParams::MemoryTraits::destroy(BufferParams::Impl * ptr) +{ + delete ptr; +} BufferParams::BufferParams() - // Initialize textclass to point to article. if `first' is - // true in the returned pair, then `second' is the textclass - // number; if it is false, second is 0. In both cases, second - // is what we want. - : textclass(textclasslist.NumberOfClass("article").second) + : // Initialize textclass to point to article. if `first' is + // true in the returned pair, then `second' is the textclass + // number; if it is false, second is 0. In both cases, second + // is what we want. + textclass(textclasslist.numberOfClass("article").second), + pimpl_(new Impl) { paragraph_separation = PARSEP_INDENT; - defskip = VSpace(VSpace::MEDSKIP); quotes_language = InsetQuotes::EnglishQ; - quotes_times = InsetQuotes::DoubleQ; fontsize = "default"; /* PaperLayout */ papersize = PAPER_DEFAULT; - papersize2 = VM_PAPER_DEFAULT; /* DEFAULT */ - paperpackage = PACKAGE_NONE; orientation = ORIENTATION_PORTRAIT; use_geometry = false; - use_amsmath = AMS_AUTO; - use_natbib = false; - use_numerical_citations = false; - tracking_changes = false; + use_amsmath = package_auto; + use_esint = package_auto; + cite_engine = biblio::ENGINE_BASIC; + use_bibtopic = false; + trackChanges = false; + outputChanges = false; secnumdepth = 3; tocdepth = 3; language = default_language; - fonts = "default"; + fontsRoman = "default"; + fontsSans = "default"; + fontsTypewriter = "default"; + fontsDefaultFamily = "default"; + fontsSC = false; + fontsOSF = false; + fontsSansScale = 100; + fontsTypewriterScale = 100; inputenc = "auto"; graphicsDriver = "default"; sides = LyXTextClass::OneSide; columns = 1; pagestyle = "default"; + compressed = false; for (int iter = 0; iter < 4; ++iter) { - user_defined_bullets[iter] = ITEMIZE_DEFAULTS[iter]; - temp_bullets[iter] = ITEMIZE_DEFAULTS[iter]; + user_defined_bullet(iter) = ITEMIZE_DEFAULTS[iter]; + temp_bullet(iter) = ITEMIZE_DEFAULTS[iter]; } } +BufferParams::~BufferParams() +{} + + +AuthorList & BufferParams::authors() +{ + return pimpl_->authorlist; +} + + +AuthorList const & BufferParams::authors() const +{ + return pimpl_->authorlist; +} + + +BranchList & BufferParams::branchlist() +{ + return pimpl_->branchlist; +} + + +BranchList const & BufferParams::branchlist() const +{ + return pimpl_->branchlist; +} + + +Bullet & BufferParams::temp_bullet(lyx::size_type const index) +{ + BOOST_ASSERT(index < 4); + return pimpl_->temp_bullets[index]; +} + + +Bullet const & BufferParams::temp_bullet(lyx::size_type const index) const +{ + BOOST_ASSERT(index < 4); + return pimpl_->temp_bullets[index]; +} + + +Bullet & BufferParams::user_defined_bullet(lyx::size_type const index) +{ + BOOST_ASSERT(index < 4); + return pimpl_->user_defined_bullets[index]; +} + + +Bullet const & BufferParams::user_defined_bullet(lyx::size_type const index) const +{ + BOOST_ASSERT(index < 4); + return pimpl_->user_defined_bullets[index]; +} + + +Spacing & BufferParams::spacing() +{ + return pimpl_->spacing; +} + + +Spacing const & BufferParams::spacing() const +{ + return pimpl_->spacing; +} + + +VSpace const & BufferParams::getDefSkip() const +{ + return pimpl_->defskip; +} + + +void BufferParams::setDefSkip(VSpace const & vs) +{ + pimpl_->defskip = vs; +} + + string const BufferParams::readToken(LyXLex & lex, string const & token) { if (token == "\\textclass") { - lex.eatLine(); + lex.next(); string const classname = lex.getString(); pair pp = - textclasslist.NumberOfClass(classname); + textclasslist.numberOfClass(classname); if (pp.first) { textclass = pp.second; } else { - textclass = 0; - return classname; + // if text class does not exist, try to load it from filepath + pp = textclasslist.addTextClass(classname, filepath); + if (pp.first) { + textclass = pp.second; + } else { + textclass = 0; + return classname; + } } + // FIXME: isTeXClassAvailable will try to load the layout file, but will + // fail because of the lack of path info. Warnings will be given although + // the layout file will be correctly loaded later. if (!getLyXTextClass().isTeXClassAvailable()) { - string msg = bformat(_("The document uses a missing " - "TeX class \"%1$s\".\n"), classname); + docstring const msg = + bformat(_("The document uses a missing " + "TeX class \"%1$s\".\n"), from_utf8(classname)); Alert::warning(_("Document class not available"), - msg + _("LyX will not be able to produce output.")); + msg + _("LyX will not be able to produce output.")); } } else if (token == "\\begin_preamble") { readPreamble(lex); @@ -110,226 +444,145 @@ string const BufferParams::readToken(LyXLex & lex, string const & token) } else if (token == "\\language") { readLanguage(lex); } else if (token == "\\inputencoding") { - lex.eatLine(); - inputenc = lex.getString(); + lex >> inputenc; } else if (token == "\\graphics") { readGraphicsDriver(lex); - } else if (token == "\\fontscheme") { - lex.eatLine(); - fonts = lex.getString(); + } else if (token == "\\font_roman") { + lex >> fontsRoman; + } else if (token == "\\font_sans") { + lex >> fontsSans; + } else if (token == "\\font_typewriter") { + lex >> fontsTypewriter; + } else if (token == "\\font_default_family") { + lex >> fontsDefaultFamily; + } else if (token == "\\font_sc") { + lex >> fontsSC; + } else if (token == "\\font_osf") { + lex >> fontsOSF; + } else if (token == "\\font_sf_scale") { + lex >> fontsSansScale; + } else if (token == "\\font_tt_scale") { + lex >> fontsTypewriterScale; } else if (token == "\\paragraph_separation") { - int tmpret = lex.findToken(string_paragraph_separation); - if (tmpret == -1) - ++tmpret; - paragraph_separation = - static_cast(tmpret); + string parsep; + lex >> parsep; + paragraph_separation = parseptranslator().find(parsep); } else if (token == "\\defskip") { - lex.nextToken(); - defskip = VSpace(lex.getString()); + lex.next(); + pimpl_->defskip = VSpace(lex.getString()); } else if (token == "\\quotes_language") { - // FIXME: should be params.readQuotes() - int tmpret = lex.findToken(string_quotes_language); - if (tmpret == -1) - ++tmpret; - InsetQuotes::quote_language tmpl = - InsetQuotes::EnglishQ; - switch (tmpret) { - case 0: - tmpl = InsetQuotes::EnglishQ; - break; - case 1: - tmpl = InsetQuotes::SwedishQ; - break; - case 2: - tmpl = InsetQuotes::GermanQ; - break; - case 3: - tmpl = InsetQuotes::PolishQ; - break; - case 4: - tmpl = InsetQuotes::FrenchQ; - break; - case 5: - tmpl = InsetQuotes::DanishQ; - break; - } - quotes_language = tmpl; - } else if (token == "\\quotes_times") { - // FIXME: should be params.readQuotes() - lex.nextToken(); - switch (lex.getInteger()) { - case 1: - quotes_times = InsetQuotes::SingleQ; - break; - case 2: - quotes_times = InsetQuotes::DoubleQ; - break; - } + string quotes_lang; + lex >> quotes_lang; + quotes_language = quoteslangtranslator().find(quotes_lang); } else if (token == "\\papersize") { - int tmpret = lex.findToken(string_papersize); - if (tmpret == -1) - ++tmpret; - else - papersize2 = tmpret; - } else if (token == "\\paperpackage") { - int tmpret = lex.findToken(string_paperpackages); - if (tmpret == -1) { - ++tmpret; - paperpackage = BufferParams::PACKAGE_NONE; - } else - paperpackage = tmpret; + string ppsize; + lex >> ppsize; + papersize = papersizetranslator().find(ppsize); } else if (token == "\\use_geometry") { - lex.nextToken(); - use_geometry = lex.getInteger(); + lex >> use_geometry; } else if (token == "\\use_amsmath") { - lex.nextToken(); - use_amsmath = static_cast( - lex.getInteger()); - } else if (token == "\\use_natbib") { - lex.nextToken(); - use_natbib = lex.getInteger(); - } else if (token == "\\use_numerical_citations") { - lex.nextToken(); - use_numerical_citations = lex.getInteger(); + int use_ams; + lex >> use_ams; + use_amsmath = packagetranslator().find(use_ams); + } else if (token == "\\use_esint") { + int useesint; + lex >> useesint; + use_esint = packagetranslator().find(useesint); + } else if (token == "\\cite_engine") { + string engine; + lex >> engine; + cite_engine = citeenginetranslator().find(engine); + } else if (token == "\\use_bibtopic") { + lex >> use_bibtopic; } else if (token == "\\tracking_changes") { - lex.nextToken(); - tracking_changes = lex.getInteger(); + lex >> trackChanges; + } else if (token == "\\output_changes") { + lex >> outputChanges; + } else if (token == "\\branch") { + lex.next(); + docstring branch = lex.getDocString(); + branchlist().add(branch); + while (true) { + lex.next(); + string const tok = lex.getString(); + if (tok == "\\end_branch") + break; + Branch * branch_ptr = branchlist().find(branch); + if (tok == "\\selected") { + lex.next(); + if (branch_ptr) + branch_ptr->setSelected(lex.getInteger()); + } + // not yet operational + if (tok == "\\color") { + lex.eatLine(); + string color = lex.getString(); + if (branch_ptr) + branch_ptr->setColor(color); + // Update also the LColor table: + if (color == "none") + color = lcolor.getX11Name(LColor::background); + // FIXME UNICODE + lcolor.setColor(to_utf8(branch), color); + + } + } } else if (token == "\\author") { - lex.nextToken(); - istringstream ss(STRCONV(lex.getString())); + lex.eatLine(); + istringstream ss(lex.getString()); Author a; ss >> a; - author_map.push_back(authorlist.record(a)); + author_map.push_back(pimpl_->authorlist.record(a)); } else if (token == "\\paperorientation") { - int tmpret = lex.findToken(string_orientation); - if (tmpret == -1) - ++tmpret; - orientation = - static_cast(tmpret); + string orient; + lex >> orient; + orientation = paperorientationtranslator().find(orient); } else if (token == "\\paperwidth") { - lex.next(); - paperwidth = lex.getString(); + lex >> paperwidth; } else if (token == "\\paperheight") { - lex.next(); - paperheight = lex.getString(); + lex >> paperheight; } else if (token == "\\leftmargin") { - lex.next(); - leftmargin = lex.getString(); + lex >> leftmargin; } else if (token == "\\topmargin") { - lex.next(); - topmargin = lex.getString(); + lex >> topmargin; } else if (token == "\\rightmargin") { - lex.next(); - rightmargin = lex.getString(); + lex >> rightmargin; } else if (token == "\\bottommargin") { - lex.next(); - bottommargin = lex.getString(); + lex >> bottommargin; } else if (token == "\\headheight") { - lex.next(); - headheight = lex.getString(); + lex >> headheight; } else if (token == "\\headsep") { - lex.next(); - headsep = lex.getString(); + lex >> headsep; } else if (token == "\\footskip") { - lex.next(); - footskip = lex.getString(); + lex >> footskip; } else if (token == "\\paperfontsize") { - lex.nextToken(); - fontsize = rtrim(lex.getString()); + lex >> fontsize; } else if (token == "\\papercolumns") { - lex.nextToken(); - columns = lex.getInteger(); + lex >> columns; } else if (token == "\\papersides") { - lex.nextToken(); - switch (lex.getInteger()) { - default: - case 1: sides = LyXTextClass::OneSide; break; - case 2: sides = LyXTextClass::TwoSides; break; - } + int psides; + lex >> psides; + sides = sidestranslator().find(psides); } else if (token == "\\paperpagestyle") { - lex.nextToken(); - pagestyle = rtrim(lex.getString()); + lex >> pagestyle; } else if (token == "\\bullet") { - // FIXME: should be params.readBullets() - lex.nextToken(); - int const index = lex.getInteger(); - lex.nextToken(); - int temp_int = lex.getInteger(); - user_defined_bullets[index].setFont(temp_int); - temp_bullets[index].setFont(temp_int); - lex.nextToken(); - temp_int = lex.getInteger(); - user_defined_bullets[index].setCharacter(temp_int); - temp_bullets[index].setCharacter(temp_int); - lex.nextToken(); - temp_int = lex.getInteger(); - user_defined_bullets[index].setSize(temp_int); - temp_bullets[index].setSize(temp_int); - lex.nextToken(); - string const temp_str = lex.getString(); - if (temp_str != "\\end_bullet") { - // this element isn't really necessary for - // parsing but is easier for humans - // to understand bullets. Put it back and - // set a debug message? - lex.printError("\\end_bullet expected, got" + temp_str); - //how can I put it back? - } + readBullets(lex); } else if (token == "\\bulletLaTeX") { - // The bullet class should be able to read this. - lex.nextToken(); - int const index = lex.getInteger(); - lex.next(); - string temp_str = lex.getString(); - string sum_str; - while (temp_str != "\\end_bullet") { - // this loop structure is needed when user - // enters an empty string since the first - // thing returned will be the \\end_bullet - // OR - // if the LaTeX entry has spaces. Each element - // therefore needs to be read in turn - sum_str += temp_str; - lex.next(); - temp_str = lex.getString(); - } - - user_defined_bullets[index].setText(sum_str); - temp_bullets[index].setText(sum_str); + readBulletsLaTeX(lex); } else if (token == "\\secnumdepth") { - lex.nextToken(); - secnumdepth = lex.getInteger(); + lex >> secnumdepth; } else if (token == "\\tocdepth") { - lex.nextToken(); - tocdepth = lex.getInteger(); + lex >> tocdepth; } else if (token == "\\spacing") { - lex.next(); - string const tmp = rtrim(lex.getString()); - Spacing::Space tmp_space = Spacing::Default; - float tmp_val = 0.0; - if (tmp == "single") { - tmp_space = Spacing::Single; - } else if (tmp == "onehalf") { - tmp_space = Spacing::Onehalf; - } else if (tmp == "double") { - tmp_space = Spacing::Double; - } else if (tmp == "other") { - lex.next(); - tmp_space = Spacing::Other; - tmp_val = lex.getFloat(); - } else { - lex.printError("Unknown spacing token: '$$Token'"); + string nspacing; + lex >> nspacing; + string tmp_val; + if (nspacing == "other") { + lex >> tmp_val; } -#if 0 // FIXME: Handled in lyx2lyx ? - // Small hack so that files written with klyx will be - // parsed correctly. - if (first_par) - par->params().spacing(Spacing(tmp_space, tmp_val)); -#endif - spacing.set(tmp_space, tmp_val); + spacing().set(spacetranslator().find(nspacing), tmp_val); } else if (token == "\\float_placement") { - lex.nextToken(); - float_placement = lex.getString(); + lex >> float_placement; } else { return token; } @@ -355,16 +608,23 @@ void BufferParams::writeFile(ostream & os) const << "\n\\end_preamble\n"; } - /* the options */ + // the options if (!options.empty()) { os << "\\options " << options << '\n'; } - /* then the text parameters */ + // then the text parameters if (language != ignore_language) os << "\\language " << language->lang() << '\n'; os << "\\inputencoding " << inputenc - << "\n\\fontscheme " << fonts + << "\n\\font_roman " << fontsRoman + << "\n\\font_sans " << fontsSans + << "\n\\font_typewriter " << fontsTypewriter + << "\n\\font_default_family " << fontsDefaultFamily + << "\n\\font_sc " << convert(fontsSC) + << "\n\\font_osf " << convert(fontsOSF) + << "\n\\font_sf_scale " << fontsSansScale + << "\n\\font_tt_scale " << fontsTypewriterScale << "\n\\graphics " << graphicsDriver << '\n'; if (!float_placement.empty()) { @@ -372,16 +632,27 @@ void BufferParams::writeFile(ostream & os) const } os << "\\paperfontsize " << fontsize << '\n'; - spacing.writeFile(os); + spacing().writeFile(os); - os << "\\papersize " << string_papersize[papersize2] - << "\n\\paperpackage " << string_paperpackages[paperpackage] - << "\n\\use_geometry " << use_geometry + os << "\\papersize " << string_papersize[papersize] + << "\n\\use_geometry " << convert(use_geometry) << "\n\\use_amsmath " << use_amsmath - << "\n\\use_natbib " << use_natbib - << "\n\\use_numerical_citations " << use_numerical_citations + << "\n\\use_esint " << use_esint + << "\n\\cite_engine " << citeenginetranslator().find(cite_engine) + << "\n\\use_bibtopic " << convert(use_bibtopic) << "\n\\paperorientation " << string_orientation[orientation] << '\n'; + + BranchList::const_iterator it = branchlist().begin(); + BranchList::const_iterator end = branchlist().end(); + for (; it != end; ++it) { + os << "\\branch " << to_utf8(it->getBranch()) + << "\n\\selected " << it->getSelected() + << "\n\\color " << lyx::X11hexname(it->getColor()) + << "\n\\end_branch" + << "\n"; + } + if (!paperwidth.empty()) os << "\\paperwidth " << VSpace(paperwidth).asLyXCommand() << '\n'; @@ -413,53 +684,41 @@ void BufferParams::writeFile(ostream & os) const << "\n\\tocdepth " << tocdepth << "\n\\paragraph_separation " << string_paragraph_separation[paragraph_separation] - << "\n\\defskip " << defskip.asLyXCommand() + << "\n\\defskip " << getDefSkip().asLyXCommand() << "\n\\quotes_language " - << string_quotes_language[quotes_language] << '\n'; - switch (quotes_times) { - // An output operator for insetquotes would be nice - case InsetQuotes::SingleQ: - os << "\\quotes_times 1\n"; break; - case InsetQuotes::DoubleQ: - os << "\\quotes_times 2\n"; break; - } - os << "\\papercolumns " << columns + << string_quotes_language[quotes_language] + << "\n\\papercolumns " << columns << "\n\\papersides " << sides << "\n\\paperpagestyle " << pagestyle << '\n'; for (int i = 0; i < 4; ++i) { - if (user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) { - if (user_defined_bullets[i].getFont() != -1) { - os << "\\bullet " << i - << "\n\t" - << user_defined_bullets[i].getFont() - << "\n\t" - << user_defined_bullets[i].getCharacter() - << "\n\t" - << user_defined_bullets[i].getSize() - << "\n\\end_bullet\n"; + if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) { + if (user_defined_bullet(i).getFont() != -1) { + os << "\\bullet " << i << " " + << user_defined_bullet(i).getFont() << " " + << user_defined_bullet(i).getCharacter() << " " + << user_defined_bullet(i).getSize() << "\n"; } else { - os << "\\bulletLaTeX " << i - << "\n\t\"" - << user_defined_bullets[i].getText() - << "\"\n\\end_bullet\n"; + // FIXME UNICODE + os << "\\bulletLaTeX " << i << " \"" + << lyx::to_ascii(user_defined_bullet(i).getText()) + << "\"\n"; } } } - os << "\\tracking_changes " << tracking_changes << "\n"; + os << "\\tracking_changes " << convert(trackChanges) << "\n"; + os << "\\output_changes " << convert(outputChanges) << "\n"; - if (tracking_changes) { - AuthorList::Authors::const_iterator it = authorlist.begin(); - AuthorList::Authors::const_iterator end = authorlist.end(); - for (; it != end; ++it) { - os << "\\author " << it->second << "\n"; - } + AuthorList::Authors::const_iterator a_it = pimpl_->authorlist.begin(); + AuthorList::Authors::const_iterator a_end = pimpl_->authorlist.end(); + for (; a_it != a_end; ++a_it) { + os << "\\author " << a_it->second << "\n"; } } -void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, +bool BufferParams::writeLaTeX(odocstream & os, LaTeXFeatures & features, TexRow & texrow) const { os << "\\documentclass"; @@ -474,28 +733,38 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, clsoptions << fontsize << "pt,"; } + // custom, A3, B3 and B4 paper sizes need geometry + bool nonstandard_papersize = papersize == PAPER_B3 + || papersize == PAPER_B4 + || papersize == PAPER_A3 + || papersize == PAPER_CUSTOM; - if (!use_geometry && - (paperpackage == PACKAGE_NONE)) { + if (!use_geometry) { switch (papersize) { - case PAPER_A4PAPER: + case PAPER_A4: clsoptions << "a4paper,"; break; case PAPER_USLETTER: clsoptions << "letterpaper,"; break; - case PAPER_A5PAPER: + case PAPER_A5: clsoptions << "a5paper,"; break; - case PAPER_B5PAPER: + case PAPER_B5: clsoptions << "b5paper,"; break; - case PAPER_EXECUTIVEPAPER: + case PAPER_USEXECUTIVE: clsoptions << "executivepaper,"; break; - case PAPER_LEGALPAPER: + case PAPER_USLEGAL: clsoptions << "legalpaper,"; break; + case PAPER_DEFAULT: + case PAPER_A3: + case PAPER_B3: + case PAPER_B4: + case PAPER_CUSTOM: + break; } } @@ -524,17 +793,14 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, clsoptions << "landscape,"; // language should be a parameter to \documentclass - use_babel = false; - ostringstream language_options; if (language->babel() == "hebrew" && default_language->babel() != "hebrew") // This seems necessary features.useLanguage(default_language); - if (lyxrc.language_use_babel || - language->lang() != lyxrc.default_language || - features.hasLanguages()) { - use_babel = true; + ostringstream language_options; + bool const use_babel = features.useBabel(); + if (use_babel) { language_options << features.getLanguages(); language_options << language->babel(); if (lyxrc.language_global_options) @@ -546,154 +812,159 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, clsoptions << options << ','; } - string strOptions(STRCONV(clsoptions.str())); + string strOptions(clsoptions.str()); if (!strOptions.empty()) { strOptions = rtrim(strOptions, ","); - os << '[' << strOptions << ']'; + // FIXME UNICODE + os << '[' << from_utf8(strOptions) << ']'; } - os << '{' << tclass.latexname() << "}\n"; + os << '{' << from_ascii(tclass.latexname()) << "}\n"; texrow.newline(); // end of \documentclass defs // font selection must be done before loading fontenc.sty - // The ae package is not needed when using OT1 font encoding. - if (fonts != "default" && - (fonts != "ae" || lyxrc.fontenc != "default")) { - os << "\\usepackage{" << fonts << "}\n"; + string const fonts = + loadFonts(features, fontsRoman, fontsSans, + fontsTypewriter, fontsSC, fontsOSF, + fontsSansScale, fontsTypewriterScale); + if (!fonts.empty()) { + os << from_ascii(fonts); texrow.newline(); - if (fonts == "ae") { - os << "\\usepackage{aecompl}\n"; - texrow.newline(); - } } + if (fontsDefaultFamily != "default") + os << "\\renewcommand{\\familydefault}{\\" + << from_ascii(fontsDefaultFamily) << "}\n"; // this one is not per buffer if (lyxrc.fontenc != "default") { - os << "\\usepackage[" << lyxrc.fontenc + os << "\\usepackage[" << from_ascii(lyxrc.fontenc) << "]{fontenc}\n"; texrow.newline(); } if (inputenc == "auto") { string const doc_encoding = - language->encoding()->LatexName(); + language->encoding()->latexName(); // Create a list with all the input encodings used // in the document std::set encodings = features.getEncodingSet(doc_encoding); - os << "\\usepackage["; - std::copy(encodings.begin(), encodings.end(), - std::ostream_iterator(os, ",")); - os << doc_encoding << "]{inputenc}\n"; - texrow.newline(); - } else if (inputenc != "default") { - os << "\\usepackage[" << inputenc + // thailatex does not use the inputenc package, but sets up + // babel directly for tis620-0 encoding, therefore we must + // not request inputenc for tis620-0 encoding + if (!encodings.empty() || doc_encoding != "tis620-0") { + os << "\\usepackage["; + std::set::const_iterator it = encodings.begin(); + std::set::const_iterator const end = encodings.end(); + if (it != end) { + os << from_ascii(*it); + ++it; + } + for (; it != end; ++it) + os << ',' << from_ascii(*it); + if (doc_encoding != "tis620-0") { + if (!encodings.empty()) + os << ','; + os << from_ascii(doc_encoding); + } + os << "]{inputenc}\n"; + texrow.newline(); + } + } else if (inputenc != "default" && inputenc != "tis620-0") { + os << "\\usepackage[" << from_ascii(inputenc) << "]{inputenc}\n"; texrow.newline(); } - // At the very beginning the text parameters. - if (paperpackage != PACKAGE_NONE) { - switch (paperpackage) { - case PACKAGE_A4: - os << "\\usepackage{a4}\n"; - texrow.newline(); - break; - case PACKAGE_A4WIDE: - os << "\\usepackage{a4wide}\n"; - texrow.newline(); - break; - case PACKAGE_WIDEMARGINSA4: - os << "\\usepackage[widemargins]{a4}\n"; - texrow.newline(); - break; - } - } - if (use_geometry) { + if (use_geometry || nonstandard_papersize) { os << "\\usepackage{geometry}\n"; texrow.newline(); os << "\\geometry{verbose"; if (orientation == ORIENTATION_LANDSCAPE) os << ",landscape"; - switch (papersize2) { - case VM_PAPER_CUSTOM: + switch (papersize) { + case PAPER_CUSTOM: if (!paperwidth.empty()) os << ",paperwidth=" - << paperwidth; + << from_ascii(paperwidth); if (!paperheight.empty()) os << ",paperheight=" - << paperheight; + << from_ascii(paperheight); break; - case VM_PAPER_USLETTER: + case PAPER_USLETTER: os << ",letterpaper"; break; - case VM_PAPER_USLEGAL: + case PAPER_USLEGAL: os << ",legalpaper"; break; - case VM_PAPER_USEXECUTIVE: + case PAPER_USEXECUTIVE: os << ",executivepaper"; break; - case VM_PAPER_A3: + case PAPER_A3: os << ",a3paper"; break; - case VM_PAPER_A4: + case PAPER_A4: os << ",a4paper"; break; - case VM_PAPER_A5: + case PAPER_A5: os << ",a5paper"; break; - case VM_PAPER_B3: + case PAPER_B3: os << ",b3paper"; break; - case VM_PAPER_B4: + case PAPER_B4: os << ",b4paper"; break; - case VM_PAPER_B5: + case PAPER_B5: os << ",b5paper"; break; default: - // default papersize ie VM_PAPER_DEFAULT + // default papersize ie PAPER_DEFAULT switch (lyxrc.default_papersize) { case PAPER_DEFAULT: // keep compiler happy case PAPER_USLETTER: os << ",letterpaper"; break; - case PAPER_LEGALPAPER: + case PAPER_USLEGAL: os << ",legalpaper"; break; - case PAPER_EXECUTIVEPAPER: + case PAPER_USEXECUTIVE: os << ",executivepaper"; break; - case PAPER_A3PAPER: + case PAPER_A3: os << ",a3paper"; break; - case PAPER_A4PAPER: + case PAPER_A4: os << ",a4paper"; break; - case PAPER_A5PAPER: + case PAPER_A5: os << ",a5paper"; break; - case PAPER_B5PAPER: + case PAPER_B5: os << ",b5paper"; break; + case PAPER_B3: + case PAPER_B4: + case PAPER_CUSTOM: + break; } } if (!topmargin.empty()) - os << ",tmargin=" << topmargin; + os << ",tmargin=" << from_ascii(topmargin); if (!bottommargin.empty()) - os << ",bmargin=" << bottommargin; + os << ",bmargin=" << from_ascii(bottommargin); if (!leftmargin.empty()) - os << ",lmargin=" << leftmargin; + os << ",lmargin=" << from_ascii(leftmargin); if (!rightmargin.empty()) - os << ",rmargin=" << rightmargin; + os << ",rmargin=" << from_ascii(rightmargin); if (!headheight.empty()) - os << ",headheight=" << headheight; + os << ",headheight=" << from_ascii(headheight); if (!headsep.empty()) - os << ",headsep=" << headsep; + os << ",headsep=" << from_ascii(headsep); if (!footskip.empty()) - os << ",footskip=" << footskip; + os << ",footskip=" << from_ascii(footskip); os << "}\n"; texrow.newline(); } @@ -704,59 +975,70 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, os << "\\usepackage{fancyhdr}\n"; texrow.newline(); } - os << "\\pagestyle{" << pagestyle << "}\n"; + os << "\\pagestyle{" << from_ascii(pagestyle) << "}\n"; texrow.newline(); } - if (secnumdepth != tclass.secnumdepth()) { - os << "\\setcounter{secnumdepth}{" - << secnumdepth - << "}\n"; - texrow.newline(); - } - if (tocdepth != tclass.tocdepth()) { - os << "\\setcounter{tocdepth}{" - << tocdepth - << "}\n"; - texrow.newline(); + // Only if class has a ToC hierarchy + if (tclass.hasTocLevels()) { + if (secnumdepth != tclass.secnumdepth()) { + os << "\\setcounter{secnumdepth}{" + << secnumdepth + << "}\n"; + texrow.newline(); + } + if (tocdepth != tclass.tocdepth()) { + os << "\\setcounter{tocdepth}{" + << tocdepth + << "}\n"; + texrow.newline(); + } } if (paragraph_separation) { - switch (defskip.kind()) { + switch (getDefSkip().kind()) { case VSpace::SMALLSKIP: - os << "\\setlength\\parskip{\\smallskipamount}\n"; + os << "\\setlength{\\parskip}{\\smallskipamount}\n"; break; case VSpace::MEDSKIP: - os << "\\setlength\\parskip{\\medskipamount}\n"; + os << "\\setlength{\\parskip}{\\medskipamount}\n"; break; case VSpace::BIGSKIP: - os << "\\setlength\\parskip{\\bigskipamount}\n"; + os << "\\setlength{\\parskip}{\\bigskipamount}\n"; break; case VSpace::LENGTH: - os << "\\setlength\\parskip{" - << defskip.length().asLatexString() + os << "\\setlength{\\parskip}{" + << from_utf8(getDefSkip().length().asLatexString()) << "}\n"; break; default: // should never happen // Then delete it. - os << "\\setlength\\parskip{\\medskipamount}\n"; + os << "\\setlength{\\parskip}{\\medskipamount}\n"; break; } texrow.newline(); - os << "\\setlength\\parindent{0pt}\n"; + os << "\\setlength{\\parindent}{0pt}\n"; + texrow.newline(); + } + + // If we use jurabib, we have to call babel here. + if (use_babel && features.isRequired("jurabib")) { + os << from_ascii(babelCall(language_options.str())) + << '\n' + << from_ascii(features.getBabelOptions()); texrow.newline(); } // Now insert the LyX specific LaTeX commands... // The optional packages; - string lyxpreamble(features.getPackages()); + docstring lyxpreamble(from_ascii(features.getPackages())); // this might be useful... lyxpreamble += "\n\\makeatletter\n"; // Some macros LyX will need - string tmppreamble(features.getMacros()); + docstring tmppreamble(from_ascii(features.getMacros())); if (!tmppreamble.empty()) { lyxpreamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " @@ -774,9 +1056,10 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, /* the user-defined preamble */ if (!preamble.empty()) { + // FIXME UNICODE lyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " "User specified LaTeX commands.\n" - + preamble + '\n'; + + from_utf8(preamble) + '\n'; } // Itemize bullet settings need to be last in case the user @@ -785,12 +1068,12 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, // Actually it has to be done much later than that // since some packages like frenchb make modifications // at \begin{document} time -- JMarc - string bullets_def; + docstring bullets_def; for (int i = 0; i < 4; ++i) { - if (user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) { + if (user_defined_bullet(i) != ITEMIZE_DEFAULTS[i]) { if (bullets_def.empty()) - bullets_def="\\AtBeginDocument{\n"; - bullets_def += " \\renewcommand{\\labelitemi"; + bullets_def += "\\AtBeginDocument{\n"; + bullets_def += " \\def\\labelitemi"; switch (i) { // `i' is one less than the item to modify case 0: @@ -805,8 +1088,8 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, bullets_def += 'v'; break; } - bullets_def += "}{" + - user_defined_bullets[i].getText() + bullets_def += '{' + + user_defined_bullet(i).getText() + "}\n"; } } @@ -816,27 +1099,23 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, // We try to load babel late, in case it interferes // with other packages. - if (use_babel) { - string tmp = lyxrc.language_package; - if (!lyxrc.language_global_options - && tmp == "\\usepackage{babel}") - tmp = string("\\usepackage[") + - STRCONV(language_options.str()) + - "]{babel}"; - lyxpreamble += tmp + "\n"; - lyxpreamble += features.getBabelOptions(); + // Jurabib has to be called after babel, though. + if (use_babel && !features.isRequired("jurabib")) { + // FIXME UNICODE + lyxpreamble += from_utf8(babelCall(language_options.str())) + '\n'; + lyxpreamble += from_utf8(features.getBabelOptions()); } lyxpreamble += "\\makeatother\n"; // dvipost settings come after everything else - if (tracking_changes) { + if (features.isAvailable("dvipost") && outputChanges) { lyxpreamble += "\\dvipostlayout\n" "\\dvipost{osstart color push Red}\n" "\\dvipost{osend color pop}\n" "\\dvipost{cbstart color push Blue}\n" - "\\dvipost{cbend color pop} \n"; + "\\dvipost{cbend color pop}\n"; } int const nlines = @@ -846,32 +1125,7 @@ void BufferParams::writeLaTeX(ostream & os, LaTeXFeatures & features, } os << lyxpreamble; -} - -void BufferParams::setPaperStuff() -{ - papersize = PAPER_DEFAULT; - char const c1 = paperpackage; - if (c1 == PACKAGE_NONE) { - char const c2 = papersize2; - if (c2 == VM_PAPER_USLETTER) - papersize = PAPER_USLETTER; - else if (c2 == VM_PAPER_USLEGAL) - papersize = PAPER_LEGALPAPER; - else if (c2 == VM_PAPER_USEXECUTIVE) - papersize = PAPER_EXECUTIVEPAPER; - else if (c2 == VM_PAPER_A3) - papersize = PAPER_A3PAPER; - else if (c2 == VM_PAPER_A4) - papersize = PAPER_A4PAPER; - else if (c2 == VM_PAPER_A5) - papersize = PAPER_A5PAPER; - else if ((c2 == VM_PAPER_B3) || (c2 == VM_PAPER_B4) || - (c2 == VM_PAPER_B5)) - papersize = PAPER_B5PAPER; - } else if ((c1 == PACKAGE_A4) || (c1 == PACKAGE_A4WIDE) || - (c1 == PACKAGE_WIDEMARGINSA4)) - papersize = PAPER_A4PAPER; + return use_babel; } @@ -883,8 +1137,11 @@ void BufferParams::useClassDefaults() columns = tclass.columns(); pagestyle = tclass.pagestyle(); options = tclass.options(); - secnumdepth = tclass.secnumdepth(); - tocdepth = tclass.tocdepth(); + // Only if class has a ToC hierarchy + if (tclass.hasTocLevels()) { + secnumdepth = tclass.secnumdepth(); + tocdepth = tclass.tocdepth(); + } } @@ -907,6 +1164,20 @@ LyXTextClass const & BufferParams::getLyXTextClass() const } +LyXFont const BufferParams::getFont() const +{ + LyXFont f = getLyXTextClass().defaultfont(); + f.setLanguage(language); + if (fontsDefaultFamily == "rmdefault") + f.setFamily(LyXFont::ROMAN_FAMILY); + else if (fontsDefaultFamily == "sfdefault") + f.setFamily(LyXFont::SANS_FAMILY); + else if (fontsDefaultFamily == "ttdefault") + f.setFamily(LyXFont::TYPEWRITER_FAMILY); + return f; +} + + void BufferParams::readPreamble(LyXLex & lex) { if (lex.getString() != "\\begin_preamble") @@ -948,7 +1219,7 @@ void BufferParams::readGraphicsDriver(LyXLex & lex) if (test == tmptok) { graphicsDriver = tmptok; break; - } else if (test == "last_item") { + } else if (test == "") { lex.printError( "Warning: graphics driver `$$Token' not recognized!\n" " Setting graphics driver to `default'.\n"); @@ -957,3 +1228,253 @@ void BufferParams::readGraphicsDriver(LyXLex & lex) } } } + + +void BufferParams::readBullets(LyXLex & lex) +{ + if (!lex.next()) return; + + int const index = lex.getInteger(); + lex.next(); + int temp_int = lex.getInteger(); + user_defined_bullet(index).setFont(temp_int); + temp_bullet(index).setFont(temp_int); + lex >> temp_int; + user_defined_bullet(index).setCharacter(temp_int); + temp_bullet(index).setCharacter(temp_int); + lex >> temp_int; + user_defined_bullet(index).setSize(temp_int); + temp_bullet(index).setSize(temp_int); +} + + +void BufferParams::readBulletsLaTeX(LyXLex & lex) +{ + // The bullet class should be able to read this. + if (!lex.next()) return; + int const index = lex.getInteger(); + lex.next(true); + docstring const temp_str = lex.getDocString(); + + user_defined_bullet(index).setText(temp_str); + temp_bullet(index).setText(temp_str); +} + + +string const BufferParams::paperSizeName() const +{ + char real_papersize = papersize; + if (real_papersize == PAPER_DEFAULT) + real_papersize = lyxrc.default_papersize; + + switch (real_papersize) { + case PAPER_A3: + return "a3"; + case PAPER_A4: + return "a4"; + case PAPER_A5: + return "a5"; + case PAPER_B5: + return "b5"; + case PAPER_USEXECUTIVE: + return "foolscap"; + case PAPER_USLEGAL: + return "legal"; + case PAPER_USLETTER: + default: + return "letter"; + } +} + + +string const BufferParams::dvips_options() const +{ + string result; + + if (use_geometry + && papersize == PAPER_CUSTOM + && !lyxrc.print_paper_dimension_flag.empty() + && !paperwidth.empty() + && !paperheight.empty()) { + // using a custom papersize + result = lyxrc.print_paper_dimension_flag; + result += ' ' + paperwidth; + result += ',' + paperheight; + } else { + string const paper_option = paperSizeName(); + if (paper_option != "letter" || + orientation != ORIENTATION_LANDSCAPE) { + // dvips won't accept -t letter -t landscape. + // In all other cases, include the paper size + // explicitly. + result = lyxrc.print_paper_flag; + result += ' ' + paper_option; + } + } + if (orientation == ORIENTATION_LANDSCAPE && + papersize != PAPER_CUSTOM) + result += ' ' + lyxrc.print_landscape_flag; + return result; +} + + +string const BufferParams::babelCall(string const & lang_opts) const +{ + string tmp = lyxrc.language_package; + if (!lyxrc.language_global_options && tmp == "\\usepackage{babel}") + tmp = string("\\usepackage[") + lang_opts + "]{babel}"; + return tmp; +} + + +string const BufferParams::loadFonts(LaTeXFeatures & features, string const & rm, + string const & sf, string const & tt, + bool const & sc, bool const & osf, + int const & sfscale, int const & ttscale) const +{ + /* The LaTeX font world is in a flux. In the PSNFSS font interface, + several packages have been replaced by others, that might not + be installed on every system. We have to take care for that + (see psnfss.pdf). We try to support all psnfss fonts as well + as the fonts that have become de facto standard in the LaTeX + world (e.g. Latin Modern). We do not support obsolete fonts + (like PSLatex). In general, it should be possible to mix any + rm font with any sf or tt font, respectively. (JSpitzm) + TODO: + -- separate math fonts. + */ + + if (rm == "default" && sf == "default" && tt == "default") + //nothing to do + return string(); + + ostringstream os; + + // ROMAN FONTS + // Computer Modern (must be explicitely selectable -- there might be classes + // that define a different default font! + if (rm == "cmr") { + os << "\\renewcommand{\\rmdefault}{cmr}\n"; + // osf for Computer Modern needs eco.sty + if (osf) + os << "\\usepackage{eco}\n"; + } + // Latin Modern Roman + else if (rm == "lmodern") + os << "\\usepackage{lmodern}\n"; + // AE + else if (rm == "ae") { + // not needed when using OT1 font encoding. + if (lyxrc.fontenc != "default") + os << "\\usepackage{ae,aecompl}\n"; + } + // Times + else if (rm == "times") { + // try to load the best available package + if (features.isAvailable("mathptmx")) + os << "\\usepackage{mathptmx}\n"; + else if (features.isAvailable("mathptm")) + os << "\\usepackage{mathptm}\n"; + else + os << "\\usepackage{times}\n"; + } + // Palatino + else if (rm == "palatino") { + // try to load the best available package + if (features.isAvailable("mathpazo")) { + os << "\\usepackage"; + if (osf || sc) { + os << '['; + if (!osf) + os << "sc"; + else + // "osf" includes "sc"! + os << "osf"; + os << ']'; + } + os << "{mathpazo}\n"; + } + else if (features.isAvailable("mathpple")) + os << "\\usepackage{mathpple}\n"; + else + os << "\\usepackage{palatino}\n"; + } + // Utopia + else if (rm == "utopia") { + // fourier supersedes utopia.sty, but does + // not work with OT1 encoding. + if (features.isAvailable("fourier") + && lyxrc.fontenc != "default") { + os << "\\usepackage"; + if (osf || sc) { + os << '['; + if (sc) + os << "expert"; + if (osf && sc) + os << ','; + if (osf) + os << "oldstyle"; + os << ']'; + } + os << "{fourier}\n"; + } + else + os << "\\usepackage{utopia}\n"; + } + // Bera (complete fontset) + else if (rm == "bera" && sf == "default" && tt == "default") + os << "\\usepackage{bera}\n"; + // everything else + else if (rm != "default") + os << "\\usepackage" << "{" << rm << "}\n"; + + // SANS SERIF + // Helvetica, Bera Sans + if (sf == "helvet" || sf == "berasans") { + if (sfscale != 100) + os << "\\usepackage[scaled=" << float(sfscale) / 100 + << "]{" << sf << "}\n"; + else + os << "\\usepackage{" << sf << "}\n"; + } + // Avant Garde + else if (sf == "avant") + os << "\\usepackage{" << sf << "}\n"; + // Computer Modern, Latin Modern, CM Bright + else if (sf != "default") + os << "\\renewcommand{\\sfdefault}{" << sf << "}\n"; + + // monospaced/typewriter + // Courier, LuxiMono + if (tt == "luximono" || tt == "beramono") { + if (ttscale != 100) + os << "\\usepackage[scaled=" << float(ttscale) / 100 + << "]{" << tt << "}\n"; + else + os << "\\usepackage{" << tt << "}\n"; + } + // Courier + else if (tt == "courier" ) + os << "\\usepackage{" << tt << "}\n"; + // Computer Modern, Latin Modern, CM Bright + else if (tt != "default") + os << "\\renewcommand{\\ttdefault}{" << tt << "}\n"; + + return os.str(); +} + + +Encoding const & BufferParams::encoding() const +{ + if (inputenc == "auto" || inputenc == "default") + return *(language->encoding()); + Encoding const * const enc = + encodings.getFromLaTeXName(inputenc); + if (enc) + return *enc; + lyxerr << "Unknown inputenc value `" << inputenc + << "'. Using `auto' instead." << endl; + return *(language->encoding()); +} + +} // namespace lyx