#include "InsetMathFont.h"
#include "InsetMathSymbol.h"
+#include "Length.h"
#include "MathData.h"
+#include "MathFactory.h"
#include "MathParser.h"
#include "MathStream.h"
+#include "LaTeXFeatures.h"
#include "MetricsInfo.h"
#include "frontends/FontLoader.h"
#include "support/debug.h"
#include "support/docstream.h"
+#include "support/lassert.h"
#include "support/lyxlib.h"
#include <map>
}
};
-static init_deco_table dummy;
+static init_deco_table dummy_deco_table;
deco_struct const * search_deco(docstring const & name)
}
-} // 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).ascent('x');
+}
+
/* The math units. Quoting TeX by Topic, p.205:
*
* Spacing around mathematical objects is measured in mu units. A mu
* 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_thinmuskip(FontInfo font)
+int mathed_mu(FontInfo const & font, double mu)
{
- font.setFamily(SYMBOL_FAMILY);
- return support::iround(3.0 / 18 * theFontMetrics(font).em());
+ MetricsBase mb(nullptr, font);
+ return Length(mu, Length::MU).inPixels(mb);
}
-
-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_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(FontInfo 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));
}
} 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 << ' ';
yp[j] = int(y + yy + 0.5);
// lyxerr << "P[" << j ' ' << xx << ' ' << yy << ' ' << x << ' ' << y << ']';
}
- pi.pain.lines(xp, yp, n, pi.base.font.color());
+ 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, from_ascii("mathnormal"));
+ 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, from_ascii("mathnormal"));
+ 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, from_ascii("mathnormal"));
+ augmentFont(f, "mathnormal");
f.setColor(Color_foreground);
pi.pain.text(x, y, str, f);
}
// 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,
};
-fontinfo * lookupFont(docstring const & name0)
+fontinfo * lookupFont(string const & name)
{
//lyxerr << "searching font '" << name << "'" << endl;
int const n = sizeof(fontinfos) / sizeof(fontinfo);
- 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);
}
-bool isMathFont(docstring const & name)
+bool isMathFont(string const & name)
{
fontinfo * f = lookupFont(name);
return f && f->color_ == Color_math;
}
-bool isTextFont(docstring const & name)
+bool isTextFont(string const & name)
{
fontinfo * f = lookupFont(name);
return f && f->color_ == Color_foreground;
}
-FontInfo getFont(docstring const & name)
+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)
docstring asString(MathData const & ar)
{
odocstringstream os;
- TexRow texrow(false);
- otexrowstream ots(os,texrow);
+ otexrowstream ots(os);
WriteStream ws(ots);
ws << ar;
return os.str();
void asArray(docstring const & str, MathData & ar, Parse::flags pf)
{
+ // 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;
- if ((str.size() == 1 && quiet) || (!mathed_parse_cell(ar, str, pf) && 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;
- TexRow texrow(false);
- otexrowstream ots(os,texrow);
+ otexrowstream ots(os);
WriteStream ws(ots);
inset.write(ws);
return os.str();
docstring asString(MathAtom const & at)
{
odocstringstream os;
- TexRow texrow(false);
- otexrowstream ots(os,texrow);
+ 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.requires;
+ if (!req.empty())
+ features.require(req);
+ }
+}
+
+
} // namespace lyx
projects / lyx.git / blobdiff