lex.next();
string const classname = lex.getString();
// if there exists a local layout file, ignore the system one
- // NOTE: in this case, the textclass (.cls file) is assumed to be available.
+ // NOTE: in this case, the textclass (.cls file) is assumed to
+ // be available.
string tcp;
LayoutFileList & bcl = LayoutFileList::get();
if (tcp.empty() && !filepath.empty())
setBaseClass(tcp);
else
setBaseClass(classname);
- // We assume that a tex class exists for local or unknown layouts so this warning
- // will only be given for system layouts.
+ // We assume that a tex class exists for local or unknown
+ // layouts so this warning, will only be given for system layouts.
if (!baseClass()->isTeXClassAvailable()) {
docstring const desc =
translateIfPossible(from_utf8(baseClass()->description()));
- docstring const prereqs = from_utf8(baseClass()->prerequisites());
+ docstring const prereqs =
+ from_utf8(baseClass()->prerequisites());
docstring const msg =
bformat(_("The selected document class\n"
"\t%1$s\n"
features.require("ct-none");
}
break;
+ case OutputParams::LUATEX:
case OutputParams::PDFLATEX:
case OutputParams::XETEX:
if (xcolorulem) {
features.require("color");
}
- if (useXetex)
- features.require("xetex");
+ if (features.runparams().flavor == OutputParams::XETEX)
+ features.require("polyglossia");
if (language->lang() == "vietnamese")
features.require("vietnamese");
ostringstream language_options;
bool const use_babel = features.useBabel() && !tclass.provides("babel");
- if (use_babel) {
+ bool const use_polyglossia = features.usePolyglossia();
+ bool const global = lyxrc.language_global_options;
+ if (use_babel || (use_polyglossia && global)) {
language_options << features.getLanguages();
if (!language->babel().empty()) {
if (!language_options.str().empty())
language_options << ',';
language_options << language->babel();
}
- if (lyxrc.language_global_options
- && !features.needBabelLangOptions())
+ if (global && !features.needBabelLangOptions())
clsoptions << language_options.str() << ',';
}
// set font encoding
// for arabic_arabi and farsi we also need to load the LAE and
// LFE encoding
- // XeTeX works without fontenc
+ // XeTeX and LuaTeX (isFullUnicode() flavor) work without fontenc
if (font_encoding() != "default" && language->lang() != "japanese"
- && !useXetex && !tclass.provides("fontenc")) {
+ && !features.runparams().isFullUnicode() && !tclass.provides("fontenc")) {
size_t fars = language_options.str().find("farsi");
size_t arab = language_options.str().find("arabic");
if (language->lang() == "arabic_arabi"
// If we use hyperref, jurabib, japanese, or vietnamese, we have to call babel before them.
if (use_babel
- && (features.isRequired("jurabib")
- || features.isRequired("hyperref")
- || features.isRequired("vietnamese")
- || features.isRequired("japanese") ) ) {
- // FIXME UNICODE
- lyxpreamble += from_utf8(features.getBabelPresettings());
- lyxpreamble += from_utf8(babelCall(language_options.str(),
- features.needBabelLangOptions())) + '\n';
- lyxpreamble += from_utf8(features.getBabelPostsettings());
+ && (features.isRequired("jurabib")
+ || features.isRequired("hyperref")
+ || features.isRequired("vietnamese")
+ || features.isRequired("japanese"))) {
+ // FIXME UNICODE
+ lyxpreamble += from_utf8(features.getBabelPresettings());
+ lyxpreamble += from_utf8(babelCall(language_options.str(),
+ features.needBabelLangOptions())) + '\n';
+ lyxpreamble += from_utf8(features.getBabelPostsettings());
}
// The optional packages;
lyxpreamble += from_utf8(features.getBabelPostsettings());
}
+ // FIXME Polyglossia?
docstring const i18npreamble = features.getTClassI18nPreamble(use_babel);
if (!i18npreamble.empty())
lyxpreamble += i18npreamble + '\n';
// these packages (xunicode, for that matter) need to be loaded at least
// after amsmath, amssymb, esint and the other packages that provide
// special glyphs
- if (useXetex) {
+ if (features.runparams().flavor == OutputParams::XETEX) {
os << "\\usepackage{xunicode}\n";
texrow.newline();
os << "\\usepackage{xltxtra}\n";
texrow.newline();
}
+ // Polyglossia must be loaded after xltxtra
+ if (use_polyglossia) {
+ // call the package
+ os << "\\usepackage{polyglossia}\n";
+ texrow.newline();
+ // set the main language
+ os << "\\setdefaultlanguage";
+ if (!language->polyglossiaOpts().empty())
+ os << "[" << from_ascii(language->polyglossiaOpts()) << "]";
+ os << "{" + from_ascii(language->polyglossia()) + "}\n";
+ texrow.newline();
+ // now setup the other languages
+ std::map<std::string, std::string> const polylangs =
+ features.getPolyglossiaLanguages();
+ for (std::map<std::string, std::string>::const_iterator mit = polylangs.begin();
+ mit != polylangs.end() ; ++mit) {
+ os << "\\setotherlanguage";
+ if (!mit->second.empty())
+ os << "[" << from_ascii(mit->second) << "]";
+ os << "{" << from_ascii(mit->first) << "}\n";
+ texrow.newline();
+ }
+ }
return use_babel;
}
string BufferParams::babelCall(string const & lang_opts, bool const langoptions) const
{
- string lang_pack = lyxrc.language_package;
- if (lang_pack != "\\usepackage{babel}")
- return lang_pack;
+ if (lyxrc.language_package_selection == LyXRC::LP_CUSTOM)
+ return lyxrc.language_custom_package;
// suppress the babel call if there is no BabelName defined
// for the document language in the lib/languages file and if no
// other languages are used (lang_opts is then empty)
// be submitted to babel itself (not the class).
if (langoptions)
return "\\usepackage[" + lang_opts + "]{babel}";
- return lang_pack;
+ return "\\usepackage{babel}";
}
void BufferParams::writeEncodingPreamble(odocstream & os,
LaTeXFeatures & features, TexRow & texrow) const
{
- if (useXetex)
+ // fully unicode-aware backends (such as XeTeX) do not need this
+ if (features.runparams().isFullUnicode())
return;
if (inputenc == "auto") {
string const doc_encoding =
ostringstream os;
if (xetex) {
- if (rm != "default")
- os << "\\setmainfont[Mapping=tex-text]{"
- << parseFontName(rm) << "}\n";
+ if (rm != "default") {
+ os << "\\setmainfont[Mapping=tex-text";
+ if (osf)
+ os << ",Numbers=OldStyle";
+ os << "]{" << parseFontName(rm) << "}\n";
+ }
if (sf != "default") {
string const sans = parseFontName(sf);
if (sfscale != 100)
os << "\\setmonofont[Mapping=tex-text]{"
<< mono << "}\n";
}
- if (osf)
- os << "\\defaultfontfeatures{Numbers=OldStyle}\n";
return os.str();
}