static docstring const lyx_hyperref_def = from_ascii(
"\\providecommand{\\LyX}{\\texorpdfstring%\n"
" {L\\kern-.1667em\\lower.25em\\hbox{Y}\\kern-.125emX\\@}\n"
- " {LyX}}");
+ " {LyX}}");
static docstring const noun_def = from_ascii(
"\\newcommand{\\noun}[1]{\\textsc{#1}}");
"\\newcommand{\\lyxadded}[3]{#3}\n"
"\\newcommand{\\lyxdeleted}[3]{}\n");
+static docstring const textgreek_LGR_def = from_ascii(
+ "\\DeclareFontEncoding{LGR}{}{}\n");
static docstring const textgreek_def = from_ascii(
"\\DeclareRobustCommand{\\greektext}{%\n"
" \\fontencoding{LGR}\\selectfont\\def\\encodingdefault{LGR}}\n"
"\\DeclareRobustCommand{\\textgreek}[1]{\\leavevmode{\\greektext #1}}\n"
- "\\DeclareFontEncoding{LGR}{}{}\n"
- "\\DeclareTextSymbol{\\~}{LGR}{126}");
+ "\\ProvideTextCommand{\\~}{LGR}[1]{\\char126#1}\n");
+static docstring const textcyr_T2A_def = from_ascii(
+ "\\InputIfFileExists{t2aenc.def}{}{%\n"
+ " \\errmessage{File `t2aenc.def' not found: Cyrillic script not supported}}\n");
static docstring const textcyr_def = from_ascii(
"\\DeclareRobustCommand{\\cyrtext}{%\n"
" \\fontencoding{T2A}\\selectfont\\def\\encodingdefault{T2A}}\n"
- "\\DeclareRobustCommand{\\textcyr}[1]{\\leavevmode{\\cyrtext #1}}\n"
- "\\AtBeginDocument{\\DeclareFontEncoding{T2A}{}{}}\n");
+ "\\DeclareRobustCommand{\\textcyr}[1]{\\leavevmode{\\cyrtext #1}}\n");
static docstring const lyxmathsym_def = from_ascii(
"\\newcommand{\\lyxmathsym}[1]{\\ifmmode\\begingroup\\def\\b@ld{bold}\n"
" \\mathchar\"0\\hexnumber@\\symtipasymb0C}{#2}}\n"
"\\newcommand{\\ogonek}[1]{\\mathpalette\\doogonek{#1}}\n");
+static docstring const lyxaccent_def = from_ascii(
+ "%% custom text accent \\LyxTextAccent[<rise value (length)>]{<accent>}{<base>}\n"
+ "\\newcommand*{\\LyxTextAccent}[3][0ex]{%\n"
+ " \\hmode@bgroup\\ooalign{\\null#3\\crcr\\hidewidth\n"
+ " \\raise#1\\hbox{#2}\\hidewidth}\\egroup}\n"
+ "%% select a font size smaller than the current font size:\n"
+ "\\newcommand{\\LyxAccentSize}[1][\\sf@size]{%\n"
+ " \\check@mathfonts\\fontsize#1\\z@\\math@fontsfalse\\selectfont\n"
+ "}\n");
+
+static docstring const textcommabelow_def = from_ascii(
+ "\\ProvideTextCommandDefault{\\textcommabelow}[1]{%%\n"
+ " \\LyxTextAccent[-.31ex]{\\LyxAccentSize,}{#1}}\n");
+
+static docstring const textcommaabove_def = from_ascii(
+ "\\ProvideTextCommandDefault{\\textcommaabove}[1]{%%\n"
+ " \\LyxTextAccent[.5ex]{\\LyxAccentSize`}{#1}}\n");
+
+static docstring const textcommaaboveright_def = from_ascii(
+ "\\ProvideTextCommandDefault{\\textcommaaboveright}[1]{%%\n"
+ " \\LyxTextAccent[.5ex]{\\LyxAccentSize\\ `}{#1}}\n");
+
+// Baltic languages use a comma-accent instead of a cedilla
+static docstring const textbaltic_def = from_ascii(
+ "%% use comma accent instead of cedilla for these characters:\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{g}{\\textcommaabove{g}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{G}{\\textcommabelow{G}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{k}{\\textcommabelow{k}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{K}{\\textcommabelow{K}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{l}{\\textcommabelow{l}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{L}{\\textcommabelow{L}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{n}{\\textcommabelow{n}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{N}{\\textcommabelow{N}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{r}{\\textcommabelow{r}}\n"
+ "\\DeclareTextCompositeCommand{\\c}{T1}{R}{\\textcommabelow{R}}\n");
+
static docstring const lyxref_def = from_ascii(
- "\\RS@ifundefined{subref}\n"
- " {\\def\\RSsubtxt{section~}\\newref{sub}{name = \\RSsubtxt}}\n"
+ "\\RS@ifundefined{subsecref}\n"
+ " {\\newref{subsec}{name = \\RSsectxt}}\n"
" {}\n"
"\\RS@ifundefined{thmref}\n"
" {\\def\\RSthmtxt{theorem~}\\newref{thm}{name = \\RSthmtxt}}\n"
" {}\n"
"\\RS@ifundefined{lemref}\n"
- " {\\def\\RSlemtxt{lemma~}\\newref{lem}{name = \\RSlemtxt}}\n"
+ " {\\def\\RSlemtxt{lemma~}\\newref{lem}{name = \\RSlemtxt}}\n"
" {}\n");
// Make sure the columns are also outputed as rtl
static docstring const lyxnoun_style = from_ascii(
"dfn.lyxnoun {\n"
- " font-variant: small-caps;\n"
- "}\n");
+ " font-variant: small-caps;\n"
+ "}\n");
// this is how it normally renders, but it might not always do so.
static docstring const lyxstrikeout_style = from_ascii(
"del.strikeout {\n"
- " text-decoration: line-through;\n"
- "}\n");
+ " text-decoration: line-through;\n"
+ "}\n");
/////////////////////////////////////////////////////////////////////
&& isAvailable("polyglossia")
&& !isProvided("babel")
&& this->hasOnlyPolyglossiaLanguages();
- bool const babel_required =
+ bool const babel_required =
!bufferParams().language->babel().empty()
|| !this->getBabelLanguages().empty();
from_ascii(params_.fonts_math)).provides(name, ot1,
complete,
nomath);
+ // TODO: "textbaltic" provided, if the font-encoding is "L7x"
+ // "textgreek" provided, if a language with font-encoding LGR is used in the document
+ // "textcyr" provided, if a language with font-encoding T2A is used in the document
}
return encodings;
}
+
+void LaTeXFeatures::getFontEncodings(vector<string> & encodings) const
+{
+ // these must be loaded if glyphs of this script
+ // are used (notwithstanding the language)
+ if (mustProvide("textgreek"))
+ encodings.insert(encodings.begin(), "LGR");
+ if (mustProvide("textcyr"))
+ encodings.insert(encodings.begin(), "T2A");
+
+ LanguageList::const_iterator it = UsedLanguages_.begin();
+ LanguageList::const_iterator end = UsedLanguages_.end();
+ for (; it != end; ++it)
+ if (!(*it)->fontenc().empty()
+ && ascii_lowercase((*it)->fontenc()) != "none") {
+ vector<string> extraencs = getVectorFromString((*it)->fontenc());
+ vector<string>::const_iterator fit = extraencs.begin();
+ for (; fit != extraencs.end(); ++fit) {
+ if (find(encodings.begin(), encodings.end(), *fit) == encodings.end())
+ encodings.insert(encodings.begin(), *fit);
+ }
+ }
+}
+
namespace {
char const * simplefeatures[] = {
"pmboxdraw",
"bbding",
"ifsym",
- "marvosym",
"txfonts",
"pxfonts",
"mathdesign",
"tfrupee",
"shapepar",
"rsphrase",
+ "hpstatement",
"algorithm2e",
"sectionbox",
"tcolorbox",
"pdfcomment",
"fixme",
- "todonotes"
+ "todonotes",
+ "forest",
+ "varwidth"
};
char const * bibliofeatures[] = {
}
+string const LaTeXFeatures::getPackageOptions() const
+{
+ ostringstream packageopts;
+ // Output all the package option stuff we have been asked to do.
+ map<string, string>::const_iterator it =
+ params_.documentClass().packageOptions().begin();
+ map<string, string>::const_iterator en =
+ params_.documentClass().packageOptions().end();
+ for (; it != en; ++it)
+ if (mustProvide(it->first))
+ packageopts << "\\PassOptionsToPackage{" << it->second << "}"
+ << "{" << it->first << "}\n";
+ return packageopts.str();
+}
+
+
string const LaTeXFeatures::getPackages() const
{
ostringstream packages;
// also unknown packages can be requested. They are silently
// swallowed now. We should change this eventually.
- // Output all the package option stuff we have been asked to do.
- map<string, string>::const_iterator it =
- params_.documentClass().packageOptions().begin();
- map<string, string>::const_iterator en =
- params_.documentClass().packageOptions().end();
- for (; it != en; ++it)
- if (mustProvide(it->first))
- packages << "\\PassOptionsToPackage{" << it->second << "}"
- << "{" << it->first << "}\n";
-
// These are all the 'simple' includes. i.e
// packages which we just \usepackage{package}
for (int i = 0; i < nb_simplefeatures; ++i) {
bool const use_newtxmath =
theLaTeXFonts().getLaTeXFont(from_ascii(params_.fonts_math)).getUsedPackage(
ot1, false, false) == "newtxmath";
-
+
if (!params_.useNonTeXFonts && !use_newtxmath && !amsPackages.empty())
packages << amsPackages;
- // fixltx2e must be loaded after amsthm, since amsthm produces an error with
- // the redefined \[ command (bug 7233). Load it as early as possible, since
- // other packages might profit from it.
- if (mustProvide("fixltx2e"))
- packages << "\\usepackage{fixltx2e}\n";
-
if (mustProvide("cancel") &&
params_.use_package("cancel") != BufferParams::package_off)
packages << "\\usepackage{cancel}\n";
-
+
+ // marvosym and bbding both define the \Cross macro
+ if (mustProvide("marvosym")) {
+ if (mustProvide("bbding"))
+ packages << "\\let\\Cross\\relax\n";
+ packages << "\\usepackage{marvosym}\n";
+ }
+
// accents must be loaded after amsmath
if (mustProvide("accents") &&
params_.use_package("accents") != BufferParams::package_off)
macros << lyxarrow_def << '\n';
if (!usePolyglossia() && mustProvide("textgreek")) {
- // Avoid a LaTeX error if times fonts are used and the grtimes
- // package is installed but actual fonts are not (bug 6469).
- if (params_.fonts_roman == "times")
- macros << subst(textgreek_def,
- from_ascii("\\greektext #1"),
- from_ascii("%\n \\IfFileExists"
- "{grtm10.tfm}{}{\\fontfamily"
- "{cmr}}\\greektext #1"))
- << '\n';
- else
- macros << textgreek_def << '\n';
+ // ensure LGR font encoding is defined also if fontenc is not loaded by LyX
+ if (params_.font_encoding() == "default")
+ macros << textgreek_LGR_def;
+ macros << textgreek_def << '\n';
}
- if (!usePolyglossia() && mustProvide("textcyr"))
+ if (!usePolyglossia() && mustProvide("textcyr")) {
+ // ensure T2A font encoding is set up also if fontenc is not loaded by LyX
+ if (params_.font_encoding() == "default")
+ macros << textcyr_T2A_def;
macros << textcyr_def << '\n';
+ }
+
+ // non-standard text accents:
+ if (mustProvide("textcommaabove") || mustProvide("textcommaaboveright") ||
+ mustProvide("textcommabelow") || mustProvide("textbaltic"))
+ macros << lyxaccent_def;
+
+ if (mustProvide("textcommabelow") || mustProvide("textbaltic"))
+ macros << textcommabelow_def << '\n';
+
+ if (mustProvide("textcommaabove") || mustProvide("textbaltic"))
+ macros << textcommaabove_def << '\n';
+
+ if (mustProvide("textcommaaboveright"))
+ macros << textcommaaboveright_def << '\n';
+
+ if (mustProvide("textbaltic"))
+ macros << textbaltic_def << '\n';
if (mustProvide("lyxmathsym"))
macros << lyxmathsym_def << '\n';
string const LaTeXFeatures::loadAMSPackages() const
{
ostringstream tmp;
- if (mustProvide("amsthm"))
- tmp << "\\usepackage{amsthm}\n";
if (mustProvide("amsmath")
&& params_.use_package("amsmath") != BufferParams::package_off) {
tmp << "\\usepackage{amstext}\n";
}
+ if (mustProvide("amsthm"))
+ tmp << "\\usepackage{amsthm}\n";
+
if (mustProvide("amssymb")
&& params_.use_package("amssymb") != BufferParams::package_off)
tmp << "\\usepackage{amssymb}\n";
docstring const i18npreamble(docstring const & templ, Language const * lang,
- Encoding const & enc, bool const polyglossia)
+ Encoding const & enc, bool const polyglossia,
+ bool const need_fixedwidth)
{
if (templ.empty())
return templ;
string const langenc = lang->encoding()->iconvName();
string const texenc = lang->encoding()->latexName();
string const bufenc = enc.iconvName();
+ Encoding const * testenc(&enc);
+ bool lang_fallback = false;
+ bool ascii_fallback = false;
+ if (need_fixedwidth && !enc.hasFixedWidth()) {
+ if (lang->encoding()->hasFixedWidth()) {
+ testenc = lang->encoding();
+ lang_fallback = true;
+ } else {
+ // We need a fixed width encoding, but both the buffer
+ // encoding and the language encoding are variable
+ // width. As a last fallback, try to convert to pure
+ // ASCII using the LaTeX commands defined in unicodesymbols.
+ testenc = encodings.fromLyXName("ascii");
+ if (!testenc)
+ return docstring();
+ ascii_fallback = true;
+ }
+ }
// First and second character of plane 15 (Private Use Area)
string const s1 = "\xf3\xb0\x80\x80"; // U+F0000
string const s2 = "\xf3\xb0\x80\x81"; // U+F0001
docstring const name = lang->translateLayout(key);
// Check whether name can be encoded in the buffer encoding
bool encodable = true;
- for (size_t i = 0; i < name.size(); ++i) {
- if (!enc.encodable(name[i])) {
+ for (size_t i = 0; i < name.size() && encodable; ++i)
+ if (!testenc->encodable(name[i]))
encodable = false;
- break;
- }
- }
- string const translated = encodable ? to_utf8(name)
- : "\\inputencoding{" + texenc + "}"
- + s1 + langenc + s2 + to_utf8(name)
- + s1 + bufenc + s2;
+ string translated;
+ if (encodable && !lang_fallback)
+ translated = to_utf8(name);
+ else if (ascii_fallback)
+ translated = to_ascii(testenc->latexString(name).first);
+ else
+ translated = "\\inputencoding{" + texenc + "}"
+ + s1 + langenc + s2 + to_utf8(name)
+ + s1 + bufenc + s2;
preamble = subst(preamble, sub.str(), translated);
}
return from_utf8(preamble);
snippets.insert(i18npreamble(tclass[*cit].langpreamble(),
buffer().language(),
buffer().params().encoding(),
- use_polyglossia));
+ use_polyglossia, false));
// commands for language changing (for multilanguage documents)
if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
snippets.insert(i18npreamble(
tclass[*cit].babelpreamble(),
buffer().language(),
buffer().params().encoding(),
- use_polyglossia));
+ use_polyglossia, false));
for (lang_it lit = lbeg; lit != lend; ++lit)
snippets.insert(i18npreamble(
tclass[*cit].babelpreamble(),
*lit,
buffer().params().encoding(),
- use_polyglossia));
+ use_polyglossia, false));
}
}
if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
TextClass::InsetLayouts::const_iterator it = ils.find(*cit);
if (it == ils.end())
continue;
+ // The listings package does not work with variable width
+ // encodings, only with fixed width encodings. Therefore we
+ // need to force a fixed width encoding for
+ // \lstlistlistingname and \lstlistingname (bug 9382).
+ // This needs to be consistent with InsetListings::latex().
+ bool const need_fixedwidth = !runparams_.isFullUnicode() &&
+ it->second.fixedwidthpreambleencoding();
// language dependent commands (once per document)
snippets.insert(i18npreamble(it->second.langpreamble(),
buffer().language(),
buffer().params().encoding(),
- use_polyglossia));
+ use_polyglossia, need_fixedwidth));
// commands for language changing (for multilanguage documents)
if ((use_babel || use_polyglossia) && !UsedLanguages_.empty()) {
snippets.insert(i18npreamble(
it->second.babelpreamble(),
buffer().language(),
buffer().params().encoding(),
- use_polyglossia));
+ use_polyglossia, need_fixedwidth));
for (lang_it lit = lbeg; lit != lend; ++lit)
snippets.insert(i18npreamble(
it->second.babelpreamble(),
*lit,
buffer().params().encoding(),
- use_polyglossia));
+ use_polyglossia, need_fixedwidth));
}
}
vector<string> const alternatives = getVectorFromString(*it, "|");
vector<string>::const_iterator const end = alternatives.end();
vector<string>::const_iterator ita = alternatives.begin();
+ // Is any alternative already required? => use that
for (; ita != end; ++ita) {
if (isRequired(*ita))
break;
}
+ // Is any alternative available? => use the first one
+ // (bug 9498)
+ if (ita == end) {
+ for (ita = alternatives.begin(); ita != end; ++ita) {
+ if (isAvailable(*ita)) {
+ require(*ita);
+ break;
+ }
+ }
+ }
+ // This will not work, but not requiring something
+ // would be more confusing
if (ita == end)
require(alternatives.front());
features_.erase(it);