* 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.
*/
#include "MathSupport.h"
-#include "InsetMath.h"
+#include "InsetMathFont.h"
+#include "InsetMathSymbol.h"
#include "MathData.h"
#include "MathParser.h"
#include "MathStream.h"
-#include "debug.h"
-
-#include "support/docstream.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 <map>
-#include <sstream>
+#include <algorithm>
+using namespace std;
namespace lyx {
using frontend::Painter;
-using std::max;
-using std::endl;
-
///
class Matrix {
};
+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,
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
};
};
+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,
double const ddot[] = {
- 1, 0.2, 0.5, 0.3, 0.5,
- 1, 0.7, 0.5, 0.8, 0.5,
+ 1, 0.2, 0.5, 0.3, 0.5,
+ 1, 0.7, 0.5, 0.8, 0.5,
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
};
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 },
{"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 },
// Accents
{"ddot", ddot, 0 },
{"dddot", dddot, 0 },
+ {"ddddot", ddddot, 0 },
{"hat", angle, 3 },
{"grave", slash, 1 },
{"acute", slash, 0 },
{"cdots", hline3, 0 },
{"vdots", hline3, 1 },
{"ddots", dline3, 0 },
+ {"adots", dline3, 1 },
+ {"iddots", dline3, 1 },
{"dotsb", hline3, 0 },
{"dotsc", hline3, 0 },
{"dotsi", hline3, 0 },
};
-std::map<docstring, deco_struct> deco_list;
+map<docstring, deco_struct> deco_list;
// sort the table on startup
class init_deco_table {
deco_struct const * search_deco(docstring const & name)
{
- std::map<docstring, deco_struct>::const_iterator p = deco_list.find(name);
+ map<docstring, deco_struct>::const_iterator p = deco_list.find(name);
return p == deco_list.end() ? 0 : &(p->second);
}
} // namespace anon
+int mathed_font_em(FontInfo const & font)
+{
+ return theFontMetrics(font).em();
+}
+
+/* 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.
+ */
+
+int mathed_thinmuskip(FontInfo font)
+{
+ font.setFamily(SYMBOL_FAMILY);
+ return support::iround(3.0 / 18 * theFontMetrics(font).em());
+}
+
+
+int mathed_medmuskip(FontInfo font)
+{
+ font.setFamily(SYMBOL_FAMILY);
+ return support::iround(4.0 / 18 * theFontMetrics(font).em());
+}
+
+
+int mathed_thickmuskip(FontInfo font)
+{
+ font.setFamily(SYMBOL_FAMILY);
+ return support::iround(5.0 / 18 * theFontMetrics(font).em());
+}
+
+
int mathed_char_width(FontInfo const & font, char_type c)
{
return theFontMetrics(font).width(c);
pi.pain.line(
int(x + xx + 0.5), int(y + yy + 0.5),
int(x + x2 + 0.5), int(y + y2 + 0.5),
- Color_math);
+ pi.base.font.color());
} else {
int xp[32];
int yp[32];
yp[j] = int(y + yy + 0.5);
// lyxerr << "P[" << j ' ' << xx << ' ' << yy << ' ' << x << ' ' << y << ']';
}
- pi.pain.lines(xp, yp, n, Color_math);
+ pi.pain.lines(xp, yp, n, pi.base.font.color());
}
}
}
+void mathedSymbolDim(MetricsInfo & mi, 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" &&
+ mi.base.fontname == "mathit";
+ std::string const font = italic_upcase_greek ? "cmm" : sym->inset;
+ Changer dummy = mi.base.changeFontSet(font);
+ mathed_string_dim(mi.base.font, sym->draw, dim);
+ // seperate things a bit
+ if (sym->extra == "mathbin")
+ dim.wid += 2 * mathed_medmuskip(mi.base.font);
+ else if (sym->extra == "mathrel")
+ dim.wid += 2 * mathed_thickmuskip(mi.base.font);
+ else if (sym->extra == "mathpunct")
+ dim.wid += mathed_thinmuskip(mi.base.font);
+}
+
+
+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;
+ if (sym->extra == "mathbin")
+ x += mathed_medmuskip(pi.base.font);
+ else if (sym->extra == "mathrel")
+ x += mathed_thickmuskip(pi.base.font);
+
+ 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)
{
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)
{
FontInfo f = pi.base.font;
+ augmentFont(f, "mathnormal");
f.setColor(Color_foreground);
pi.pain.text(x, y, str, f);
}
struct fontinfo {
- std::string cmd_;
+ string cmd_;
FontFamily family_;
FontSeries series_;
FontShape shape_;
// does not work
fontinfo fontinfos[] = {
// math fonts
+ // 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},
{"mathit", inh_family, inh_series,
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},
{"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,
{"textipa", inh_family, inh_series,
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,
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,
};
-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;
}
-fontinfo * searchFont(docstring const & name)
+fontinfo * searchFont(string const & name)
{
fontinfo * f = lookupFont(name);
return f ? f : fontinfos;
}
-bool isFontName(docstring const & name)
+bool isFontName(string const & name)
{
return lookupFont(name);
}
-FontInfo 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)
{
FontInfo font;
augmentFont(font, name);
}
-void fakeFont(docstring const & orig, docstring const & fake)
+void fakeFont(string const & orig, string const & fake)
{
fontinfo * forig = searchFont(orig);
fontinfo * ffake = searchFont(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(FontInfo & 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)
}
+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, MathData & ar)
+void asArray(docstring const & str, MathData & ar, Parse::flags pf)
{
- mathed_parse_cell(ar, str);
+ bool quiet = pf & Parse::QUIET;
+ if ((str.size() == 1 && quiet) || (!mathed_parse_cell(ar, str, pf) && quiet))
+ 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();
}
docstring asString(MathAtom const & at)
{
odocstringstream os;
- WriteStream ws(os);
+ otexrowstream ots(os);
+ WriteStream ws(ots);
at->write(ws);
return os.str();
}
projects / lyx.git / blobdiff