void InsetMathSubstack::validate(LaTeXFeatures & features) const
{
if (features.runparams().isLaTeX())
features.require("amsmath");
else if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addCSSSnippet(
"span.substack{display: inline-block; vertical-align: middle; text-align:center; font-size: 75%;}\n"
"span.substack span{display: block;}");
InsetMathGrid::validate(features);
}
void InsetMathEnsureMath::validate(LaTeXFeatures & features) const
{
// FIXME XHTML
// It'd be better to be able to get this from an InsetLayout, but at present
// InsetLayouts do not seem really to work for things that aren't InsetTexts.
if (features.runparams().math_flavor == OutputParams::MathAsMathML)
features.addCSSSnippet("mstyle.math { font-style: italic; }");
else if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addCSSSnippet("span.mathbox { font-style: italic; }");
InsetMathNest::validate(features);
}
void InsetMathUnderset::validate(LaTeXFeatures & features) const
{
if (features.runparams().isLaTeX())
features.require("amsmath");
else if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.underset{display: inline-block; vertical-align: top; text-align:center;}\n"
"span.underset span {display: block;}\n"
"span.bottom{font-size: 66%;}\n"
"</style>");
InsetMathNest::validate(features);
}
void InsetMathBinom::validate(LaTeXFeatures & features) const
{
if (features.runparams().isLaTeX()) {
if (kind_ == BINOM)
features.require("binom");
if (kind_ == DBINOM || kind_ == TBINOM)
features.require("amsmath");
} else if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.binom{display: inline-block; vertical-align: bottom; text-align:center;}\n"
"span.binom span{display: block;}\n"
"span.binomdelim{font-size: 2em;}\n"
"</style>");
InsetMathNest::validate(features);
}
void InsetRef::validate(LaTeXFeatures & features) const
{
string const cmd = getCmdName();
if (cmd == "vref" || cmd == "vpageref")
features.require("varioref");
else if (cmd == "formatted") {
docstring const data = getEscapedLabel(features.runparams());
docstring label;
docstring prefix;
string const fcmd = to_utf8(getFormattedCmd(data, label, prefix));
if (buffer().params().use_refstyle) {
features.require("refstyle");
if (prefix == "cha")
features.addPreambleSnippet("\\let\\charef=\\chapref");
else if (!prefix.empty()) {
string lcmd = "\\AtBeginDocument{\\providecommand" +
fcmd + "[1]{\\ref{" + to_utf8(prefix) + ":#1}}}";
features.addPreambleSnippet(lcmd);
}
} else {
features.require("prettyref");
// prettyref uses "cha" for chapters, so we provide a kind of
// translation.
if (prefix == "chap")
features.addPreambleSnippet("\\let\\pr@chap=\\pr@cha");
}
} else if (cmd == "eqref" && !buffer().params().use_refstyle)
// with refstyle, we simply output "(\ref{label})"
features.require("amsmath");
else if (cmd == "nameref")
features.require("nameref");
}
// ideas borrowed from the eLyXer code
void InsetMathDecoration::validate(LaTeXFeatures & features) const
{
if (features.runparams().math_flavor == OutputParams::MathAsHTML) {
string const name = to_utf8(key_->name);
if (name == "bar") {
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.overbar{border-top: thin black solid;}\n"
"</style>");
} else if (name == "underbar" || name == "underline") {
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.underbar{border-bottom: thin black solid;}\n"
"</style>");
} else {
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.symbolpair{display: inline-block; text-align:center;}\n"
"span.symontop{vertical-align: top;}\n"
"span.symonbot{vertical-align: bottom;}\n"
"span.symbolpair span{display: block;}\n"
"span.symbol{height: 0.5ex;}\n"
"</style>");
}
} else {
if (!key_->requires.empty())
features.require(to_utf8(key_->requires));
}
InsetMathNest::validate(features);
}
void InsetMathBig::validate(LaTeXFeatures & features) const
{
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addCSSSnippet(
"span.bigsymbol{font-size: 150%;}\n"
"span.biggsymbol{font-size: 200%;}\n"
"span.bigggsymbol{font-size: 225%;}");
}
void InsetMathSqrt::validate(LaTeXFeatures & features) const
{
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.sqrtof{border-top: thin solid black;}\n"
"</style>");
InsetMathNest::validate(features);
}
void InsetMathBig::validate(LaTeXFeatures & features) const
{
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.bigsymbol{font-size: 150%;}\n"
"span.biggsymbol{font-size: 200%;}\n"
"span.bigggsymbol{font-size: 225%;}\n"
"</style>");
}
void InsetMathSize::validate(LaTeXFeatures & features) const
{
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addCSSSnippet(
"span.displaystyle, span.textstyle{font-size: normal;}\n"
"span.scriptstyle {font-size: small;}\n"
"span.scriptscriptstyle {font-size: x-small;}");
InsetMathNest::validate(features);
}
void InsetMathXArrow::validate(LaTeXFeatures & features) const
{
features.require("amsmath");
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
// CSS adapted from eLyXer
features.addCSSSnippet(
"span.xarrow{display: inline-block; vertical-align: middle; text-align:center;}\n"
"span.xatop{display: block;}\n"
"span.xabottom{display: block;}");
InsetMathNest::validate(features);
}
void InsetMathCases::validate(LaTeXFeatures & features) const
{
features.require("amsmath");
InsetMathGrid::validate(features);
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
// CSS based on eLyXer's
features.addCSSSnippet(
"table.cases{display: inline-block; text-align: center;"
"border-left: thin solid black; vertical-align: middle; padding-left: 0.5ex;}\n"
"table.cases td {text-align: left;}");
}
void BufferEncodings::validate(char_type c, LaTeXFeatures & features, bool for_mathed)
{
CharInfo const & ci = Encodings::unicodeCharInfo(c);
if (ci.isUnicodeSymbol()) {
// In mathed, c could be used both in textmode and mathmode
docstring const textcommand = ci.textcommand();
bool const math_mode = for_mathed && isMathCmd(c);
bool const use_math = math_mode ||
(!for_mathed && textcommand.empty());
bool const use_text = (for_mathed && isTextCmd(c)) ||
(!for_mathed && !textcommand.empty());
bool const plain_utf8 = (features.runparams().encoding->name() == "utf8-plain");
bool const unicode_math = (features.isRequired("unicode-math")
&& features.isAvailable("unicode-math"));
// with utf8-plain, we only load packages when in mathed (see #7766)
// and if we do not use unicode-math
if ((math_mode && !unicode_math)
|| (use_math && !plain_utf8)) {
string const mathpreamble = ci.mathpreamble();
if (!mathpreamble.empty()) {
if (ci.mathfeature()) {
string feats = mathpreamble;
while (!feats.empty()) {
string feat;
feats = split(feats, feat, ',');
features.require(feat);
}
} else
features.addPreambleSnippet(mathpreamble);
}
}
// with utf8-plain, we do not load packages (see #7766)
if (use_text && !plain_utf8) {
string const textpreamble = ci.textpreamble();
if (!textpreamble.empty()) {
if (ci.textfeature()) {
string feats = textpreamble;
while (!feats.empty()) {
string feat;
feats = split(feats, feat, ',');
features.require(feat);
}
} else
features.addPreambleSnippet(textpreamble);
}
}
}
if (for_mathed && isMathSym(c)) {
features.require("amstext");
features.require("lyxmathsym");
}
}
void InsetMathFrac::validate(LaTeXFeatures & features) const
{
if (kind_ == NICEFRAC || kind_ == UNITFRAC || kind_ == UNIT)
features.require("units");
if (kind_ == CFRAC || kind_ == CFRACLEFT || kind_ == CFRACRIGHT
|| kind_ == DFRAC || kind_ == TFRAC)
features.require("amsmath");
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
// CSS adapted from eLyXer
features.addPreambleSnippet("<style type=\"text/css\">\n"
"span.frac{display: inline-block; vertical-align: middle; text-align:center;}\n"
"span.numer{display: block;}\n"
"span.denom{display: block; border-top: thin solid #000040;}\n"
"</style>");
InsetMathNest::validate(features);
}
void InsetMathSymbol::validate(LaTeXFeatures & features) const
{
// this is not really the ideal place to do this, but we can't
// validate in InsetMathExInt.
if (features.runparams().math_flavor == OutputParams::MathAsHTML
&& sym_->name == from_ascii("int")) {
features.addCSSSnippet(
"span.limits{display: inline-block; vertical-align: middle; text-align:center; font-size: 75%;}\n"
"span.limits span{display: block;}\n"
"span.intsym{font-size: 150%;}\n"
"sub.limit{font-size: 75%;}\n"
"sup.limit{font-size: 75%;}");
} else {
if (!sym_->requires.empty())
features.require(sym_->requires);
}
}
void InsetNote::validate(LaTeXFeatures & features) const
{
switch (params_.type) {
case InsetNoteParams::Comment:
features.require("verbatim");
if (features.runparams().flavor == OutputParams::HTML)
// we do output this but set display to "none" by default,
// but people might want to use it.
InsetCollapsable::validate(features);
break;
case InsetNoteParams::Greyedout:
features.require("color");
features.require("lyxgreyedout");
InsetCollapsable::validate(features);
break;
case InsetNoteParams::Note:
break;
}
}
void InsetMathSqrt::validate(LaTeXFeatures & features) const
{
if (features.runparams().math_flavor == OutputParams::MathAsHTML)
features.addCSSSnippet("span.sqrtof{border-top: thin solid black;}");
InsetMathNest::validate(features);
}