X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferParams.cpp;h=3f0f44aeff5956fe659c638593017700bf5008a2;hb=5a8e91d1c5381d8c152b12269707b547d5241624;hp=34f1a50187189f189f0d6b9c2d208ba8c5d9e6ad;hpb=260a98d295c54ba1009236cf7101a76cba20bd03;p=lyx.git diff --git a/src/BufferParams.cpp b/src/BufferParams.cpp index 34f1a50187..3f0f44aeff 100644 --- a/src/BufferParams.cpp +++ b/src/BufferParams.cpp @@ -54,6 +54,7 @@ #include "support/gettext.h" #include "support/Messages.h" #include "support/mutex.h" +#include "support/Package.h" #include "support/Translator.h" #include "support/lstrings.h" @@ -303,6 +304,35 @@ SpaceTranslator const & spacetranslator() return translator; } + +bool inSystemDir(FileName const & document_dir, string & system_dir) +{ + // A document is assumed to be in a system LyX directory (not + // necessarily the system directory of the running instance) + // if both "configure.py" and "chkconfig.ltx" are found in + // either document_dir/../ or document_dir/../../. + // If true, the system directory path is returned in system_dir + // with a trailing path separator. + + string const msg = "Checking whether document is in a system dir..."; + + string dir = document_dir.absFileName(); + + for (int i = 0; i < 2; ++i) { + dir = addPath(dir, ".."); + if (!fileSearch(dir, "configure.py").empty() && + !fileSearch(dir, "chkconfig.ltx").empty()) { + LYXERR(Debug::FILES, msg << " yes"); + system_dir = addPath(FileName(dir).realPath(), ""); + return true; + } + } + + LYXERR(Debug::FILES, msg << " no"); + system_dir = string(); + return false; +} + } // anon namespace @@ -354,6 +384,8 @@ BufferParams::BufferParams() : pimpl_(new Impl) { setBaseClass(defaultBaseclass()); + cite_engine_.push_back("basic"); + cite_engine_type_ = ENGINE_TYPE_DEFAULT; makeDocumentClass(); paragraph_separation = ParagraphIndentSeparation; quotes_language = InsetQuotes::EnglishQuotes; @@ -363,11 +395,10 @@ BufferParams::BufferParams() papersize = PAPER_DEFAULT; orientation = ORIENTATION_PORTRAIT; use_geometry = false; - cite_engine_.push_back("basic"); - cite_engine_type_ = ENGINE_TYPE_DEFAULT; biblio_style = "plain"; use_bibtopic = false; use_indices = false; + save_transient_properties = true; track_changes = false; output_changes = false; use_default_options = true; @@ -376,16 +407,22 @@ BufferParams::BufferParams() tocdepth = 3; language = default_language; fontenc = "global"; - fonts_roman = "default"; - fonts_sans = "default"; - fonts_typewriter = "default"; - fonts_math = "auto"; + fonts_roman[0] = "default"; + fonts_roman[1] = "default"; + fonts_sans[0] = "default"; + fonts_sans[1] = "default"; + fonts_typewriter[0] = "default"; + fonts_typewriter[1] = "default"; + fonts_math[0] = "auto"; + fonts_math[1] = "auto"; fonts_default_family = "default"; useNonTeXFonts = false; fonts_expert_sc = false; fonts_old_figures = false; - fonts_sans_scale = 100; - fonts_typewriter_scale = 100; + fonts_sans_scale[0] = 100; + fonts_sans_scale[1] = 100; + fonts_typewriter_scale[0] = 100; + fonts_typewriter_scale[1] = 100; inputenc = "auto"; lang_package = "default"; graphics_driver = "default"; @@ -422,6 +459,9 @@ BufferParams::BufferParams() output_sync = false; use_refstyle = true; + + // map current author + author_map_[pimpl_->authorlist.get(0).bufferId()] = 0; } @@ -497,6 +537,12 @@ AuthorList const & BufferParams::authors() const } +void BufferParams::addAuthor(Author a) +{ + author_map_[a.bufferId()] = pimpl_->authorlist.record(a); +} + + BranchList & BufferParams::branchlist() { return pimpl_->branchlist; @@ -657,9 +703,20 @@ string BufferParams::readToken(Lexer & lex, string const & token, frontend::Alert::warning(_("Document class not available"), msg, true); } + } else if (token == "\\save_transient_properties") { + lex >> save_transient_properties; } else if (token == "\\origin") { lex.eatLine(); origin = lex.getString(); + string const sysdirprefix = "/systemlyxdir/"; + if (prefixIs(origin, sysdirprefix)) { + string docsys; + if (inSystemDir(filepath, docsys)) + origin.replace(0, sysdirprefix.length() - 1, docsys); + else + origin.replace(0, sysdirprefix.length() - 1, + package().system_support().absFileName()); + } } else if (token == "\\begin_preamble") { readPreamble(lex); } else if (token == "\\begin_local_layout") { @@ -720,17 +777,17 @@ string BufferParams::readToken(Lexer & lex, string const & token, lex.eatLine(); fontenc = lex.getString(); } else if (token == "\\font_roman") { - lex.eatLine(); - fonts_roman = lex.getString(); + lex >> fonts_roman[0]; + lex >> fonts_roman[1]; } else if (token == "\\font_sans") { - lex.eatLine(); - fonts_sans = lex.getString(); + lex >> fonts_sans[0]; + lex >> fonts_sans[1]; } else if (token == "\\font_typewriter") { - lex.eatLine(); - fonts_typewriter = lex.getString(); + lex >> fonts_typewriter[0]; + lex >> fonts_typewriter[1]; } else if (token == "\\font_math") { - lex.eatLine(); - fonts_math = lex.getString(); + lex >> fonts_math[0]; + lex >> fonts_math[1]; } else if (token == "\\font_default_family") { lex >> fonts_default_family; } else if (token == "\\use_non_tex_fonts") { @@ -740,9 +797,11 @@ string BufferParams::readToken(Lexer & lex, string const & token, } else if (token == "\\font_osf") { lex >> fonts_old_figures; } else if (token == "\\font_sf_scale") { - lex >> fonts_sans_scale; + lex >> fonts_sans_scale[0]; + lex >> fonts_sans_scale[1]; } else if (token == "\\font_tt_scale") { - lex >> fonts_typewriter_scale; + lex >> fonts_typewriter_scale[0]; + lex >> fonts_typewriter_scale[1]; } else if (token == "\\font_cjk") { lex >> fonts_cjk; } else if (token == "\\paragraph_separation") { @@ -862,7 +921,7 @@ string BufferParams::readToken(Lexer & lex, string const & token, istringstream ss(lex.getString()); Author a; ss >> a; - author_map[a.bufferId()] = pimpl_->authorlist.record(a); + addAuthor(a); } else if (token == "\\paperorientation") { string orient; lex >> orient; @@ -977,18 +1036,43 @@ string BufferParams::readToken(Lexer & lex, string const & token, } +namespace { + // Quote argument if it contains spaces + string quoteIfNeeded(string const & str) { + if (contains(str, ' ')) + return "\"" + str + "\""; + return str; + } +} + + void BufferParams::writeFile(ostream & os, Buffer const * buf) const { // The top of the file is written by the buffer. // Prints out the buffer info into the .lyx file given by file - // the document directory - os << "\\origin " - << (lyxrc.save_origin ? buf->filePath() : "unavailable") << '\n'; + os << "\\save_transient_properties " + << convert(save_transient_properties) << '\n'; + + // the document directory (must end with a path separator) + // realPath() is used to resolve symlinks, while addPath(..., "") + // ensures a trailing path separator. + string docsys; + string filepath = addPath(buf->fileName().onlyPath().realPath(), ""); + string const sysdir = inSystemDir(FileName(filepath), docsys) ? docsys + : addPath(package().system_support().realPath(), ""); + string const relpath = + to_utf8(makeRelPath(from_utf8(filepath), from_utf8(sysdir))); + if (!prefixIs(relpath, "../") && !FileName::isAbsolute(relpath)) + filepath = addPath("/systemlyxdir", relpath); + else if (!save_transient_properties || !lyxrc.save_origin) + filepath = "unavailable"; + os << "\\origin " << quoteIfNeeded(filepath) << '\n'; // the textclass - os << "\\textclass " << buf->includedFilePath(addName(buf->layoutPos(), - baseClass()->name()), "layout") + os << "\\textclass " + << quoteIfNeeded(buf->includedFilePath(addName(buf->layoutPos(), + baseClass()->name()), "layout")) << '\n'; // then the preamble @@ -1070,16 +1154,22 @@ void BufferParams::writeFile(ostream & os, Buffer const * buf) const os << "\\language_package " << lang_package << "\n\\inputencoding " << inputenc << "\n\\fontencoding " << fontenc - << "\n\\font_roman " << fonts_roman - << "\n\\font_sans " << fonts_sans - << "\n\\font_typewriter " << fonts_typewriter - << "\n\\font_math " << fonts_math + << "\n\\font_roman \"" << fonts_roman[0] + << "\" \"" << fonts_roman[1] << '"' + << "\n\\font_sans \"" << fonts_sans[0] + << "\" \"" << fonts_sans[1] << '"' + << "\n\\font_typewriter \"" << fonts_typewriter[0] + << "\" \"" << fonts_typewriter[1] << '"' + << "\n\\font_math \"" << fonts_math[0] + << "\" \"" << fonts_math[1] << '"' << "\n\\font_default_family " << fonts_default_family << "\n\\use_non_tex_fonts " << convert(useNonTeXFonts) << "\n\\font_sc " << convert(fonts_expert_sc) << "\n\\font_osf " << convert(fonts_old_figures) - << "\n\\font_sf_scale " << fonts_sans_scale - << "\n\\font_tt_scale " << fonts_typewriter_scale + << "\n\\font_sf_scale " << fonts_sans_scale[0] + << ' ' << fonts_sans_scale[1] + << "\n\\font_tt_scale " << fonts_typewriter_scale[0] + << ' ' << fonts_typewriter_scale[1] << '\n'; if (!fonts_cjk.empty()) { os << "\\font_cjk " << fonts_cjk << '\n'; @@ -1224,9 +1314,15 @@ void BufferParams::writeFile(ostream & os, Buffer const * buf) const } } - os << "\\tracking_changes " << convert(track_changes) << '\n' - << "\\output_changes " << convert(output_changes) << '\n' - << "\\html_math_output " << html_math_output << '\n' + os << "\\tracking_changes " + << (save_transient_properties ? convert(track_changes) : "false") + << '\n'; + + os << "\\output_changes " + << (save_transient_properties ? convert(output_changes) : "false") + << '\n'; + + os << "\\html_math_output " << html_math_output << '\n' << "\\html_css_as_file " << html_css_as_file << '\n' << "\\html_be_strict " << convert(html_be_strict) << '\n'; @@ -1345,12 +1441,10 @@ void BufferParams::validate(LaTeXFeatures & features) const } // some languages are only available via polyglossia - if (features.runparams().flavor == OutputParams::XETEX - && (features.hasPolyglossiaExclusiveLanguages() - || useNonTeXFonts)) - features.require("polyglossia"); + if (features.hasPolyglossiaExclusiveLanguages()) + features.require("polyglossia"); - if (useNonTeXFonts && fonts_math != "auto") + if (useNonTeXFonts && fontsMath() != "auto") features.require("unicode-math"); if (!language->requires().empty()) @@ -1517,13 +1611,14 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features, string const ams = features.loadAMSPackages(); bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1"); bool const use_newtxmath = - theLaTeXFonts().getLaTeXFont(from_ascii(fonts_math)).getUsedPackage( + theLaTeXFonts().getLaTeXFont(from_ascii(fontsMath())).getUsedPackage( ot1, false, false) == "newtxmath"; if ((useNonTeXFonts || use_newtxmath) && !ams.empty()) os << from_ascii(ams); if (useNonTeXFonts) { - os << "\\usepackage{fontspec}\n"; + if (!features.isProvided("fontspec")) + os << "\\usepackage{fontspec}\n"; if (features.mustProvide("unicode-math") && features.isAvailable("unicode-math")) os << "\\usepackage{unicode-math}\n"; @@ -1921,11 +2016,55 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features, atlyxpreamble += "\\@ifundefined{date}{}{\\date{}}\n"; /* the user-defined preamble */ - if (!containsOnly(preamble, " \n\t")) + if (!containsOnly(preamble, " \n\t")) { // FIXME UNICODE atlyxpreamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " - "User specified LaTeX commands.\n" - + from_utf8(preamble) + '\n'; + "User specified LaTeX commands.\n"; + + // Check if the user preamble contains uncodable glyphs + docstring const u_preamble = from_utf8(preamble); + odocstringstream user_preamble; + docstring uncodable_glyphs; + Encoding const * const enc = features.runparams().encoding; + if (enc) { + for (size_t n = 0; n < u_preamble.size(); ++n) { + char_type c = u_preamble[n]; + if (!enc->encodable(c)) { + docstring const glyph(1, c); + LYXERR0("Uncodable character '" + << glyph + << "' in user preamble!"); + uncodable_glyphs += glyph; + if (features.runparams().dryrun) { + user_preamble << "<" << _("LyX Warning: ") + << _("uncodable character") << " '"; + user_preamble.put(c); + user_preamble << "'>"; + } + } else + user_preamble.put(c); + } + } else + user_preamble << u_preamble; + + // On BUFFER_VIEW|UPDATE, warn user if we found uncodable glyphs + if (!features.runparams().dryrun && !uncodable_glyphs.empty()) { + frontend::Alert::warning( + _("Uncodable character in user preamble"), + support::bformat( + _("The user preamble of your document contains glyphs " + "that are unknown in the current document encoding " + "(namely %1$s).\nThese glyphs are omitted " + " from the output, which may result in " + "incomplete output." + "\n\nPlease select an appropriate " + "document encoding\n" + "(such as utf8) or change the " + "preamble code accordingly."), + uncodable_glyphs)); + } + atlyxpreamble += user_preamble.str() + '\n'; + } // footmisc must be loaded after setspace // Load it here to avoid clashes with footmisc loaded in the user @@ -1944,7 +2083,7 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features, // koma's own caption commands are used instead of caption. We // use \PassOptionsToPackage here because the user could have // already loaded subfig in the preamble. - if (features.isRequired("subfig")) { + if (features.mustProvide("subfig")) { atlyxpreamble += "\\@ifundefined{showcaptionsetup}{}{%\n" " \\PassOptionsToPackage{caption=false}{subfig}}\n" "\\usepackage{subfig}\n"; @@ -2005,7 +2144,7 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features, } if (features.isRequired("bicaption")) lyxpreamble += "\\usepackage{bicaption}\n"; - if (!listings_params.empty() || features.isRequired("listings")) + if (!listings_params.empty() || features.mustProvide("listings")) lyxpreamble += "\\usepackage{listings}\n"; if (!listings_params.empty()) { lyxpreamble += "\\lstset{"; @@ -2019,6 +2158,7 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features, // xunicode needs to be loaded at least after amsmath, amssymb, // esint and the other packages that provide special glyphs + // The package only supports XeTeX currently. if (features.runparams().flavor == OutputParams::XETEX && useNonTeXFonts) lyxpreamble += "\\usepackage{xunicode}\n"; @@ -2033,14 +2173,17 @@ bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features, lyxpreamble += "[" + from_ascii(language->polyglossiaOpts()) + "]"; lyxpreamble += "{" + from_ascii(language->polyglossia()) + "}\n"; // now setup the other languages - std::map const polylangs = + set const polylangs = features.getPolyglossiaLanguages(); - for (std::map::const_iterator mit = polylangs.begin(); + for (set::const_iterator mit = polylangs.begin(); mit != polylangs.end() ; ++mit) { + // We do not output the options here; they are output in + // the language switch commands. This is safer if multiple + // varieties are used. + if (*mit == language->polyglossia()) + continue; lyxpreamble += "\\setotherlanguage"; - if (!mit->second.empty()) - lyxpreamble += "[" + from_ascii(mit->second) + "]"; - lyxpreamble += "{" + from_ascii(mit->first) + "}\n"; + lyxpreamble += "{" + from_ascii(*mit) + "}\n"; } } @@ -2240,6 +2383,9 @@ string BufferParams::bufferFormat() const string format = documentClass().outputFormat(); if (format == "latex") { if (useNonTeXFonts) + // FIXME: In this context, this means "xetex or luatex" + // with fontspec. We cannot differentiate further here. + // But maybe use a more appropriate string. return "xetex"; if (encoding().package() == Encoding::japanese) return "platex"; @@ -2310,11 +2456,8 @@ vector BufferParams::backends() const v.push_back("xetex"); } else if (buffmt == "xetex") { v.push_back("xetex"); - // FIXME: need to test all languages (bug 8205) - if (!language || !language->isPolyglossiaExclusive()) { - v.push_back("luatex"); - v.push_back("dviluatex"); - } + v.push_back("luatex"); + v.push_back("dviluatex"); } else v.push_back(buffmt); @@ -2860,30 +3003,26 @@ docstring BufferParams::getGraphicsDriver(string const & package) const void BufferParams::writeEncodingPreamble(otexstream & os, LaTeXFeatures & features) const { - // XeTeX does not need this - if (features.runparams().flavor == OutputParams::XETEX) + // XeTeX/LuaTeX: (see also #9740) + // With Unicode fonts we use utf8-plain without encoding package. + // With TeX fonts, we cannot use utf8-plain, but "inputenc" fails. + // XeTeX must use ASCII encoding (see Buffer.cpp), + // for LuaTeX, we load "luainputenc" (see below). + if (useNonTeXFonts || features.runparams().flavor == OutputParams::XETEX) return; - // LuaTeX neither, but with tex fonts, we need to load - // the luainputenc package. - if (features.runparams().flavor == OutputParams::LUATEX - || features.runparams().flavor == OutputParams::DVILUATEX) { - if (!useNonTeXFonts && inputenc != "default" - && ((inputenc == "auto" && language->encoding()->package() == Encoding::inputenc) - || (inputenc != "auto" && encoding().package() == Encoding::inputenc))) { - os << "\\usepackage[utf8]{luainputenc}\n"; - } - return; - } + if (inputenc == "auto") { string const doc_encoding = language->encoding()->latexName(); Encoding::Package const package = language->encoding()->package(); - // Create a list with all the input encodings used - // in the document - set encodings = - features.getEncodingSet(doc_encoding); + // Create list of inputenc options: + set encodings; + // luainputenc fails with more than one encoding + if (!features.runparams().isFullUnicode()) // if we reach this point, this means LuaTeX with TeX fonts + // list all input encodings used in the document + encodings = features.getEncodingSet(doc_encoding); // If the "japanese" package (i.e. pLaTeX) is used, // inputenc must be omitted. @@ -2905,7 +3044,11 @@ void BufferParams::writeEncodingPreamble(otexstream & os, os << ','; os << from_ascii(doc_encoding); } - os << "]{inputenc}\n"; + if (features.runparams().flavor == OutputParams::LUATEX + || features.runparams().flavor == OutputParams::DVILUATEX) + os << "]{luainputenc}\n"; + else + os << "]{inputenc}\n"; } if (package == Encoding::CJK || features.mustProvide("CJK")) { if (language->encoding()->name() == "utf8-cjk" @@ -2925,8 +3068,12 @@ void BufferParams::writeEncodingPreamble(otexstream & os, if (features.isRequired("japanese") || features.isProvided("inputenc")) break; - os << "\\usepackage[" << from_ascii(encoding().latexName()) - << "]{inputenc}\n"; + os << "\\usepackage[" << from_ascii(encoding().latexName()); + if (features.runparams().flavor == OutputParams::LUATEX + || features.runparams().flavor == OutputParams::DVILUATEX) + os << "]{luainputenc}\n"; + else + os << "]{inputenc}\n"; break; case Encoding::CJK: if (encoding().name() == "utf8-cjk" @@ -2962,9 +3109,9 @@ string const BufferParams::parseFontName(string const & name) const string const BufferParams::loadFonts(LaTeXFeatures & features) const { - if (fonts_roman == "default" && fonts_sans == "default" - && fonts_typewriter == "default" - && (fonts_math == "default" || fonts_math == "auto")) + if (fontsRoman() == "default" && fontsSans() == "default" + && fontsTypewriter() == "default" + && (fontsMath() == "default" || fontsMath() == "auto")) //nothing to do return string(); @@ -2993,28 +3140,28 @@ string const BufferParams::loadFonts(LaTeXFeatures & features) const string const texmapping = (features.runparams().flavor == OutputParams::XETEX) ? "Mapping=tex-text" : "Ligatures=TeX"; - if (fonts_roman != "default") { + if (fontsRoman() != "default") { os << "\\setmainfont[" << texmapping; if (fonts_old_figures) os << ",Numbers=OldStyle"; - os << "]{" << parseFontName(fonts_roman) << "}\n"; + os << "]{" << parseFontName(fontsRoman()) << "}\n"; } - if (fonts_sans != "default") { - string const sans = parseFontName(fonts_sans); - if (fonts_sans_scale != 100) + if (fontsSans() != "default") { + string const sans = parseFontName(fontsSans()); + if (fontsSansScale() != 100) os << "\\setsansfont[Scale=" - << float(fonts_sans_scale) / 100 + << float(fontsSansScale()) / 100 << "," << texmapping << "]{" << sans << "}\n"; else os << "\\setsansfont[" << texmapping << "]{" << sans << "}\n"; } - if (fonts_typewriter != "default") { - string const mono = parseFontName(fonts_typewriter); - if (fonts_typewriter_scale != 100) + if (fontsTypewriter() != "default") { + string const mono = parseFontName(fontsTypewriter()); + if (fontsTypewriterScale() != 100) os << "\\setmonofont[Scale=" - << float(fonts_typewriter_scale) / 100 + << float(fontsTypewriterScale()) / 100 << "]{" << mono << "}\n"; else @@ -3027,26 +3174,26 @@ string const BufferParams::loadFonts(LaTeXFeatures & features) const // Tex Fonts bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1"); bool const dryrun = features.runparams().dryrun; - bool const complete = (fonts_sans == "default" && fonts_typewriter == "default"); - bool const nomath = (fonts_math == "default"); + bool const complete = (fontsSans() == "default" && fontsTypewriter() == "default"); + bool const nomath = (fontsMath() == "default"); // ROMAN FONTS - os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_roman)).getLaTeXCode( + os << theLaTeXFonts().getLaTeXFont(from_ascii(fontsRoman())).getLaTeXCode( dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures, nomath); // SANS SERIF - os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_sans)).getLaTeXCode( + os << theLaTeXFonts().getLaTeXFont(from_ascii(fontsSans())).getLaTeXCode( dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures, - nomath, fonts_sans_scale); + nomath, fontsSansScale()); // MONOSPACED/TYPEWRITER - os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_typewriter)).getLaTeXCode( + os << theLaTeXFonts().getLaTeXFont(from_ascii(fontsTypewriter())).getLaTeXCode( dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures, - nomath, fonts_typewriter_scale); + nomath, fontsTypewriterScale()); // MATH - os << theLaTeXFonts().getLaTeXFont(from_ascii(fonts_math)).getLaTeXCode( + os << theLaTeXFonts().getLaTeXFont(from_ascii(fontsMath())).getLaTeXCode( dryrun, ot1, complete, fonts_expert_sc, fonts_old_figures, nomath); @@ -3056,11 +3203,13 @@ string const BufferParams::loadFonts(LaTeXFeatures & features) const Encoding const & BufferParams::encoding() const { - // FIXME: actually, we should check for the flavor - // or runparams.isFullyUnicode() here: - // This check will not work with XeTeX/LuaTeX and tex fonts. - // Thus we have to reset the encoding in Buffer::makeLaTeXFile - // (for export) and Buffer::writeLaTeXSource (for preview). + // Main encoding for LaTeX output. + // + // Exception: XeTeX with 8-bit TeX fonts requires ASCII (see #9740). + // As the "flavor" is only known once export started, this + // cannot be handled here. Instead, runparams.encoding is set + // to ASCII in Buffer::makeLaTeXFile (for export) + // and Buffer::writeLaTeXSource (for preview). if (useNonTeXFonts) return *(encodings.fromLyXName("utf8-plain")); if (inputenc == "auto" || inputenc == "default")