AuthorList authorlist;
BranchList branchlist;
+ WordLangTable spellignore;
Bullet temp_bullets[4];
Bullet user_defined_bullets[4];
IndicesList indiceslist;
html_math_img_scale = 1.0;
html_css_as_file = false;
docbook_table_output = HTMLTable;
+ docbook_mathml_prefix = MPrefix;
display_pixel_ratio = 1.0;
shell_escape = false;
}
+WordLangTable & BufferParams::spellignore()
+{
+ return pimpl_->spellignore;
+}
+
+
+WordLangTable const & BufferParams::spellignore() const
+{
+ return pimpl_->spellignore;
+}
+
+
+bool BufferParams::spellignored(WordLangTuple const & wl) const
+{
+ bool has_item = false;
+ vector<WordLangTuple> il = spellignore();
+ vector<WordLangTuple>::const_iterator it = il.begin();
+ for (; it != il.end(); ++it) {
+ if (it->lang()->code() != wl.lang()->code())
+ continue;
+ if (it->word() == wl.word()) {
+ has_item = true;
+ break;
+ }
+ }
+ return has_item;
+}
+
+
Bullet & BufferParams::temp_bullet(lyx::size_type const index)
{
LASSERT(index < 4, return pimpl_->temp_bullets[0]);
origin.replace(0, sysdirprefix.length() - 1,
package().system_support().absFileName());
}
+ } else if (token == "\\begin_metadata") {
+ readDocumentMetadata(lex);
} else if (token == "\\begin_preamble") {
readPreamble(lex);
} else if (token == "\\begin_local_layout") {
lcolor.setColor(to_utf8(shortcut)+ "@" + filename.absFileName(), color);
}
}
+ } else if (token == "\\spellchecker_ignore") {
+ lex.eatLine();
+ docstring wl = lex.getDocString();
+ docstring language;
+ docstring word = split(wl, language, ' ');
+ Language const * lang = languages.getLanguage(to_ascii(language));
+ if (lang)
+ spellignore().push_back(WordLangTuple(word, lang));
} else if (token == "\\author") {
lex.eatLine();
istringstream ss(lex.getString());
notefontcolor = lyx::rgbFromHexName(color);
lcolor.setColor("notefontcolor", color);
lcolor.setLaTeXName("notefontcolor", "note_fontcolor");
+ lcolor.setGUIName("notefontcolor", N_("greyedout inset text"));
// set a local name for the painter
lcolor.setColor("notefontcolor@" + filename.absFileName(), color);
isnotefontcolor = true;
int temp;
lex >> temp;
docbook_table_output = static_cast<TableOutput>(temp);
+ } else if (token == "\\docbook_mathml_prefix") {
+ int temp;
+ lex >> temp;
+ docbook_mathml_prefix = static_cast<MathMLNameSpacePrefix>(temp);
} else if (token == "\\output_sync") {
lex >> output_sync;
} else if (token == "\\output_sync_macro") {
baseClass()->name()), "layout"))
<< '\n';
+ // then document metadata
+ if (!document_metadata.empty()) {
+ // remove '\n' from the end of document_metadata
+ docstring const tmpmd = rtrim(document_metadata, "\n");
+ os << "\\begin_metadata\n"
+ << to_utf8(tmpmd)
+ << "\n\\end_metadata\n";
+ }
+
// then the preamble
if (!preamble.empty()) {
// remove '\n' from the end of preamble
<< "\n";
}
+ for (auto const & si : spellignore()) {
+ os << "\\spellchecker_ignore " << si.lang()->lang()
+ << " " << to_utf8(si.word())
+ << "\n";
+ }
+
if (!paperwidth.empty())
os << "\\paperwidth "
<< VSpace(paperwidth).asLyXCommand() << '\n';
<< "\\html_be_strict " << convert<string>(html_be_strict) << '\n';
os << "\\docbook_table_output " << docbook_table_output << '\n';
+ os << "\\docbook_mathml_prefix " << docbook_mathml_prefix << '\n';
if (html_math_img_scale != 1.0)
os << "\\html_math_img_scale " << convert<string>(html_math_img_scale) << '\n';
bool BufferParams::writeLaTeX(otexstream & os, LaTeXFeatures & features,
FileName const & filepath) const
{
+ // DocumentMetadata must come before anything else
+ if (features.isAvailable("LaTeX-2022/06/01")
+ && !containsOnly(document_metadata, " \n\t")) {
+ // Check if the user preamble contains uncodable glyphs
+ odocstringstream doc_metadata;
+ docstring uncodable_glyphs;
+ Encoding const * const enc = features.runparams().encoding;
+ if (enc) {
+ for (char_type c : document_metadata) {
+ if (!enc->encodable(c)) {
+ docstring const glyph(1, c);
+ LYXERR0("Uncodable character '"
+ << glyph
+ << "' in document metadata!");
+ uncodable_glyphs += glyph;
+ if (features.runparams().dryrun) {
+ doc_metadata << "<" << _("LyX Warning: ")
+ << _("uncodable character") << " '";
+ doc_metadata.put(c);
+ doc_metadata << "'>";
+ }
+ } else
+ doc_metadata.put(c);
+ }
+ } else
+ doc_metadata << document_metadata;
+
+ // On BUFFER_VIEW|UPDATE, warn user if we found uncodable glyphs
+ if (!features.runparams().dryrun && !uncodable_glyphs.empty()) {
+ frontend::Alert::warning(
+ _("Uncodable character in document metadata"),
+ support::bformat(
+ _("The metadata 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));
+ }
+ if (!doc_metadata.str().empty()) {
+ os << "\\DocumentMetadata{\n"
+ << doc_metadata.str()
+ << "}\n";
+ }
+ }
+
// http://www.tug.org/texmf-dist/doc/latex/base/fixltx2e.pdf
// !! To use the Fix-cm package, load it before \documentclass, and use the command
// \RequirePackage to do so, rather than the normal \usepackage
// if we use fontspec or newtxmath, we have to load the AMS packages here
string const ams = features.loadAMSPackages();
- bool const ot1 = (main_font_encoding() == "default" || main_font_encoding() == "OT1");
+ string const main_font_enc = features.runparams().main_fontenc;
+ bool const ot1 = (main_font_enc == "default" || main_font_enc == "OT1");
bool const use_newtxmath =
theLaTeXFonts().getLaTeXFont(from_ascii(fontsMath())).getUsedPackage(
ot1, false, false) == "newtxmath";
// set font encoding
// non-TeX fonts use font encoding TU (set by fontspec)
if (!useNonTeXFonts && !features.isProvided("fontenc")
- && main_font_encoding() != "default") {
+ && main_font_enc != "default") {
// get main font encodings
vector<string> fontencs = font_encodings();
// get font encodings of secondary languages
}
+void BufferParams::readDocumentMetadata(Lexer & lex)
+{
+ if (lex.getString() != "\\begin_metadata")
+ lyxerr << "Error (BufferParams::readDocumentMetadata):"
+ "consistency check failed." << endl;
+
+ document_metadata = lex.getLongString(from_ascii("\\end_metadata"));
+}
+
+
void BufferParams::readLocalLayout(Lexer & lex, bool forced)
{
string const expected = forced ? "\\begin_forced_local_layout" :
string const BufferParams::main_font_encoding() const
{
- if (font_encodings().empty()) {
+ vector<string> const fencs = font_encodings();
+ if (fencs.empty()) {
if (ascii_lowercase(language->fontenc(*this)) == "none")
return "none";
return "default";
}
- return font_encodings().back();
+ return fencs.back();
}
if (!doc_fontenc.empty())
// If we have a custom setting, we use only that!
return getVectorFromString(doc_fontenc);
- if (!language->fontenc(*this).empty()
+ string const lfe = language->fontenc(*this);
+ if (!lfe.empty()
&& ascii_lowercase(language->fontenc(*this)) != "none") {
- vector<string> fencs = getVectorFromString(language->fontenc(*this));
+ vector<string> fencs = getVectorFromString(lfe);
for (auto & fe : fencs) {
if (find(fontencs.begin(), fontencs.end(), fe) == fontencs.end())
fontencs.push_back(fe);
}
// Tex Fonts
- bool const ot1 = (main_font_encoding() == "default" || main_font_encoding() == "OT1");
+ bool const ot1 = (features.runparams().main_fontenc == "default"
+ || features.runparams().main_fontenc == "OT1");
bool const dryrun = features.runparams().dryrun;
bool const complete = (fontsSans() == "default" && fontsTypewriter() == "default");
bool const nomath = (fontsMath() != "auto");
}
-string const BufferParams::bibtexCommand() const
+string const BufferParams::getBibtexCommand(string const cmd, bool const warn) const
+{
+ // split from options
+ string command_in;
+ split(cmd, command_in, ' ');
+
+ // Look if the requested command is available. If so, use that.
+ for (auto const & alts : lyxrc.bibtex_alternatives) {
+ string command_prov;
+ split(alts, command_prov, ' ');
+ if (command_in == command_prov)
+ return cmd;
+ }
+
+ // If not, find the most suitable fallback for the current cite framework,
+ // and warn. Note that we omit options in any such case.
+ string fallback;
+ if (useBiblatex()) {
+ // For Biblatex, we prefer biber (also for Japanese)
+ // and try to fall back to bibtex8
+ if (lyxrc.bibtex_alternatives.find("biber") != lyxrc.bibtex_alternatives.end())
+ fallback = "biber";
+ else if (lyxrc.bibtex_alternatives.find("bibtex8") != lyxrc.bibtex_alternatives.end())
+ fallback = "bibtex8";
+ }
+ // For classic BibTeX and as last resort for biblatex, try bibtex
+ if (fallback.empty()) {
+ if (lyxrc.bibtex_alternatives.find("bibtex") != lyxrc.bibtex_alternatives.end())
+ fallback = "bibtex";
+ }
+
+ if (!warn)
+ return fallback;
+
+ if (fallback.empty()) {
+ frontend::Alert::warning(
+ _("No bibliography processor found!"),
+ support::bformat(
+ _("The bibliography processor requested by this document "
+ "(%1$s) is not available and no appropriate "
+ "alternative has been found. "
+ "No bibliography and references will be generated.\n"
+ "Please fix your installation!"),
+ from_utf8(cmd)));
+ } else {
+ frontend::Alert::warning(
+ _("Requested bibliography processor not found!"),
+ support::bformat(
+ _("The bibliography processor requested by this document "
+ "(%1$s) is not available. "
+ "As a fallback, '%2$s' will be used, options are omitted. "
+ "This might result in errors or unwanted changes in "
+ "the bibliography. Please check carefully!\n"
+ "It is suggested to install the missing processor."),
+ from_utf8(cmd), from_utf8(fallback)));
+ }
+ return fallback;
+}
+
+
+string const BufferParams::bibtexCommand(bool const warn) const
{
// Return document-specific setting if available
if (bibtex_command != "default")
- return bibtex_command;
+ return getBibtexCommand(bibtex_command, warn);
// If we have "default" in document settings, consult the prefs
// 1. Japanese (uses a specific processor)
// 2. All other languages
else if (lyxrc.bibtex_command != "automatic")
// Return the specified program, if "automatic" is not set
- return lyxrc.bibtex_command;
+ return getBibtexCommand(lyxrc.bibtex_command, warn);
// 3. Automatic: find the most suitable for the current cite framework
if (useBiblatex()) {
projects / features.git / blobdiff