X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathSupport.cpp;h=55b0822068f1c31f725e45f3308008e76c418d8f;hb=38c2cde0d8695ac5287bae218c4a33a2acf18ef8;hp=8f3aacb66b55503e3424677f0cec655247f98ac7;hpb=f497296c30e6da2f97b16da8ad1c9e96feffb16b;p=lyx.git diff --git a/src/mathed/MathSupport.cpp b/src/mathed/MathSupport.cpp index 8f3aacb66b..55b0822068 100644 --- a/src/mathed/MathSupport.cpp +++ b/src/mathed/MathSupport.cpp @@ -4,7 +4,7 @@ * Licence details can be found in the file COPYING. * * \author Alejandro Aguilar Sierra - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ @@ -12,30 +12,36 @@ #include #include "MathSupport.h" + +#include "InsetMathFont.h" +#include "InsetMathSymbol.h" +#include "Length.h" #include "MathData.h" -#include "InsetMath.h" -#include "MathStream.h" +#include "MathFactory.h" #include "MathParser.h" +#include "MathStream.h" -#include "debug.h" -#include "LColor.h" +#include "LaTeXFeatures.h" +#include "MetricsInfo.h" #include "frontends/FontLoader.h" #include "frontends/FontMetrics.h" #include "frontends/Painter.h" +#include "support/debug.h" +#include "support/docstream.h" +#include "support/lassert.h" +#include "support/lyxlib.h" + #include -#include +#include +using namespace std; namespace lyx { using frontend::Painter; -using std::max; -using std::endl; -using std::vector; - /// class Matrix { @@ -76,6 +82,7 @@ namespace { /* * Internal struct of a drawing: code n x1 y1 ... xn yn, where code is: * 0 = end, 1 = line, 2 = polyline, 3 = square line, 4 = square polyline + * 5 = rounded thick line (i.e. dot for short line) */ @@ -114,6 +121,95 @@ double const brace[] = { }; +double const mapsto[] = { + 2, 3, + 0.75, 0.015, 0.95, 0.5, 0.75, 0.985, + 1, 0.015, 0.475, 0.945, 0.475, + 1, 0.015, 0.015, 0.015, 0.985, + 0 +}; + + +double const lhook[] = { + 2, 3, + 0.25, 0.015, 0.05, 0.5, 0.25, 0.985, + 1, 0.015, 0.475, 0.7, 0.475, + 2, 5, + 0.7, 0.015, 0.825, 0.15, 0.985, 0.25, + 0.825, 0.35, 0.7, 0.475, + 0 +}; + + +double const rhook[] = { + 2, 3, + 0.75, 0.015, 0.95, 0.5, 0.75, 0.985, + 1, 0.3, 0.475, 0.985, 0.475, + 2, 5, + 0.3, 0.015, 0.175, 0.15, 0.05, 0.25, + 0.175, 0.35, 0.3, 0.475, + 0 +}; + + +double const LRArrow[] = { + 2, 3, + 0.25, 0.015, 0.05, 0.5, 0.25, 0.985, + 2, 3, + 0.75, 0.015, 0.95, 0.5, 0.75, 0.985, + 1, 0.2, 0.8, 0.8, 0.8, + 1, 0.2, 0.2, 0.8, 0.2, + 0 +}; + + +double const LArrow[] = { + 2, 3, + 0.25, 0.015, 0.05, 0.5, 0.25, 0.985, + 1, 0.2, 0.8, 0.985, 0.8, + 1, 0.2, 0.2, 0.985, 0.2, + 0 +}; + + +double const lharpoondown[] = { + 2, 2, + 0.015, 0.5, 0.25, 0.985, + 1, 0.02, 0.475, 0.985, 0.475, + 0 +}; + + +double const lharpoonup[] = { + 2, 2, + 0.25, 0.015, 0.015, 0.5, + 1, 0.02, 0.525, 0.985, 0.525, + 0 +}; + + +double const lrharpoons[] = { + 2, 2, + 0.25, 0.015, 0.015, 0.225, + 1, 0.02, 0.23, 0.985, 0.23, + 2, 2, + 0.75, 0.985, 0.985, 0.775, + 1, 0.02, 0.7, 0.980, 0.7, + 0 +}; + + +double const rlharpoons[] = { + 2, 2, + 0.75, 0.015, 0.985, 0.225, + 1, 0.02, 0.23, 0.985, 0.23, + 2, 2, + 0.25, 0.985, 0.015, 0.775, + 1, 0.02, 0.7, 0.980, 0.7, + 0 +}; + + double const arrow[] = { 4, 7, 0.0150, 0.7500, 0.2000, 0.6000, 0.3500, 0.3500, @@ -140,7 +236,7 @@ double const udarrow[] = { 0.015, 0.25, 0.5, 0.05, 0.95, 0.25, 2, 3, 0.015, 0.75, 0.5, 0.95, 0.95, 0.75, - 1, 0.5, 0.2, 0.5, 0.8, + 1, 0.5, 0.1, 0.5, 0.9, 0 }; @@ -163,6 +259,15 @@ double const brack[] = { }; +double const dbrack[] = { + 2, 4, + 0.95, 0.05, 0.05, 0.05, 0.05, 0.95, 0.95, 0.95, + 2, 2, + 0.50, 0.05, 0.50, 0.95, + 0 +}; + + double const corner[] = { 2, 3, 0.95, 0.05, 0.05, 0.05, 0.05, 0.95, @@ -189,17 +294,35 @@ double const hline[] = { }; +double const dot[] = { +// 1, 0.5, 0.2, 0.5, 0.2, +// 1, 0.4, 0.4, 0.6, 0.4, +// 1, 0.5, 0.5, 0.5, 0.5, + 5, 0.4, 0.4, 0.6, 0.4, + 0 +}; + + double const ddot[] = { - 1, 0.2, 0.5, 0.3, 0.5, - 1, 0.7, 0.5, 0.8, 0.5, + 5, 0.0, 0.4, 0.3, 0.4, + 5, 0.6, 0.4, 1.0, 0.4, 0 }; double const dddot[] = { - 1, 0.1, 0.5, 0.2, 0.5, + 1, 0.1, 0.5, 0.2, 0.5, + 1, 0.45, 0.5, 0.55, 0.5, + 1, 0.8, 0.5, 0.9, 0.5, + 0 +}; + + +double const ddddot[] = { + 1, 0.1, 0.5, 0.2, 0.5, 1, 0.45, 0.5, 0.55, 0.5, - 1, 0.8, 0.5, 0.9, 0.5, + 1, 0.8, 0.5, 0.9, 0.5, + 1, 1.15, 0.5, 1.25, 0.5, 0 }; @@ -220,12 +343,6 @@ double const dline3[] = { }; -double const hlinesmall[] = { - 1, 0.4, 0.5, 0.6, 0.5, - 0 -}; - - double const ring[] = { 2, 5, 0.5, 0.8, 0.8, 0.5, 0.5, 0.2, 0.2, 0.5, 0.5, 0.8, @@ -266,21 +383,36 @@ struct named_deco_struct { named_deco_struct deco_table[] = { // Decorations - {"widehat", angle, 3 }, - {"widetilde", tilde, 0 }, - {"underbar", hline, 0 }, - {"underline", hline, 0 }, - {"overline", hline, 0 }, - {"underbrace", brace, 1 }, - {"overbrace", brace, 3 }, - {"overleftarrow", arrow, 1 }, - {"overrightarrow", arrow, 3 }, - {"overleftrightarrow", udarrow, 1 }, - {"xleftarrow", arrow, 1 }, - {"xrightarrow", arrow, 3 }, - {"underleftarrow", arrow, 1 }, - {"underrightarrow", arrow, 3 }, - {"underleftrightarrow", udarrow, 1 }, + {"widehat", angle, 3 }, + {"widetilde", tilde, 0 }, + {"underbar", hline, 0 }, + {"underline", hline, 0 }, + {"overline", hline, 0 }, + {"underbrace", brace, 1 }, + {"overbrace", brace, 3 }, + {"overleftarrow", arrow, 1 }, + {"overrightarrow", arrow, 3 }, + {"overleftrightarrow", udarrow, 1 }, + {"xhookleftarrow", lhook, 0 }, + {"xhookrightarrow", rhook, 0 }, + {"xleftarrow", arrow, 1 }, + {"xLeftarrow", LArrow, 0 }, + {"xleftharpoondown", lharpoondown, 0 }, + {"xleftharpoonup", lharpoonup, 0 }, + {"xleftrightharpoons", lrharpoons, 0 }, + {"xleftrightarrow", udarrow, 1 }, + {"xLeftrightarrow", LRArrow, 0 }, + {"xmapsto", mapsto, 0 }, + {"xrightarrow", arrow, 3 }, + {"xRightarrow", LArrow, 2 }, + {"xrightharpoondown", lharpoonup, 2 }, + {"xrightharpoonup", lharpoondown, 2 }, + {"xrightleftharpoons", rlharpoons, 0 }, + {"underleftarrow", arrow, 1 }, + {"underrightarrow", arrow, 3 }, + {"underleftrightarrow", udarrow, 1 }, + {"undertilde", tilde, 0 }, + {"utilde", tilde, 0 }, // Delimiters {"(", parenth, 0 }, @@ -291,12 +423,20 @@ named_deco_struct deco_table[] = { {"rbrace", brace, 2 }, {"[", brack, 0 }, {"]", brack, 2 }, + {"llbracket", dbrack, 0 }, + {"rrbracket", dbrack, 2 }, {"|", vert, 0 }, {"/", slash, 0 }, {"slash", slash, 0 }, {"vert", vert, 0 }, + {"lvert", vert, 0 }, + {"rvert", vert, 0 }, {"Vert", Vert, 0 }, + {"lVert", Vert, 0 }, + {"rVert", Vert, 0 }, {"'", slash, 1 }, + {"<", angle, 0 }, + {">", angle, 2 }, {"\\", slash, 1 }, {"backslash", slash, 1 }, {"langle", angle, 0 }, @@ -315,12 +455,13 @@ named_deco_struct deco_table[] = { // Accents {"ddot", ddot, 0 }, {"dddot", dddot, 0 }, + {"ddddot", ddddot, 0 }, {"hat", angle, 3 }, {"grave", slash, 1 }, {"acute", slash, 0 }, {"tilde", tilde, 0 }, {"bar", hline, 0 }, - {"dot", hlinesmall, 0 }, + {"dot", dot, 0 }, {"check", angle, 1 }, {"breve", parenth, 1 }, {"vec", arrow, 3 }, @@ -332,6 +473,8 @@ named_deco_struct deco_table[] = { {"cdots", hline3, 0 }, {"vdots", hline3, 1 }, {"ddots", dline3, 0 }, + {"adots", dline3, 1 }, + {"iddots", dline3, 1 }, {"dotsb", hline3, 0 }, {"dotsc", hline3, 0 }, {"dotsi", hline3, 0 }, @@ -340,7 +483,7 @@ named_deco_struct deco_table[] = { }; -std::map deco_list; +map deco_list; // sort the table on startup class init_deco_table { @@ -356,33 +499,78 @@ public: } }; -static init_deco_table dummy; +static init_deco_table dummy_deco_table; deco_struct const * search_deco(docstring const & name) { - std::map::const_iterator p = deco_list.find(name); + map::const_iterator p = deco_list.find(name); return p == deco_list.end() ? 0 : &(p->second); } -} // namespace anon +} // namespace + + +int mathed_font_em(FontInfo const & font) +{ + return theFontMetrics(font).em(); +} + + +int mathed_font_x_height(FontInfo const & font) +{ + return theFontMetrics(font).xHeight(); +} + +/* The math units. Quoting TeX by Topic, p.205: + * + * Spacing around mathematical objects is measured in mu units. A mu + * is 1/18th part of \fontdimen6 of the font in family 2 in the + * current style, the ‘quad’ value of the symbol font. + * + * A \thickmuskip (default value in plain TeX: 5mu plus 5mu) is + * inserted around (binary) relations, except where these are preceded + * or followed by other relations or punctuation, and except if they + * follow an open, or precede a close symbol. + * + * A \medmuskip (default value in plain TeX: 4mu plus 2mu minus 4mu) + * is put around binary operators. + * + * A \thinmuskip (default value in plain TeX: 3mu) follows after + * punctuation, and is put around inner objects, except where these + * are followed by a close or preceded by an open symbol, and except + * if the other object is a large operator or a binary relation. + * + * See the file MathClass.cpp for a formal implementation of the rules + * above. + */ + +int mathed_mu(FontInfo const & font, double mu) +{ + MetricsBase mb(nullptr, font); + return mb.inPixels(Length(mu, Length::MU)); +} + +int mathed_thinmuskip(FontInfo const & font) { return mathed_mu(font, 3.0); } +int mathed_medmuskip(FontInfo const & font) { return mathed_mu(font, 4.0); } +int mathed_thickmuskip(FontInfo const & font) { return mathed_mu(font, 5.0); } -int mathed_char_width(LyXFont const & font, char_type c) +int mathed_char_width(FontInfo const & font, char_type c) { return theFontMetrics(font).width(c); } -int mathed_char_kerning(LyXFont const & font, char_type c) +int mathed_char_kerning(FontInfo const & font, char_type c) { frontend::FontMetrics const & fm = theFontMetrics(font); - return fm.rbearing(c) - fm.width(c); + return max(0, fm.rbearing(c) - fm.width(c)); } -void mathed_string_dim(LyXFont const & font, +void mathed_string_dim(FontInfo const & font, docstring const & s, Dimension & dim) { @@ -399,7 +587,7 @@ void mathed_string_dim(LyXFont const & font, } -int mathed_string_width(LyXFont const & font, docstring const & s) +int mathed_string_width(FontInfo const & font, docstring const & s) { return theFontMetrics(font).width(s); } @@ -410,7 +598,7 @@ void mathed_draw_deco(PainterInfo & pi, int x, int y, int w, int h, { if (name == ".") { pi.pain.line(x + w/2, y, x + w/2, y + h, - LColor::cursor, Painter::line_onoffdash); + Color_cursor, Painter::line_onoffdash); return; } @@ -439,7 +627,7 @@ void mathed_draw_deco(PainterInfo & pi, int x, int y, int w, int h, for (int i = 0; d[i]; ) { int code = int(d[i++]); - if (code & 1) { // code == 1 || code == 3 + if (code & 1) { // code == 1 || code == 3 || code == 5 double xx = d[i++]; double yy = d[i++]; double x2 = d[i++]; @@ -452,12 +640,22 @@ void mathed_draw_deco(PainterInfo & pi, int x, int y, int w, int h, pi.pain.line( int(x + xx + 0.5), int(y + yy + 0.5), int(x + x2 + 0.5), int(y + y2 + 0.5), - LColor::math); + pi.base.font.color()); + if (code == 5) { // thicker, but rounded + pi.pain.line( + int(x + xx + 0.5+1), int(y + yy + 0.5-1), + int(x + x2 + 0.5-1), int(y + y2 + 0.5-1), + pi.base.font.color()); + pi.pain.line( + int(x + xx + 0.5+1), int(y + yy + 0.5+1), + int(x + x2 + 0.5-1), int(y + y2 + 0.5+1), + pi.base.font.color()); + } } else { int xp[32]; int yp[32]; - int const n = int(d[i++]); - for (int j = 0; j < n; ++j) { + int const n2 = int(d[i++]); + for (int j = 0; j < n2; ++j) { double xx = d[i++]; double yy = d[i++]; // lyxerr << ' ' << xx << ' ' << yy << ' '; @@ -469,29 +667,74 @@ void mathed_draw_deco(PainterInfo & pi, int x, int y, int w, int h, yp[j] = int(y + yy + 0.5); // lyxerr << "P[" << j ' ' << xx << ' ' << yy << ' ' << x << ' ' << y << ']'; } - pi.pain.lines(xp, yp, n, LColor::math); + pi.pain.lines(xp, yp, n2, pi.base.font.color()); } } } +void mathedSymbolDim(MetricsBase & mb, Dimension & dim, latexkeys const * sym) +{ + LASSERT((bool)sym, return); + //lyxerr << "metrics: symbol: '" << sym->name + // << "' in font: '" << sym->inset + // << "' drawn as: '" << sym->draw + // << "'" << endl; + + bool const italic_upcase_greek = sym->inset == "cmr" && + sym->extra == "mathalpha" && + mb.fontname == "mathit"; + std::string const font = italic_upcase_greek ? "cmm" : sym->inset; + Changer dummy = mb.changeFontSet(font); + mathed_string_dim(mb.font, sym->draw, dim); +} + + +void mathedSymbolDraw(PainterInfo & pi, int x, int y, latexkeys const * sym) +{ + LASSERT((bool)sym, return); + //lyxerr << "drawing: symbol: '" << sym->name + // << "' in font: '" << sym->inset + // << "' drawn as: '" << sym->draw + // << "'" << endl; + + bool const italic_upcase_greek = sym->inset == "cmr" && + sym->extra == "mathalpha" && + pi.base.fontname == "mathit"; + std::string const font = italic_upcase_greek ? "cmm" : sym->inset; + + Changer dummy = pi.base.changeFontSet(font); + pi.draw(x, y, sym->draw); +} + + +void metricsStrRedBlack(MetricsInfo & mi, Dimension & dim, docstring const & str) +{ + FontInfo font = mi.base.font; + augmentFont(font, "mathnormal"); + mathed_string_dim(font, str, dim); +} + + void drawStrRed(PainterInfo & pi, int x, int y, docstring const & str) { - LyXFont f = pi.base.font; - f.setColor(LColor::latex); + FontInfo f = pi.base.font; + augmentFont(f, "mathnormal"); + f.setColor(Color_latex); pi.pain.text(x, y, str, f); } void drawStrBlack(PainterInfo & pi, int x, int y, docstring const & str) { - LyXFont f = pi.base.font; - f.setColor(LColor::foreground); + FontInfo f = pi.base.font; + augmentFont(f, "mathnormal"); + f.setColor(Color_foreground); pi.pain.text(x, y, str, f); } -void math_font_max_dim(LyXFont const & font, int & asc, int & des) +void math_font_max_dim(FontInfo const & font, int & asc, int & des) { frontend::FontMetrics const & fm = theFontMetrics(font); asc = fm.maxAscent(); @@ -500,113 +743,126 @@ void math_font_max_dim(LyXFont const & font, int & asc, int & des) struct fontinfo { - std::string cmd_; - LyXFont::FONT_FAMILY family_; - LyXFont::FONT_SERIES series_; - LyXFont::FONT_SHAPE shape_; - LColor::color color_; + string cmd_; + FontFamily family_; + FontSeries series_; + FontShape shape_; + ColorCode color_; }; -LyXFont::FONT_FAMILY const inh_family = LyXFont::INHERIT_FAMILY; -LyXFont::FONT_SERIES const inh_series = LyXFont::INHERIT_SERIES; -LyXFont::FONT_SHAPE const inh_shape = LyXFont::INHERIT_SHAPE; +FontFamily const inh_family = INHERIT_FAMILY; +FontSeries const inh_series = INHERIT_SERIES; +FontShape const inh_shape = INHERIT_SHAPE; // mathnormal should be the first, otherwise the fallback further down // does not work fontinfo fontinfos[] = { // math fonts - {"mathnormal", LyXFont::ROMAN_FAMILY, LyXFont::MEDIUM_SERIES, - LyXFont::ITALIC_SHAPE, LColor::math}, - {"mathbf", inh_family, LyXFont::BOLD_SERIES, - inh_shape, LColor::math}, - {"mathcal", LyXFont::CMSY_FAMILY, inh_series, - inh_shape, LColor::math}, - {"mathfrak", LyXFont::EUFRAK_FAMILY, inh_series, - inh_shape, LColor::math}, - {"mathrm", LyXFont::ROMAN_FAMILY, inh_series, - LyXFont::UP_SHAPE, LColor::math}, - {"mathsf", LyXFont::SANS_FAMILY, inh_series, - inh_shape, LColor::math}, - {"mathbb", LyXFont::MSB_FAMILY, inh_series, - inh_shape, LColor::math}, - {"mathtt", LyXFont::TYPEWRITER_FAMILY, inh_series, - inh_shape, LColor::math}, + // Color_math determines which fonts are math (see isMathFont) + {"mathnormal", ROMAN_FAMILY, MEDIUM_SERIES, + ITALIC_SHAPE, Color_math}, + {"mathbf", inh_family, BOLD_SERIES, + inh_shape, Color_math}, + {"mathcal", CMSY_FAMILY, inh_series, + inh_shape, Color_math}, + {"mathfrak", EUFRAK_FAMILY, inh_series, + inh_shape, Color_math}, + {"mathrm", ROMAN_FAMILY, inh_series, + UP_SHAPE, Color_math}, + {"mathsf", SANS_FAMILY, inh_series, + inh_shape, Color_math}, + {"mathbb", MSB_FAMILY, inh_series, + inh_shape, Color_math}, + {"mathtt", TYPEWRITER_FAMILY, inh_series, + inh_shape, Color_math}, {"mathit", inh_family, inh_series, - LyXFont::ITALIC_SHAPE, LColor::math}, - {"cmex", LyXFont::CMEX_FAMILY, inh_series, - inh_shape, LColor::math}, - {"cmm", LyXFont::CMM_FAMILY, inh_series, - inh_shape, LColor::math}, - {"cmr", LyXFont::CMR_FAMILY, inh_series, - inh_shape, LColor::math}, - {"cmsy", LyXFont::CMSY_FAMILY, inh_series, - inh_shape, LColor::math}, - {"eufrak", LyXFont::EUFRAK_FAMILY, inh_series, - inh_shape, LColor::math}, - {"msa", LyXFont::MSA_FAMILY, inh_series, - inh_shape, LColor::math}, - {"msb", LyXFont::MSB_FAMILY, inh_series, - inh_shape, LColor::math}, - {"wasy", LyXFont::WASY_FAMILY, inh_series, - inh_shape, LColor::none}, - {"esint", LyXFont::ESINT_FAMILY, inh_series, - inh_shape, LColor::none}, + ITALIC_SHAPE, Color_math}, + {"mathscr", RSFS_FAMILY, inh_series, + inh_shape, Color_math}, + {"cmex", CMEX_FAMILY, inh_series, + inh_shape, Color_math}, + {"cmm", CMM_FAMILY, inh_series, + inh_shape, Color_math}, + {"cmr", CMR_FAMILY, inh_series, + inh_shape, Color_math}, + {"cmsy", CMSY_FAMILY, inh_series, + inh_shape, Color_math}, + {"eufrak", EUFRAK_FAMILY, inh_series, + inh_shape, Color_math}, + {"msa", MSA_FAMILY, inh_series, + inh_shape, Color_math}, + {"msb", MSB_FAMILY, inh_series, + inh_shape, Color_math}, + {"stmry", STMARY_FAMILY, inh_series, + inh_shape, Color_math}, + {"wasy", WASY_FAMILY, inh_series, + inh_shape, Color_math}, + {"esint", ESINT_FAMILY, inh_series, + inh_shape, Color_math}, // Text fonts {"text", inh_family, inh_series, - inh_shape, LColor::foreground}, - {"textbf", inh_family, LyXFont::BOLD_SERIES, - inh_shape, LColor::foreground}, + inh_shape, Color_foreground}, + {"textbf", inh_family, BOLD_SERIES, + inh_shape, Color_foreground}, {"textit", inh_family, inh_series, - LyXFont::ITALIC_SHAPE, LColor::foreground}, - {"textmd", inh_family, LyXFont::MEDIUM_SERIES, - inh_shape, LColor::foreground}, + ITALIC_SHAPE, Color_foreground}, + {"textmd", inh_family, MEDIUM_SERIES, + inh_shape, Color_foreground}, {"textnormal", inh_family, inh_series, - LyXFont::UP_SHAPE, LColor::foreground}, - {"textrm", LyXFont::ROMAN_FAMILY, - inh_series, LyXFont::UP_SHAPE,LColor::foreground}, + UP_SHAPE, Color_foreground}, + {"textrm", ROMAN_FAMILY, + inh_series, UP_SHAPE,Color_foreground}, {"textsc", inh_family, inh_series, - LyXFont::SMALLCAPS_SHAPE, LColor::foreground}, - {"textsf", LyXFont::SANS_FAMILY, inh_series, - inh_shape, LColor::foreground}, + SMALLCAPS_SHAPE, Color_foreground}, + {"textsf", SANS_FAMILY, inh_series, + inh_shape, Color_foreground}, {"textsl", inh_family, inh_series, - LyXFont::SLANTED_SHAPE, LColor::foreground}, - {"texttt", LyXFont::TYPEWRITER_FAMILY, inh_series, - inh_shape, LColor::foreground}, + SLANTED_SHAPE, Color_foreground}, + {"texttt", TYPEWRITER_FAMILY, inh_series, + inh_shape, Color_foreground}, {"textup", inh_family, inh_series, - LyXFont::UP_SHAPE, LColor::foreground}, + UP_SHAPE, Color_foreground}, // TIPA support {"textipa", inh_family, inh_series, - inh_shape, LColor::foreground}, + inh_shape, Color_foreground}, + + // mhchem support + {"ce", inh_family, inh_series, + inh_shape, Color_foreground}, + {"cf", inh_family, inh_series, + inh_shape, Color_foreground}, // LyX internal usage {"lyxtex", inh_family, inh_series, - LyXFont::UP_SHAPE, LColor::latex}, - {"lyxsymbol", LyXFont::SYMBOL_FAMILY, inh_series, - inh_shape, LColor::math}, - {"lyxboldsymbol", LyXFont::SYMBOL_FAMILY, LyXFont::BOLD_SERIES, - inh_shape, LColor::math}, - {"lyxblacktext", LyXFont::ROMAN_FAMILY, LyXFont::MEDIUM_SERIES, - LyXFont::UP_SHAPE, LColor::foreground}, + UP_SHAPE, Color_latex}, + // FIXME: The following two don't work on OS X, since the Symbol font + // uses a different encoding, and is therefore disabled in + // FontLoader::available(). + {"lyxsymbol", SYMBOL_FAMILY, inh_series, + inh_shape, Color_math}, + {"lyxboldsymbol", SYMBOL_FAMILY, BOLD_SERIES, + inh_shape, Color_math}, + {"lyxblacktext", ROMAN_FAMILY, MEDIUM_SERIES, + UP_SHAPE, Color_foreground}, {"lyxnochange", inh_family, inh_series, - inh_shape, LColor::foreground}, - {"lyxfakebb", LyXFont::TYPEWRITER_FAMILY, LyXFont::BOLD_SERIES, - LyXFont::UP_SHAPE, LColor::math}, - {"lyxfakecal", LyXFont::SANS_FAMILY, LyXFont::MEDIUM_SERIES, - LyXFont::ITALIC_SHAPE, LColor::math}, - {"lyxfakefrak", LyXFont::ROMAN_FAMILY, LyXFont::BOLD_SERIES, - LyXFont::ITALIC_SHAPE, LColor::math} + inh_shape, Color_foreground}, + {"lyxfakebb", TYPEWRITER_FAMILY, BOLD_SERIES, + UP_SHAPE, Color_math}, + {"lyxfakecal", SANS_FAMILY, MEDIUM_SERIES, + ITALIC_SHAPE, Color_math}, + {"lyxfakefrak", ROMAN_FAMILY, BOLD_SERIES, + ITALIC_SHAPE, Color_math} }; -fontinfo * lookupFont(docstring const & name0) +fontinfo * lookupFont(string const & name) { //lyxerr << "searching font '" << name << "'" << endl; int const n = sizeof(fontinfos) / sizeof(fontinfo); - std::string name = to_utf8(name0); for (int i = 0; i < n; ++i) if (fontinfos[i].cmd_ == name) { //lyxerr << "found '" << i << "'" << endl; @@ -616,7 +872,7 @@ fontinfo * lookupFont(docstring const & name0) } -fontinfo * searchFont(docstring const & name) +fontinfo * searchFont(string const & name) { fontinfo * f = lookupFont(name); return f ? f : fontinfos; @@ -625,21 +881,35 @@ fontinfo * searchFont(docstring const & name) } -bool isFontName(docstring const & name) +bool isFontName(string const & name) { return lookupFont(name); } -LyXFont getFont(docstring const & name) +bool isMathFont(string const & name) +{ + fontinfo * f = lookupFont(name); + return f && f->color_ == Color_math; +} + + +bool isTextFont(string const & name) +{ + fontinfo * f = lookupFont(name); + return f && f->color_ == Color_foreground; +} + + +FontInfo getFont(string const & name) { - LyXFont font; + FontInfo font; augmentFont(font, name); return font; } -void fakeFont(docstring const & orig, docstring const & fake) +void fakeFont(string const & orig, string const & fake) { fontinfo * forig = searchFont(orig); fontinfo * ffake = searchFont(fake); @@ -649,22 +919,22 @@ void fakeFont(docstring const & orig, docstring const & fake) forig->shape_ = ffake->shape_; forig->color_ = ffake->color_; } else { - lyxerr << "Can't fake font '" << to_utf8(orig) << "' with '" - << to_utf8(fake) << "'" << endl; + lyxerr << "Can't fake font '" << orig << "' with '" + << fake << "'" << endl; } } -void augmentFont(LyXFont & font, docstring const & name) +void augmentFont(FontInfo & font, string const & name) { static bool initialized = false; if (!initialized) { initialized = true; // fake fonts if necessary - if (!theFontLoader().available(getFont(from_ascii("mathfrak")))) - fakeFont(from_ascii("mathfrak"), from_ascii("lyxfakefrak")); - if (!theFontLoader().available(getFont(from_ascii("mathcal")))) - fakeFont(from_ascii("mathcal"), from_ascii("lyxfakecal")); + if (!theFontLoader().available(getFont("mathfrak"))) + fakeFont("mathfrak", "lyxfakefrak"); + if (!theFontLoader().available(getFont("mathcal"))) + fakeFont("mathcal", "lyxfakecal"); } fontinfo * info = searchFont(name); if (info->family_ != inh_family) @@ -673,30 +943,60 @@ void augmentFont(LyXFont & font, docstring const & name) font.setSeries(info->series_); if (info->shape_ != inh_shape) font.setShape(info->shape_); - if (info->color_ != LColor::none) + if (info->color_ != Color_none) font.setColor(info->color_); } -docstring asString(MathArray const & ar) +bool isAlphaSymbol(MathAtom const & at) +{ + if (at->asCharInset() || + (at->asSymbolInset() && + at->asSymbolInset()->isOrdAlpha())) + return true; + + if (at->asFontInset()) { + MathData const & ar = at->asFontInset()->cell(0); + for (size_t i = 0; i < ar.size(); ++i) { + if (!(ar[i]->asCharInset() || + (ar[i]->asSymbolInset() && + ar[i]->asSymbolInset()->isOrdAlpha()))) + return false; + } + return true; + } + return false; +} + + +docstring asString(MathData const & ar) { odocstringstream os; - WriteStream ws(os); + otexrowstream ots(os); + WriteStream ws(ots); ws << ar; return os.str(); } -void asArray(docstring const & str, MathArray & ar) +void asArray(docstring const & str, MathData & ar, Parse::flags pf) { - mathed_parse_cell(ar, str); + // If the QUIET flag is set, we are going to parse for either + // a paste operation or a macro definition. We try to do the + // right thing in all cases. + + bool quiet = pf & Parse::QUIET; + bool macro = pf & Parse::MACRODEF; + if ((str.size() == 1 && quiet) || (!mathed_parse_cell(ar, str, pf) && quiet && !macro)) + mathed_parse_cell(ar, str, pf | Parse::VERBATIM); } docstring asString(InsetMath const & inset) { odocstringstream os; - WriteStream ws(os); + otexrowstream ots(os); + WriteStream ws(ots); inset.write(ws); return os.str(); } @@ -705,10 +1005,30 @@ docstring asString(InsetMath const & inset) docstring asString(MathAtom const & at) { odocstringstream os; - WriteStream ws(os); + otexrowstream ots(os); + WriteStream ws(ots); at->write(ws); return os.str(); } +int axis_height(MetricsBase & mb) +{ + Changer dummy = mb.changeFontSet("mathnormal"); + return theFontMetrics(mb.font).ascent('-') - 1; +} + + +void validate_math_word(LaTeXFeatures & features, docstring const & word) +{ + MathWordList const & words = mathedWordList(); + MathWordList::const_iterator it = words.find(word); + if (it != words.end()) { + string const req = it->second.required; + if (!req.empty()) + features.require(req); + } +} + + } // namespace lyx