anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-09-21 07:12:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

get rid of several friends small cleanup

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@1519 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2001-02-15 12:22:01 +00:00
parent 50be761b25
commit d5905fabf6
29 changed files with 1597 additions and 1487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/mathed/ChangeLog
View File

@ -1,3 +1,9 @@
2001-02-15 Lars Gullik Bjønnes <larsbj@lyx.org>
* matriz.C: clean up a bit.
* several files: changes so that several friends can be removed
2001-02-14 André Pönitz <poenitz@htwm.de>
* formula.C: reformatting

1038
src/mathed/formula.C
View File

File diff suppressed because it is too large Load Diff

117
src/mathed/formulamacro.C
View File

@ -14,10 +14,9 @@
*/
#include <config.h>
#include <cstdlib>
#ifdef __GNUG__
#pragma implementation "formulamacro.h"
#pragma implementation
#endif
#include "formulamacro.h"
@ -40,34 +39,34 @@ using std::ostream;
using std::istream;
InsetFormulaMacro::InsetFormulaMacro()
: InsetFormula(true)
: InsetFormula(true)
{
tmacro = 0;
opened = false;
tmacro = 0;
opened = false;
}
InsetFormulaMacro::InsetFormulaMacro(string nm, int na, bool /*e*/)
: InsetFormula(true), name(nm)
{
tmacro = MathMacroTable::mathMTable.getTemplate(name);
if (!tmacro) {
tmacro = new MathMacroTemplate(name.c_str(), na);
MathMacroTable::mathMTable.addTemplate(tmacro);
}
opened = false;
tmacro = MathMacroTable::mathMTable.getTemplate(name);
if (!tmacro) {
tmacro = new MathMacroTemplate(name.c_str(), na);
MathMacroTable::mathMTable.addTemplate(tmacro);
}
opened = false;
}
InsetFormulaMacro::~InsetFormulaMacro()
{
par = 0;
par = 0;
}
Inset * InsetFormulaMacro::Clone(Buffer const &) const
{
return new InsetFormulaMacro(name);
return new InsetFormulaMacro(name);
}
@ -88,13 +87,13 @@ int InsetFormulaMacro::Latex(Buffer const *, ostream & os, bool /*fragile*/,
int InsetFormulaMacro::Linuxdoc(Buffer const * buf, ostream & os) const
{
return Ascii(buf, os, 0);
return Ascii(buf, os, 0);
}
int InsetFormulaMacro::DocBook(Buffer const * buf, ostream & os) const
{
return Ascii(buf, os, 0);
return Ascii(buf, os, 0);
}
@ -121,33 +120,33 @@ void InsetFormulaMacro::Read(Buffer const *, LyXLex & lex)
int InsetFormulaMacro::ascent(BufferView * pain, LyXFont const & f) const
{
if (opened) {
tmacro->update();
return InsetFormula::ascent(pain, f);
}
return lyxfont::maxAscent(f) + 3;
if (opened) {
tmacro->update();
return InsetFormula::ascent(pain, f);
}
return lyxfont::maxAscent(f) + 3;
}
int InsetFormulaMacro::descent(BufferView * pain, LyXFont const & f) const
{
if (opened) {
tmacro->update();
return InsetFormula::descent(pain, f);
}
return lyxfont::maxDescent(f) + 1;
if (opened) {
tmacro->update();
return InsetFormula::descent(pain, f);
}
return lyxfont::maxDescent(f) + 1;
}
int InsetFormulaMacro::width(BufferView * bv, LyXFont const & f) const
{
if (opened) {
tmacro->update();
return InsetFormula::width(bv, f);
}
string ilabel(_("Macro: "));
ilabel += name;
return 6 + lyxfont::width(ilabel, f);
if (opened) {
tmacro->update();
return InsetFormula::width(bv, f);
}
string ilabel(_("Macro: "));
ilabel += name;
return 6 + lyxfont::width(ilabel, f);
}
@ -164,10 +163,9 @@ void InsetFormulaMacro::draw(BufferView * bv, LyXFont const & f,
} else {
font.setColor(LColor::math);
int y = baseline - ascent(bv, font) + 1;
int w = width(bv, font) - 2;
int h = (ascent(bv, font) + descent(bv, font) - 2);
int const y = baseline - ascent(bv, font) + 1;
int const w = width(bv, font) - 2;
int const h = (ascent(bv, font) + descent(bv, font) - 2);
pain.fillRectangle(int(x), y, w, h, LColor::mathbg);
pain.rectangle(int(x), y, w, h, LColor::mathframe);
@ -188,21 +186,21 @@ string const InsetFormulaMacro::EditMessage() const
void InsetFormulaMacro::Edit(BufferView * bv, int x, int y,unsigned int button)
{
opened = true;
par = static_cast<MathParInset*>(tmacro->Clone());
InsetFormula::Edit(bv, x, y, button);
opened = true;
par = static_cast<MathParInset*>(tmacro->Clone());
InsetFormula::Edit(bv, x, y, button);
}
void InsetFormulaMacro::InsetUnlock(BufferView * bv)
{
opened = false;
MathedArray * tarray = tmacro->GetData();
MathedIter it(tarray);
it.Clear();
tmacro->SetData(par->GetData());
tmacro->setEditMode(false);
InsetFormula::InsetUnlock(bv);
opened = false;
MathedArray * tarray = tmacro->GetData();
MathedIter it(tarray);
it.Clear();
tmacro->SetData(par->GetData());
tmacro->setEditMode(false);
InsetFormula::InsetUnlock(bv);
}
@ -210,19 +208,20 @@ UpdatableInset::RESULT
InsetFormulaMacro::LocalDispatch(BufferView * bv,
int action, string const & arg)
{
if (action == LFUN_MATH_MACROARG) {
int i = lyx::atoi(arg) - 1;
if (i >= 0 && i < tmacro->getNoArgs()) {
mathcursor->Insert(tmacro->getMacroPar(i), LM_TC_INSET);
InsetFormula::UpdateLocal(bv);
}
if (action == LFUN_MATH_MACROARG) {
int i = lyx::atoi(arg) - 1;
if (i >= 0 && i < tmacro->getNoArgs()) {
mathcursor->Insert(tmacro->getMacroPar(i),
LM_TC_INSET);
InsetFormula::UpdateLocal(bv);
}
return DISPATCHED;
}
tmacro->setEditMode(true);
tmacro->Metrics();
RESULT result = InsetFormula::LocalDispatch(bv, action, arg);
tmacro->setEditMode(false);
return DISPATCHED;
}
tmacro->setEditMode(true);
tmacro->Metrics();
RESULT result = InsetFormula::LocalDispatch(bv, action, arg);
tmacro->setEditMode(false);
return result;
return result;
}

8
src/mathed/math_accentinset.C
View File

@ -48,7 +48,7 @@ MathAccentInset::draw(Painter & pain, int x, int y)
else {
string s;
s += c;
drawStr(pain, fn, size, x, y, s);
drawStr(pain, fn, size(), x, y, s);
}
x += (code == LM_not) ? (width-dw) / 2 : 2;
mathed_draw_deco(pain, x, y - dy, dw, dh, code);
@ -65,9 +65,9 @@ MathAccentInset::Metrics()
width = inset->Width();
dh = ascent;
} else {
mathed_char_height(fn, size, c, ascent, descent);
width = mathed_char_width(fn, size, c);
dh = (width-2)/2;
mathed_char_height(fn, size(), c, ascent, descent);
width = mathed_char_width(fn, size(), c);
dh = (width - 2) / 2;
}
if (code == LM_not) {
ascent += dh;

6
src/mathed/math_bigopinset.C
View File

@ -57,7 +57,7 @@ MathBigopInset::draw(Painter & pain, int x, int y)
LColor::mathline);
++x;
}
pain.text(x, y, s, mathed_get_font(t, size));
pain.text(x, y, s, mathed_get_font(t, size()));
}
@ -76,8 +76,8 @@ MathBigopInset::Metrics()
s = name;
t = LM_TC_TEXTRM;
}
mathed_string_height(t, size, s, ascent, descent);
width = mathed_string_width(t, size, s);
mathed_string_height(t, size(), s, ascent, descent);
width = mathed_string_width(t, size(), s);
if (sym == LM_oint) width += 2;
}

17
src/mathed/math_decorationinset.C
View File

@ -42,19 +42,20 @@ MathDecorationInset::draw(Painter & pain, int x, int y)
void
MathDecorationInset::Metrics()
{
int h = 2*mathed_char_height(LM_TC_VAR, size, 'I', ascent, descent);
int h = 2 * mathed_char_height(LM_TC_VAR, size(), 'I',
ascent, descent);
MathParInset::Metrics();
int w = Width()+4;
if (w<16) w = 16;
dh = w/5;
if (dh>h) dh = h;
int w = Width() + 4;
if (w < 16) w = 16;
dh = w / 5;
if (dh > h) dh = h;
if (upper) {
ascent += dh+2;
ascent += dh + 2;
dy = -ascent;
} else {
dy = descent+2;
descent += dh+4;
dy = descent + 2;
descent += dh + 4;
}
dw = width;
width = w;

1
src/mathed/math_delim.C
View File

@ -19,7 +19,6 @@
#include FORMS_H_LOCATION
#include <algorithm>
#include <cstdlib>
#include "symbol_def.h"
#include "math_inset.h"
#include "LColor.h"

35
src/mathed/math_deliminset.C
View File

@ -57,37 +57,38 @@ void MathDelimInset::Write(ostream & os, bool fragile)
void
MathDelimInset::draw(Painter & pain, int x, int y)
{
xo = x; yo = y;
xo(x);
yo(y);
MathParInset::draw(pain, x + dw + 2, y - dh);
if (left == '.') {
pain.line(x + 4, yo - ascent,
x + 4, yo + descent,
pain.line(x + 4, yo() - ascent,
x + 4, yo() + descent,
LColor::mathcursor, Painter::line_onoffdash);
} else
mathed_draw_deco(pain, x, y - ascent, dw, Height(), left);
x += Width() - dw - 2;
if (right == '.') {
pain.line(x + 4, yo - ascent,
x + 4, yo + descent,
pain.line(x + 4, yo() - ascent,
x + 4, yo() + descent,
LColor::mathcursor, Painter::line_onoffdash);
} else
mathed_draw_deco(pain, x, y-ascent, dw, Height(), right);
mathed_draw_deco(pain, x, y - ascent, dw, Height(), right);
}
void
MathDelimInset::Metrics()
{
MathParInset::Metrics();
int d;
mathed_char_height(LM_TC_CONST, size, 'I', d, dh);
dh /= 2;
ascent += 2 + dh;
descent += 2 - dh;
dw = Height()/5;
if (dw > 15) dw = 15;
if (dw<6) dw = 6;
width += 2*dw+4;
MathParInset::Metrics();
int d;
mathed_char_height(LM_TC_CONST, size(), 'I', d, dh);
dh /= 2;
ascent += 2 + dh;
descent += 2 - dh;
dw = Height()/5;
if (dw > 15) dw = 15;
if (dw < 6) dw = 6;
width += 2 * dw + 4;
}

4
src/mathed/math_dotsinset.C
View File

@ -30,8 +30,8 @@ MathDotsInset::draw(Painter & pain, int x, int y)
void
MathDotsInset::Metrics()
{
mathed_char_height(LM_TC_VAR, size, 'M', ascent, descent);
width = mathed_char_width(LM_TC_VAR, size, 'M');
mathed_char_height(LM_TC_VAR, size(), 'M', ascent, descent);
width = mathed_char_width(LM_TC_VAR, size(), 'M');
switch (code) {
case LM_ldots: dh = 0; break;
case LM_cdots: dh = ascent/2; break;

27
src/mathed/math_fracinset.C
View File

@ -56,9 +56,9 @@ void MathFracInset::SetStyle(short st)
{
MathParInset::SetStyle(st);
dh = 0;
den->SetStyle((size == LM_ST_DISPLAY) ?
den->SetStyle((size() == LM_ST_DISPLAY) ?
static_cast<short>(LM_ST_TEXT)
: size);
: size());
}
@ -99,16 +99,19 @@ MathedArray * MathFracInset::GetData()
bool MathFracInset::Inside(int x, int y)
{
int xx = xo - (width - w0) / 2;
int xx = xo() - (width - w0) / 2;
return x >= xx && x <= xx + width && y <= yo + descent && y >= yo - ascent;
return x >= xx
&& x <= xx + width
&& y <= yo() + descent
&& y >= yo() - ascent;
}
void MathFracInset::SetFocus(int /*x*/, int y)
{
// lyxerr << "y " << y << " " << yo << " " << den->yo << " ";
idx = (y > yo) ? 1: 0;
idx = (y > yo()) ? 1: 0;
}
@ -116,13 +119,13 @@ void
MathFracInset::draw(Painter & pain, int x, int y)
{
short idxp = idx;
short sizex = size;
short sizex = size();
idx = 0;
if (size == LM_ST_DISPLAY) ++size;
if (size() == LM_ST_DISPLAY) incSize();
MathParInset::draw(pain, x + (width - w0) / 2, y - des0);
den->draw(pain, x + (width - w1) / 2, y + den->Ascent() + 2 - dh);
size = sizex;
size(sizex);
if (objtype == LM_OT_FRAC)
pain.line(x + 2, y - dh, x + width - 4, y - dh, LColor::mathline);
idx = idxp;
@ -134,14 +137,14 @@ MathFracInset::Metrics()
{
if (!dh) {
int a, b;
dh = mathed_char_height(LM_TC_CONST, size, 'I', a, b)/2;
dh = mathed_char_height(LM_TC_CONST, size(), 'I', a, b) / 2;
}
short idxp = idx;
short sizex = size;
short sizex = size();
idx = 0;
if (size == LM_ST_DISPLAY) ++size;
if (size() == LM_ST_DISPLAY) incSize();
MathParInset::Metrics();
size = sizex;
size(sizex);
w0 = width;
int as = Height() + 2 + dh;
des0 = Descent() + 2 + dh;

6
src/mathed/math_funcinset.C
View File

@ -54,7 +54,7 @@ void
MathFuncInset::draw(Painter & pain, int x, int y)
{
if (!name.empty() && name[0] > ' ') {
LyXFont font = WhichFont(LM_TC_TEXTRM, size);
LyXFont font = WhichFont(LM_TC_TEXTRM, size());
font.setLatex(LyXFont::ON);
x += (lyxfont::width('I', font) + 3) / 4;
pain.text(x, y, name, font);
@ -66,7 +66,7 @@ MathFuncInset::draw(Painter & pain, int x, int y)
void MathFuncInset::Metrics()
{
//ln = (name) ? strlen(name): 0;
LyXFont font = WhichFont(LM_TC_TEXTRM, size);
LyXFont font = WhichFont(LM_TC_TEXTRM, size());
font.setLatex(LyXFont::ON);
if (name.empty()) {
width = df_width;
@ -75,6 +75,6 @@ void MathFuncInset::Metrics()
} else {
width = lyxfont::width(name, font)
+ lyxfont::width('I', font) / 2;
mathed_string_height(LM_TC_TEXTRM, size, name, ascent, descent);
mathed_string_height(LM_TC_TEXTRM, size(), name, ascent, descent);
}
}

648
src/mathed/math_hash.C
View File

@ -2,7 +2,6 @@
/* Command-line: gperf -a -p -o -t -G -D keywords */
#include <config.h>
#include <cstdlib>
#include <cstring>
#include "math_defs.h"
@ -18,300 +17,301 @@ int const MAX_HASH_VALUE = 490;
static
unsigned int
math_hash (register char const *str, register int len)
math_hash (register char const * str, register int len)
{
static unsigned short asso_values[] =
{
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 95, 491,
491, 45, 491, 10, 491, 491, 255, 491, 491, 65,
30, 491, 0, 70, 80, 70, 15, 491, 10, 491,
491, 491, 491, 491, 491, 491, 491, 50, 200, 140,
219, 35, 135, 237, 230, 69, 0, 20, 10, 180,
105, 247, 55, 208, 125, 0, 25, 42, 255, 75,
5, 0, 0, 491, 491, 491, 491, 491,
};
return len + asso_values[str[len - 1]] + asso_values[str[0]];
static unsigned short asso_values[] =
{
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 491, 491,
491, 491, 491, 491, 491, 491, 491, 491, 95, 491,
491, 45, 491, 10, 491, 491, 255, 491, 491, 65,
30, 491, 0, 70, 80, 70, 15, 491, 10, 491,
491, 491, 491, 491, 491, 491, 491, 50, 200, 140,
219, 35, 135, 237, 230, 69, 0, 20, 10, 180,
105, 247, 55, 208, 125, 0, 25, 42, 255, 75,
5, 0, 0, 491, 491, 491, 491, 491,
};
return len + asso_values[str[len - 1]] + asso_values[str[0]];
}
static
latexkeys wordlist[] =
{
{"",0,0}, {"",0,0}, {"",0,0}, {"",0,0}, {"",0,0}, {"",0,0}, {"",0,0}, {"",0,0},
{"setminus", LM_TK_SYM, LM_setminus},
{"ldots", LM_TK_DOTS, LM_ldots},
{"limits", LM_TK_LIMIT, 1 },
{"stackrel", LM_TK_STACK, 0},
{"ll", LM_TK_SYM, LM_ll},
{"label", LM_TK_LABEL, 0},
{"lceil", LM_TK_SYM, LM_lceil},
{"sqrt", LM_TK_SQRT, 0},
{"times", LM_TK_SYM, LM_times},
{"subset", LM_TK_SYM, LM_subset},
{"supset", LM_TK_SYM, LM_supset},
{"spadesuit", LM_TK_SYM, LM_spadesuit},
{"Re", LM_TK_SYM, LM_Re},
{"left", LM_TK_LEFT, 0},
{"smile", LM_TK_SYM, LM_smile},
{"exists", LM_TK_SYM, LM_exists},
{"Vert", LM_TK_SYM, LM_Vert},
{"scriptstyle", LM_TK_STY, LM_ST_SCRIPT},
{"uplus", LM_TK_SYM, LM_uplus},
{"ell", LM_TK_SYM, LM_ell},
{"langle", LM_TK_SYM, LM_langle},
{"scriptscriptstyle", LM_TK_STY, LM_ST_SCRIPTSCRIPT},
{"zeta", LM_TK_SYM, LM_zeta},
{"sigma", LM_TK_SYM, LM_sigma},
{"arccos", LM_TK_FUNC, 0},
{"sup", LM_TK_FUNCLIM, 0},
{"sharp", LM_TK_SYM, LM_sharp},
{"sqcup", LM_TK_SYM, LM_sqcup},
{"sqcap", LM_TK_SYM, LM_sqcap},
{"approx", LM_TK_SYM, LM_approx},
{"triangleleft", LM_TK_SYM, LM_triangleleft},
{"triangleright", LM_TK_SYM, LM_triangleright},
{"tilde", LM_TK_ACCENT, LM_tilde},
{"lambda", LM_TK_SYM, LM_lambda},
{"emptyset", LM_TK_MACRO, LM_emptyset},
{"triangle", LM_TK_SYM, LM_triangle},
{"textstyle", LM_TK_STY, LM_ST_TEXT},
{"tau", LM_TK_SYM, LM_tau},
{"limsup", LM_TK_FUNCLIM, 0},
{"partial", LM_TK_SYM, LM_partial},
{"parallel", LM_TK_SYM, LM_parallel},
{"infty", LM_TK_SYM, LM_infty},
{"kappa", LM_TK_SYM, LM_kappa},
{"xi", LM_TK_SYM, LM_xi},
{"leftharpoonup", LM_TK_SYM, LM_leftharpoonup},
{"theta", LM_TK_SYM, LM_theta},
{"Xi", LM_TK_SYM, LM_Xi},
{"searrow", LM_TK_SYM, LM_searrow},
{"swarrow", LM_TK_SYM, LM_swarrow},
{"top", LM_TK_SYM, LM_top},
{"Rightarrow", LM_TK_SYM, LM_Rightarrow},
{"underline", LM_TK_WIDE, LM_underline},
{"underbrace", LM_TK_WIDE, LM_underbrace},
{"eta", LM_TK_SYM, LM_eta},
{"acute", LM_TK_ACCENT, LM_acute},
{"angle", LM_TK_SYM, LM_angle},
{"exp", LM_TK_FUNC, 0},
{"leftarrow", LM_TK_SYM, LM_leftarrow},
{"prime", LM_TK_SYM, LM_prime},
{"int", LM_TK_BIGSYM, LM_int},
{"longleftarrow", LM_TK_SYM, LM_longleftarrow},
{"leftrightarrow", LM_TK_SYM, LM_leftrightarrow},
{"longrightarrow", LM_TK_SYM, LM_longrightarrow},
{"Gamma", LM_TK_SYM, LM_Gamma},
{"Pi", LM_TK_SYM, LM_Pi},
{"Phi", LM_TK_SYM, LM_Phi},
{"Psi", LM_TK_SYM, LM_Psi},
{"longleftrightarrow", LM_TK_SYM, LM_longleftrightarrow},
{"alpha", LM_TK_SYM, LM_alpha},
{"widehat", LM_TK_WIDE, LM_widehat},
{"sin", LM_TK_FUNC, 0},
{"asymp", LM_TK_SYM, LM_asymp},
{"nolimits", LM_TK_LIMIT, 0 },
{"perp", LM_TK_MACRO, LM_perp},
{"wedge", LM_TK_SYM, LM_wedge},
{"ln", LM_TK_FUNC, 0},
{"widetilde", LM_TK_WIDE, LM_widetilde},
{"Omega", LM_TK_SYM, LM_Omega},
{"natural", LM_TK_SYM, LM_natural},
{"iota", LM_TK_SYM, LM_iota},
{"uparrow", LM_TK_SYM, LM_uparrow},
{"Sigma", LM_TK_SYM, LM_Sigma},
{"pi", LM_TK_SYM, LM_pi},
{"phi", LM_TK_SYM, LM_phi},
{"psi", LM_TK_SYM, LM_psi},
{"updownarrow", LM_TK_SYM, LM_updownarrow},
{"star", LM_TK_SYM, LM_star},
{"leftharpoondown", LM_TK_SYM, LM_leftharpoondown},
{"wp", LM_TK_SYM, LM_wp},
{"not", LM_TK_ACCENT, LM_not},
{"tan", LM_TK_FUNC, 0},
{"Theta", LM_TK_SYM, LM_Theta},
{"rceil", LM_TK_SYM, LM_rceil},
{"lfloor", LM_TK_SYM, LM_lfloor},
{"rightleftharpoons", LM_TK_SYM, LM_rightleftharpoons},
{"cos", LM_TK_FUNC, 0},
{"sec", LM_TK_FUNC, 0},
{"succ", LM_TK_SYM, LM_succ},
{"cdots", LM_TK_DOTS, LM_cdots},
{"epsilon", LM_TK_SYM, LM_epsilon},
{"ker", LM_TK_FUNC, 0},
{"nu", LM_TK_SYM, LM_nu},
{"Delta", LM_TK_SYM, LM_Delta},
{"forall", LM_TK_SYM, LM_forall},
{"liminf", LM_TK_FUNCLIM, 0},
{"Uparrow", LM_TK_SYM, LM_Uparrow},
{"upsilon", LM_TK_SYM, LM_upsilon},
{"right", LM_TK_RIGHT, 0},
{"Updownarrow", LM_TK_SYM, LM_Updownarrow},
{"Pr", LM_TK_FUNCLIM, 0},
{"nabla", LM_TK_SYM, LM_nabla},
{"arcsin", LM_TK_FUNC, 0},
{"arctan", LM_TK_FUNC, 0},
{"flat", LM_TK_SYM, LM_flat},
{"check", LM_TK_ACCENT, LM_check},
{"rangle", LM_TK_SYM, LM_rangle},
{"cot", LM_TK_FUNC, 0},
{"cdot", LM_TK_SYM, LM_cdot},
{"clubsuit", LM_TK_SYM, LM_clubsuit},
{"in", LM_TK_SYM, LM_in},
{"ni", LM_TK_SYM, LM_ni},
{"Downarrow", LM_TK_SYM, LM_Downarrow},
{"Upsilon", LM_TK_SYM, LM_Upsilon},
{"sim", LM_TK_SYM, LM_sim},
{"sum", LM_TK_BIGSYM, LM_sum},
{"models", LM_TK_SYM, LM_models},
{"nearrow", LM_TK_SYM, LM_nearrow},
{"nwarrow", LM_TK_SYM, LM_nwarrow},
{"max", LM_TK_FUNCLIM, 0},
{"Im", LM_TK_SYM, LM_Im},
{"lim", LM_TK_FUNCLIM, 0},
{"rightharpoonup", LM_TK_SYM, LM_rightharpoonup},
{"mathcal", LM_TK_FONT, LM_TC_CAL},
{"cap", LM_TK_SYM, LM_cap},
{"cup", LM_TK_SYM, LM_cup},
{"prec", LM_TK_SYM, LM_prec},
{"mathnormal", LM_TK_FONT, LM_TC_VAR},
{"wr", LM_TK_SYM, LM_wr},
{"inf", LM_TK_FUNCLIM, 0},
{"bigoplus", LM_TK_BIGSYM, LM_oplus},
{"biguplus", LM_TK_BIGSYM, LM_biguplus},
{"bigotimes", LM_TK_BIGSYM, LM_otimes},
{"rightarrow", LM_TK_SYM, LM_rightarrow},
{"mathit", LM_TK_FONT, LM_TC_IT},
{"textrm", LM_TK_FONT, LM_TC_TEXTRM},
{"mathtt", LM_TK_FONT, LM_TC_TT},
{"chi", LM_TK_SYM, LM_chi},
{"simeq", LM_TK_SYM, LM_simeq},
{"succeq", LM_TK_SYM, LM_succeq},
{"notin", LM_TK_MACRO, LM_notin},
{"subseteq", LM_TK_SYM, LM_subseteq},
{"supseteq", LM_TK_SYM, LM_supseteq},
{"sqsubseteq", LM_TK_SYM, LM_sqsubseteq},
{"sqsupseteq", LM_TK_SYM, LM_sqsupseteq},
{"leq", LM_TK_SYM, LM_leq},
{"surd", LM_TK_SYM, LM_surd},
{"ddots", LM_TK_DOTS, LM_ddots},
{"mu", LM_TK_SYM, LM_mu},
{"bot", LM_TK_SYM, LM_bot},
{"bullet", LM_TK_SYM, LM_bullet},
{"bigodot", LM_TK_BIGSYM, LM_bigodot},
{"sinh", LM_TK_FUNC, 0},
{"jmath", LM_TK_SYM, LM_jmath},
{"mp", LM_TK_SYM, LM_mp},
{"pm", LM_TK_SYM, LM_pm},
{"nonumber", LM_TK_NONUM, 0},
{"breve", LM_TK_ACCENT, LM_breve},
{"bigvee", LM_TK_BIGSYM, LM_vee},
{"bowtie", LM_TK_SYM, LM_bowtie},
{"bigwedge", LM_TK_BIGSYM, LM_wedge},
{"frown", LM_TK_SYM, LM_frown},
{"rightharpoondown", LM_TK_SYM, LM_rightharpoondown},
{"det", LM_TK_FUNCLIM, 0},
{"dot", LM_TK_ACCENT, LM_dot},
{"ddot", LM_TK_ACCENT, LM_ddot},
{"lg", LM_TK_FUNC, 0},
{"log", LM_TK_FUNC, 0},
{"oplus", LM_TK_SYM, LM_oplus},
{"ominus", LM_TK_SYM, LM_ominus},
{"otimes", LM_TK_SYM, LM_otimes},
{"beta", LM_TK_SYM, LM_beta},
{"diamondsuit", LM_TK_SYM, LM_diamondsuit},
{"rfloor", LM_TK_SYM, LM_rfloor},
{"end", LM_TK_END, 0},
{"hat", LM_TK_ACCENT, LM_hat},
{"tanh", LM_TK_FUNC, 0},
{"vdots", LM_TK_DOTS, LM_vdots},
{"bigcap", LM_TK_BIGSYM, LM_cap},
{"bigcup", LM_TK_BIGSYM, LM_cup},
{"bigsqcup", LM_TK_BIGSYM, LM_bigsqcup},
{"heartsuit", LM_TK_SYM, LM_heartsuit},
{"displaystyle", LM_TK_STY, LM_ST_DISPLAY},
{"longmapsto", LM_TK_SYM, LM_longmapsto},
{"bigtriangleup", LM_TK_SYM, LM_bigtriangleup},
{"preceq", LM_TK_SYM, LM_preceq},
{"delta", LM_TK_SYM, LM_delta},
{"odot", LM_TK_SYM, LM_odot},
{"oint", LM_TK_BIGSYM, LM_oint},
{"grave", LM_TK_ACCENT, LM_grave},
{"pmod", LM_TK_PMOD, 0},
{"prod", LM_TK_BIGSYM, LM_prod},
{"frac", LM_TK_FRAC, 0},
{"csc", LM_TK_FUNC, 0},
{"circ", LM_TK_SYM, LM_circ},
{"aleph", LM_TK_SYM, LM_aleph},
{"min", LM_TK_FUNCLIM, 0},
{"overline", LM_TK_WIDE, LM_overline},
{"arg", LM_TK_FUNC, 0},
{"overbrace", LM_TK_WIDE, LM_overbrace},
{"amalg", LM_TK_SYM, LM_amalg},
{"gamma", LM_TK_SYM, LM_gamma},
{"vee", LM_TK_SYM, LM_vee},
{"equiv", LM_TK_SYM, LM_equiv},
{"omega", LM_TK_SYM, LM_omega},
{"downarrow", LM_TK_SYM, LM_downarrow},
{"imath", LM_TK_SYM, LM_imath},
{"propto", LM_TK_SYM, LM_propto},
{"begin", LM_TK_BEGIN, 0},
{"Lambda", LM_TK_SYM, LM_Lambda},
{"varsigma", LM_TK_SYM, LM_varsigma},
{"vartheta", LM_TK_SYM, LM_vartheta},
{"neq", LM_TK_SYM, LM_neq},
{"hookleftarrow", LM_TK_SYM, LM_hookleftarrow},
{"hookrightarrow", LM_TK_SYM, LM_hookrightarrow},
{"bigtriangledown", LM_TK_SYM, LM_bigtriangledown},
{"mathbf", LM_TK_FONT, LM_TC_BF},
{"mathsf", LM_TK_FONT, LM_TC_SF},
{"bar", LM_TK_ACCENT, LM_bar},
{"varpi", LM_TK_SYM, LM_varpi},
{"varphi", LM_TK_SYM, LM_varphi},
{"newcommand", LM_TK_NEWCOMMAND, 0 },
{"overleftarrow", LM_TK_WIDE, LM_overleftarrow},
{"overrightarrow", LM_TK_WIDE, LM_overightarrow},
{"Leftarrow", LM_TK_SYM, LM_Leftarrow},
{"Longleftarrow", LM_TK_SYM, LM_Longleftarrow},
{"Leftrightarrow", LM_TK_SYM, LM_Leftrightarrow},
{"Longrightarrow", LM_TK_SYM, LM_Longrightarrow},
{"neg", LM_TK_SYM, LM_neg},
{"bigcirc", LM_TK_SYM, LM_bigcirc},
{"Longleftrightarrow", LM_TK_SYM, LM_Longleftrightarrow},
{"dagger", LM_TK_SYM, LM_dagger},
{"ddagger", LM_TK_SYM, LM_ddagger},
{"hbar", LM_TK_SYM, LM_hbar},
{"coprod", LM_TK_BIGSYM, LM_coprod},
{"mathrm", LM_TK_FONT, LM_TC_RM},
{"varepsilon", LM_TK_SYM, LM_varepsilon},
{"cosh", LM_TK_FUNC, 0},
{"coth", LM_TK_FUNC, 0},
{"rho", LM_TK_SYM, LM_rho},
{"cong", LM_TK_SYM, LM_cong},
{"vec", LM_TK_ACCENT, LM_vec},
{"dim", LM_TK_FUNC, 0},
{"mid", LM_TK_SYM, LM_mid},
{"hom", LM_TK_FUNC, 0},
{"bmod", LM_TK_FUNC, 0},
{"quad", LM_TK_SPACE, LM_quad},
{"doteq", LM_TK_SYM, LM_doteq},
{"qquad", LM_TK_SPACE, LM_qquad},
{"mapsto", LM_TK_SYM, LM_mapsto},
{"backslash", LM_TK_SYM, LM_backslash},
{"diamond", LM_TK_SYM, LM_diamond},
{"geq", LM_TK_SYM, LM_geq},
{"deg", LM_TK_FUNC, 0},
{"gcd", LM_TK_FUNCLIM, 0},
{"gg", LM_TK_SYM, LM_gg},
{"div", LM_TK_SYM, LM_div},
{"dashv", LM_TK_SYM, LM_dashv},
{"oslash", LM_TK_SYM, LM_oslash},
{"vdash", LM_TK_SYM, LM_vdash},
{"",0,0}, {"",0,0}, {"",0,0}, {"",0,0},
{"",0,0}, {"",0,0}, {"",0,0}, {"",0,0},
{"setminus", LM_TK_SYM, LM_setminus},
{"ldots", LM_TK_DOTS, LM_ldots},
{"limits", LM_TK_LIMIT, 1 },
{"stackrel", LM_TK_STACK, 0},
{"ll", LM_TK_SYM, LM_ll},
{"label", LM_TK_LABEL, 0},
{"lceil", LM_TK_SYM, LM_lceil},
{"sqrt", LM_TK_SQRT, 0},
{"times", LM_TK_SYM, LM_times},
{"subset", LM_TK_SYM, LM_subset},
{"supset", LM_TK_SYM, LM_supset},
{"spadesuit", LM_TK_SYM, LM_spadesuit},
{"Re", LM_TK_SYM, LM_Re},
{"left", LM_TK_LEFT, 0},
{"smile", LM_TK_SYM, LM_smile},
{"exists", LM_TK_SYM, LM_exists},
{"Vert", LM_TK_SYM, LM_Vert},
{"scriptstyle", LM_TK_STY, LM_ST_SCRIPT},
{"uplus", LM_TK_SYM, LM_uplus},
{"ell", LM_TK_SYM, LM_ell},
{"langle", LM_TK_SYM, LM_langle},
{"scriptscriptstyle", LM_TK_STY, LM_ST_SCRIPTSCRIPT},
{"zeta", LM_TK_SYM, LM_zeta},
{"sigma", LM_TK_SYM, LM_sigma},
{"arccos", LM_TK_FUNC, 0},
{"sup", LM_TK_FUNCLIM, 0},
{"sharp", LM_TK_SYM, LM_sharp},
{"sqcup", LM_TK_SYM, LM_sqcup},
{"sqcap", LM_TK_SYM, LM_sqcap},
{"approx", LM_TK_SYM, LM_approx},
{"triangleleft", LM_TK_SYM, LM_triangleleft},
{"triangleright", LM_TK_SYM, LM_triangleright},
{"tilde", LM_TK_ACCENT, LM_tilde},
{"lambda", LM_TK_SYM, LM_lambda},
{"emptyset", LM_TK_MACRO, LM_emptyset},
{"triangle", LM_TK_SYM, LM_triangle},
{"textstyle", LM_TK_STY, LM_ST_TEXT},
{"tau", LM_TK_SYM, LM_tau},
{"limsup", LM_TK_FUNCLIM, 0},
{"partial", LM_TK_SYM, LM_partial},
{"parallel", LM_TK_SYM, LM_parallel},
{"infty", LM_TK_SYM, LM_infty},
{"kappa", LM_TK_SYM, LM_kappa},
{"xi", LM_TK_SYM, LM_xi},
{"leftharpoonup", LM_TK_SYM, LM_leftharpoonup},
{"theta", LM_TK_SYM, LM_theta},
{"Xi", LM_TK_SYM, LM_Xi},
{"searrow", LM_TK_SYM, LM_searrow},
{"swarrow", LM_TK_SYM, LM_swarrow},
{"top", LM_TK_SYM, LM_top},
{"Rightarrow", LM_TK_SYM, LM_Rightarrow},
{"underline", LM_TK_WIDE, LM_underline},
{"underbrace", LM_TK_WIDE, LM_underbrace},
{"eta", LM_TK_SYM, LM_eta},
{"acute", LM_TK_ACCENT, LM_acute},
{"angle", LM_TK_SYM, LM_angle},
{"exp", LM_TK_FUNC, 0},
{"leftarrow", LM_TK_SYM, LM_leftarrow},
{"prime", LM_TK_SYM, LM_prime},
{"int", LM_TK_BIGSYM, LM_int},
{"longleftarrow", LM_TK_SYM, LM_longleftarrow},
{"leftrightarrow", LM_TK_SYM, LM_leftrightarrow},
{"longrightarrow", LM_TK_SYM, LM_longrightarrow},
{"Gamma", LM_TK_SYM, LM_Gamma},
{"Pi", LM_TK_SYM, LM_Pi},
{"Phi", LM_TK_SYM, LM_Phi},
{"Psi", LM_TK_SYM, LM_Psi},
{"longleftrightarrow", LM_TK_SYM, LM_longleftrightarrow},
{"alpha", LM_TK_SYM, LM_alpha},
{"widehat", LM_TK_WIDE, LM_widehat},
{"sin", LM_TK_FUNC, 0},
{"asymp", LM_TK_SYM, LM_asymp},
{"nolimits", LM_TK_LIMIT, 0 },
{"perp", LM_TK_MACRO, LM_perp},
{"wedge", LM_TK_SYM, LM_wedge},
{"ln", LM_TK_FUNC, 0},
{"widetilde", LM_TK_WIDE, LM_widetilde},
{"Omega", LM_TK_SYM, LM_Omega},
{"natural", LM_TK_SYM, LM_natural},
{"iota", LM_TK_SYM, LM_iota},
{"uparrow", LM_TK_SYM, LM_uparrow},
{"Sigma", LM_TK_SYM, LM_Sigma},
{"pi", LM_TK_SYM, LM_pi},
{"phi", LM_TK_SYM, LM_phi},
{"psi", LM_TK_SYM, LM_psi},
{"updownarrow", LM_TK_SYM, LM_updownarrow},
{"star", LM_TK_SYM, LM_star},
{"leftharpoondown", LM_TK_SYM, LM_leftharpoondown},
{"wp", LM_TK_SYM, LM_wp},
{"not", LM_TK_ACCENT, LM_not},
{"tan", LM_TK_FUNC, 0},
{"Theta", LM_TK_SYM, LM_Theta},
{"rceil", LM_TK_SYM, LM_rceil},
{"lfloor", LM_TK_SYM, LM_lfloor},
{"rightleftharpoons", LM_TK_SYM, LM_rightleftharpoons},
{"cos", LM_TK_FUNC, 0},
{"sec", LM_TK_FUNC, 0},
{"succ", LM_TK_SYM, LM_succ},
{"cdots", LM_TK_DOTS, LM_cdots},
{"epsilon", LM_TK_SYM, LM_epsilon},
{"ker", LM_TK_FUNC, 0},
{"nu", LM_TK_SYM, LM_nu},
{"Delta", LM_TK_SYM, LM_Delta},
{"forall", LM_TK_SYM, LM_forall},
{"liminf", LM_TK_FUNCLIM, 0},
{"Uparrow", LM_TK_SYM, LM_Uparrow},
{"upsilon", LM_TK_SYM, LM_upsilon},
{"right", LM_TK_RIGHT, 0},
{"Updownarrow", LM_TK_SYM, LM_Updownarrow},
{"Pr", LM_TK_FUNCLIM, 0},
{"nabla", LM_TK_SYM, LM_nabla},
{"arcsin", LM_TK_FUNC, 0},
{"arctan", LM_TK_FUNC, 0},
{"flat", LM_TK_SYM, LM_flat},
{"check", LM_TK_ACCENT, LM_check},
{"rangle", LM_TK_SYM, LM_rangle},
{"cot", LM_TK_FUNC, 0},
{"cdot", LM_TK_SYM, LM_cdot},
{"clubsuit", LM_TK_SYM, LM_clubsuit},
{"in", LM_TK_SYM, LM_in},
{"ni", LM_TK_SYM, LM_ni},
{"Downarrow", LM_TK_SYM, LM_Downarrow},
{"Upsilon", LM_TK_SYM, LM_Upsilon},
{"sim", LM_TK_SYM, LM_sim},
{"sum", LM_TK_BIGSYM, LM_sum},
{"models", LM_TK_SYM, LM_models},
{"nearrow", LM_TK_SYM, LM_nearrow},
{"nwarrow", LM_TK_SYM, LM_nwarrow},
{"max", LM_TK_FUNCLIM, 0},
{"Im", LM_TK_SYM, LM_Im},
{"lim", LM_TK_FUNCLIM, 0},
{"rightharpoonup", LM_TK_SYM, LM_rightharpoonup},
{"mathcal", LM_TK_FONT, LM_TC_CAL},
{"cap", LM_TK_SYM, LM_cap},
{"cup", LM_TK_SYM, LM_cup},
{"prec", LM_TK_SYM, LM_prec},
{"mathnormal", LM_TK_FONT, LM_TC_VAR},
{"wr", LM_TK_SYM, LM_wr},
{"inf", LM_TK_FUNCLIM, 0},
{"bigoplus", LM_TK_BIGSYM, LM_oplus},
{"biguplus", LM_TK_BIGSYM, LM_biguplus},
{"bigotimes", LM_TK_BIGSYM, LM_otimes},
{"rightarrow", LM_TK_SYM, LM_rightarrow},
{"mathit", LM_TK_FONT, LM_TC_IT},
{"textrm", LM_TK_FONT, LM_TC_TEXTRM},
{"mathtt", LM_TK_FONT, LM_TC_TT},
{"chi", LM_TK_SYM, LM_chi},
{"simeq", LM_TK_SYM, LM_simeq},
{"succeq", LM_TK_SYM, LM_succeq},
{"notin", LM_TK_MACRO, LM_notin},
{"subseteq", LM_TK_SYM, LM_subseteq},
{"supseteq", LM_TK_SYM, LM_supseteq},
{"sqsubseteq", LM_TK_SYM, LM_sqsubseteq},
{"sqsupseteq", LM_TK_SYM, LM_sqsupseteq},
{"leq", LM_TK_SYM, LM_leq},
{"surd", LM_TK_SYM, LM_surd},
{"ddots", LM_TK_DOTS, LM_ddots},
{"mu", LM_TK_SYM, LM_mu},
{"bot", LM_TK_SYM, LM_bot},
{"bullet", LM_TK_SYM, LM_bullet},
{"bigodot", LM_TK_BIGSYM, LM_bigodot},
{"sinh", LM_TK_FUNC, 0},
{"jmath", LM_TK_SYM, LM_jmath},
{"mp", LM_TK_SYM, LM_mp},
{"pm", LM_TK_SYM, LM_pm},
{"nonumber", LM_TK_NONUM, 0},
{"breve", LM_TK_ACCENT, LM_breve},
{"bigvee", LM_TK_BIGSYM, LM_vee},
{"bowtie", LM_TK_SYM, LM_bowtie},
{"bigwedge", LM_TK_BIGSYM, LM_wedge},
{"frown", LM_TK_SYM, LM_frown},
{"rightharpoondown", LM_TK_SYM, LM_rightharpoondown},
{"det", LM_TK_FUNCLIM, 0},
{"dot", LM_TK_ACCENT, LM_dot},
{"ddot", LM_TK_ACCENT, LM_ddot},
{"lg", LM_TK_FUNC, 0},
{"log", LM_TK_FUNC, 0},
{"oplus", LM_TK_SYM, LM_oplus},
{"ominus", LM_TK_SYM, LM_ominus},
{"otimes", LM_TK_SYM, LM_otimes},
{"beta", LM_TK_SYM, LM_beta},
{"diamondsuit", LM_TK_SYM, LM_diamondsuit},
{"rfloor", LM_TK_SYM, LM_rfloor},
{"end", LM_TK_END, 0},
{"hat", LM_TK_ACCENT, LM_hat},
{"tanh", LM_TK_FUNC, 0},
{"vdots", LM_TK_DOTS, LM_vdots},
{"bigcap", LM_TK_BIGSYM, LM_cap},
{"bigcup", LM_TK_BIGSYM, LM_cup},
{"bigsqcup", LM_TK_BIGSYM, LM_bigsqcup},
{"heartsuit", LM_TK_SYM, LM_heartsuit},
{"displaystyle", LM_TK_STY, LM_ST_DISPLAY},
{"longmapsto", LM_TK_SYM, LM_longmapsto},
{"bigtriangleup", LM_TK_SYM, LM_bigtriangleup},
{"preceq", LM_TK_SYM, LM_preceq},
{"delta", LM_TK_SYM, LM_delta},
{"odot", LM_TK_SYM, LM_odot},
{"oint", LM_TK_BIGSYM, LM_oint},
{"grave", LM_TK_ACCENT, LM_grave},
{"pmod", LM_TK_PMOD, 0},
{"prod", LM_TK_BIGSYM, LM_prod},
{"frac", LM_TK_FRAC, 0},
{"csc", LM_TK_FUNC, 0},
{"circ", LM_TK_SYM, LM_circ},
{"aleph", LM_TK_SYM, LM_aleph},
{"min", LM_TK_FUNCLIM, 0},
{"overline", LM_TK_WIDE, LM_overline},
{"arg", LM_TK_FUNC, 0},
{"overbrace", LM_TK_WIDE, LM_overbrace},
{"amalg", LM_TK_SYM, LM_amalg},
{"gamma", LM_TK_SYM, LM_gamma},
{"vee", LM_TK_SYM, LM_vee},
{"equiv", LM_TK_SYM, LM_equiv},
{"omega", LM_TK_SYM, LM_omega},
{"downarrow", LM_TK_SYM, LM_downarrow},
{"imath", LM_TK_SYM, LM_imath},
{"propto", LM_TK_SYM, LM_propto},
{"begin", LM_TK_BEGIN, 0},
{"Lambda", LM_TK_SYM, LM_Lambda},
{"varsigma", LM_TK_SYM, LM_varsigma},
{"vartheta", LM_TK_SYM, LM_vartheta},
{"neq", LM_TK_SYM, LM_neq},
{"hookleftarrow", LM_TK_SYM, LM_hookleftarrow},
{"hookrightarrow", LM_TK_SYM, LM_hookrightarrow},
{"bigtriangledown", LM_TK_SYM, LM_bigtriangledown},
{"mathbf", LM_TK_FONT, LM_TC_BF},
{"mathsf", LM_TK_FONT, LM_TC_SF},
{"bar", LM_TK_ACCENT, LM_bar},
{"varpi", LM_TK_SYM, LM_varpi},
{"varphi", LM_TK_SYM, LM_varphi},
{"newcommand", LM_TK_NEWCOMMAND, 0 },
{"overleftarrow", LM_TK_WIDE, LM_overleftarrow},
{"overrightarrow", LM_TK_WIDE, LM_overightarrow},
{"Leftarrow", LM_TK_SYM, LM_Leftarrow},
{"Longleftarrow", LM_TK_SYM, LM_Longleftarrow},
{"Leftrightarrow", LM_TK_SYM, LM_Leftrightarrow},
{"Longrightarrow", LM_TK_SYM, LM_Longrightarrow},
{"neg", LM_TK_SYM, LM_neg},
{"bigcirc", LM_TK_SYM, LM_bigcirc},
{"Longleftrightarrow", LM_TK_SYM, LM_Longleftrightarrow},
{"dagger", LM_TK_SYM, LM_dagger},
{"ddagger", LM_TK_SYM, LM_ddagger},
{"hbar", LM_TK_SYM, LM_hbar},
{"coprod", LM_TK_BIGSYM, LM_coprod},
{"mathrm", LM_TK_FONT, LM_TC_RM},
{"varepsilon", LM_TK_SYM, LM_varepsilon},
{"cosh", LM_TK_FUNC, 0},
{"coth", LM_TK_FUNC, 0},
{"rho", LM_TK_SYM, LM_rho},
{"cong", LM_TK_SYM, LM_cong},
{"vec", LM_TK_ACCENT, LM_vec},
{"dim", LM_TK_FUNC, 0},
{"mid", LM_TK_SYM, LM_mid},
{"hom", LM_TK_FUNC, 0},
{"bmod", LM_TK_FUNC, 0},
{"quad", LM_TK_SPACE, LM_quad},
{"doteq", LM_TK_SYM, LM_doteq},
{"qquad", LM_TK_SPACE, LM_qquad},
{"mapsto", LM_TK_SYM, LM_mapsto},
{"backslash", LM_TK_SYM, LM_backslash},
{"diamond", LM_TK_SYM, LM_diamond},
{"geq", LM_TK_SYM, LM_geq},
{"deg", LM_TK_FUNC, 0},
{"gcd", LM_TK_FUNCLIM, 0},
{"gg", LM_TK_SYM, LM_gg},
{"div", LM_TK_SYM, LM_div},
{"dashv", LM_TK_SYM, LM_dashv},
{"oslash", LM_TK_SYM, LM_oslash},
{"vdash", LM_TK_SYM, LM_vdash},
};
static short lookup[] =
@ -326,43 +326,43 @@ static short lookup[] =
68, 565, 71, 72, 499, 75, -1, 76, -1, 77, 78, -1, 79, -73,
-2, 80, 81, 82, -1, 83, -1, 84, 85, -1, 86, 87, 88, 89,
90, 501, 93, 94, 95, -1, 96, 493, -1, 99, -97, -2, -91, -2,
100, 101, 102, 517, 105, 106, -1, 107, 108, 109, 110, 497, 113, -1,
114, 115, 116, 117,-111, -2, 118, 491,-119, -2, 121, 122, 123, -1,
124, 125,-103, -2, -1, 126, -69, -2, 491,-127, -2, 129, -55, -2,
130, 491,-131, -2, 133, 492, 136,-134, -2, -1, 137, 138, 139, -42,
100, 101, 102, 517, 105, 106, -1, 107, 108, 109, 110, 497, 113, -1,
114, 115, 116, 117,-111, -2, 118, 491,-119, -2, 121, 122, 123, -1,
124, 125,-103, -2, -1, 126, -69, -2, 491,-127, -2, 129, -55, -2,
130, 491,-131, -2, 133, 492, 136,-134, -2, -1, 137, 138, 139, -42,
-2, 140, 495, 143, 144, -1, 145,-141, -2, -34, -3, 146, 613, 149,
150, 605, 154, 155, 156, 157, 503, -1, 491,-160, -2, 162, -1, 163,
491,-164, -2, -1, 166,-158, -2, 167, 168, -1, 169, 170, -1, 577,
173, -1, 174, 554, -1, 177, -1, 178, 179, 543, 182, 183, 184, -1,
185, 509, 188, 189, 190, 191, 192, 193, 194, 499, -1, 197, 198, -1,
199, 200, 201, 202,-195, -2,-186, -2, 203, -1, 500, 206, 492, 209,
-207, -2, -1, 210, 211, 212,-204, -2, 213, -1, 498, 216, 494, 219,
150, 605, 154, 155, 156, 157, 503, -1, 491,-160, -2, 162, -1, 163,
491,-164, -2, -1, 166,-158, -2, 167, 168, -1, 169, 170, -1, 577,
173, -1, 174, 554, -1, 177, -1, 178, 179, 543, 182, 183, 184, -1,
185, 509, 188, 189, 190, 191, 192, 193, 194, 499, -1, 197, 198, -1,
199, 200, 201, 202,-195, -2,-186, -2, 203, -1, 500, 206, 492, 209,
-207, -2, -1, 210, 211, 212,-204, -2, 213, -1, 498, 216, 494, 219,
-1, 220,-217, -2,-214, -2,-180, -2, 221, 222, 223,-175, -2, -1,
224, -1, 225, 226, -1, 491,-227, -2, 229, -1, 230, 231, 232, 491,
-233, -2,-171, -2,-151, -3, 235, 236, 237,-147, -2, -1, 238, 239,
240, -1, -1, 241, -1, -1, -1, 242, 498, 245, -1, 246, 247, -1,
248, 249,-243, -2, -1, -1, -1, -1, -1, 250, -1, -1, -1, -1,
224, -1, 225, 226, -1, 491,-227, -2, 229, -1, 230, 231, 232, 491,
-233, -2,-171, -2,-151, -3, 235, 236, 237,-147, -2, -1, 238, 239,
240, -1, -1, 241, -1, -1, -1, 242, 498, 245, -1, 246, 247, -1,
248, 249,-243, -2, -1, -1, -1, -1, -1, 250, -1, -1, -1, -1,
-1, 251, 252, -1, -1, -1, 253, -1, -1, -1, 492, 256,-254, -2,
-1, -1, -1, 257, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 258, -1, -1, -1, 491,-259, -2, -1,
-1, -1, -1, -1, -1, -1, -1, 261, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 262, -1, -1, -1, -1, -1, -1, -1, 263, 492, 266,
-264, -2, -1, -1, -1, 267, -1, -1, -1, -1, -1, 268, -1, -1,
269, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 491,-270, -2,
-264, -2, -1, -1, -1, 267, -1, -1, -1, -1, -1, 268, -1, -1,
269, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 491,-270, -2,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272, 273, -1, 274, -1, -1, -1, 275, -1, -1, -1, -1, -1, -1,
276,
272, 273, -1, 274, -1, -1, -1, 275, -1, -1, -1, -1, -1, -1,
276,
};
latexkeys *
in_word_set (register char const *str, register int len)
in_word_set (register char const * str, register int len)
{
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) {
int key = math_hash (str, len);
int const key = math_hash (str, len);
if (key <= MAX_HASH_VALUE && key >= 0) {
int idx = lookup[key];
int const idx = lookup[key];
if (idx >= 0 && idx < MAX_HASH_VALUE) {
char const * s = wordlist[idx].name;
@ -372,7 +372,7 @@ in_word_set (register char const *str, register int len)
} else if (idx < 0 && idx >= -MAX_HASH_VALUE) {
return 0;
} else {
int offset = key + idx + (idx > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
int const offset = key + idx + (idx > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
latexkeys * base = &wordlist[-lookup[offset]];
latexkeys * ptr = base + -lookup[offset + 1];
@ -392,22 +392,22 @@ latexkeys * in_word_set(string const & str)
}
latexkeys *lm_get_key_by_id(int t, short tk)
latexkeys * lm_get_key_by_id(int t, short tk)
{
latexkeys * l = &wordlist[MIN_HASH_VALUE+TOTAL_KEYWORDS];
latexkeys * base = &wordlist[MIN_HASH_VALUE];
while (--l >= base) {
if (t == l->id && tk == l->token)
return l;
}
return 0;
latexkeys * l = &wordlist[MIN_HASH_VALUE+TOTAL_KEYWORDS];
latexkeys * base = &wordlist[MIN_HASH_VALUE];
while (--l >= base) {
if (t == l->id && tk == l->token)
return l;
}
return 0;
}
latexkeys *lm_get_key_by_index(int i)
latexkeys * lm_get_key_by_index(int i)
{
if (i > 0 && i < TOTAL_KEYWORDS + 2)
return &wordlist[i];
else
return 0;
if (i > 0 && i < TOTAL_KEYWORDS + 2)
return &wordlist[i];
else
return 0;
}

125
src/mathed/math_inset.C
View File

@ -36,26 +36,26 @@ int MathedInset::workWidth;
MathedInset::MathedInset(MathedInset * inset)
{
if (inset) {
name = inset->GetName();
objtype = inset->GetType();
size = inset->GetStyle();
width = inset->Width();
ascent = inset->Ascent();
descent = inset->Descent();
} else {
objtype = LM_OT_UNDEF;
size = LM_ST_TEXT;
width = ascent = descent = 0;
//name = 0;
}
if (inset) {
name = inset->GetName();
objtype = inset->GetType();
size_ = inset->GetStyle();
width = inset->Width();
ascent = inset->Ascent();
descent = inset->Descent();
} else {
objtype = LM_OT_UNDEF;
size_ = LM_ST_TEXT;
width = ascent = descent = 0;
//name = 0;
}
}
MathedInset::MathedInset(string const & nm, short ot, short st):
name(nm), objtype(ot), size(st)
MathedInset::MathedInset(string const & nm, short ot, short st)
: name(nm), objtype(ot), size_(st)
{
width = ascent = descent = 0;
width = ascent = descent = 0;
}
@ -65,15 +65,104 @@ void MathedInset::drawStr(Painter & pain, short type, int siz,
{
string st;
if (MathIsBinary(type))
for (string::const_iterator it = s.begin(); it != s.end(); ++it) {
for (string::const_iterator it = s.begin();
it != s.end(); ++it) {
st += ' ';
st += *it;
st += ' ';
}
else
st = s;
LyXFont const mf = mathed_get_font(type, siz);
pain.text(x, y, st, mf);
}
int MathedInset::Ascent() const
{
return ascent;
}
int MathedInset::Descent() const
{
return descent;
}
int MathedInset::Width() const
{
return width;
}
int MathedInset::Height() const
{
return ascent + descent;
}
bool MathedInset::GetLimits() const
{
return false;
}
void MathedInset::SetLimits(bool) {}
string const & MathedInset::GetName() const
{
return name;
}
short MathedInset::GetType() const
{
return objtype;
}
short MathedInset::GetStyle() const
{
return size_;
}
void MathedInset::SetType(short t)
{
objtype = t;
}
void MathedInset::SetStyle(short st)
{
size_ = st;
}
void MathedInset::SetName(string const & n)
{
name = n;
}
void MathedInset::defaultAscent(int da)
{
df_asc = da;
}
void MathedInset::defaultDescent(int dd)
{
df_des = dd;
}
void MathedInset::defaultWidth(int dw)
{
df_width = dw;
}

154
src/mathed/math_inset.h
View File

@ -35,75 +35,91 @@ class Painter;
A math insets is for use of the math editor only, it isn't a
general LyX inset. It's used to represent all the math objects.
The formulaInset (a LyX inset) encapsulates a math inset.
*/
*/
class MathedInset {
public:
/// A math inset has a name (usually its LaTeX name), type and font-size
MathedInset(string const & nm, short ot, short st);
///
explicit
MathedInset(MathedInset *);
///
virtual ~MathedInset() {}
/// Draw the object
virtual void draw(Painter &, int x, int baseline) = 0;
/// Write LaTeX and Lyx code
virtual void Write(std::ostream &, bool fragile) = 0;
/// Reproduces itself
virtual MathedInset * Clone() = 0;
/// Compute the size of the object
virtual void Metrics() = 0;
///
virtual int Ascent() const { return ascent; }
///
virtual int Descent() const { return descent; }
///
virtual int Width() const { return width; }
///
virtual int Height() const { return ascent + descent; }
///
virtual bool GetLimits() const { return false; }
///
virtual void SetLimits(bool) {}
///
string const & GetName() const { return name; }
///
short GetType() const { return objtype; }
///
short GetStyle() const { return size; }
//Man: Avoid to use these functions if it's not strictly necessary
///
virtual void SetType(short t) { objtype = t; }
///
virtual void SetStyle(short st) { size = st; } // Metrics();
///
virtual void SetName(string const & n) { name = n; }
///
static int workWidth;
protected:
///
string name;
///
short objtype;
///
int width;
///
int ascent;
///
int descent;
///
short size;
/// Default metrics
static int df_asc;
///
static int df_des;
///
static int df_width;
/// In a near future maybe we use a better fonts renderer than X
void drawStr(Painter &, short, int, int, int, string const &);
///
friend class MathedCursor;
///
friend void mathed_init_fonts();
public:
/** A math inset has a name (usually its LaTeX name),
type and font-size
*/
MathedInset(string const & nm, short ot, short st);
///
explicit
MathedInset(MathedInset *);
///
virtual ~MathedInset() {}
/// Draw the object
virtual void draw(Painter &, int x, int baseline) = 0;
/// Write LaTeX and Lyx code
virtual void Write(std::ostream &, bool fragile) = 0;
/// Reproduces itself
virtual MathedInset * Clone() = 0;
/// Compute the size of the object
virtual void Metrics() = 0;
///
virtual int Ascent() const;
///
virtual int Descent() const;
///
virtual int Width() const;
///
virtual int Height() const;
///
virtual bool GetLimits() const;
///
virtual void SetLimits(bool);
///
string const & GetName() const;
///
short GetType() const;
///
short GetStyle() const;
//Man: Avoid to use these functions if it's not strictly necessary
///
virtual void SetType(short t);
///
virtual void SetStyle(short st);
///
virtual void SetName(string const & n);
///
static int workWidth;
///
static void defaultAscent(int da);
///
static void defaultDescent(int dd);
///
static void defaultWidth(int dw);
///
short size() const {
return size_;
}
protected:
///
string name;
///
short objtype;
///
int width;
///
int ascent;
///
int descent;
/// Default metrics
static int df_asc;
///
static int df_des;
///
static int df_width;
/// In a near future maybe we use a better fonts renderer than X
void drawStr(Painter &, short, int, int, int, string const &);
///
void size(short s) {
size_ = s;
}
void incSize() {
++size_;
}
private:
///
short size_;
};
#endif

112
src/mathed/math_macro.C
View File

@ -45,29 +45,29 @@ ostream & operator<<(ostream & o, MathedTextCodes mtc)
MathMacro::MathMacro(MathMacroTemplate * t):
MathParInset(LM_ST_TEXT, "", LM_OT_MACRO), tmplate(t)
MathParInset(LM_ST_TEXT, "", LM_OT_MACRO), tmplate_(t)
{
nargs = tmplate->getNoArgs();
tcode = tmplate->getTCode();
args_.resize(nargs);
for (int i = 0; i < nargs; ++i) {
nargs_ = tmplate_->getNoArgs();
tcode_ = tmplate_->getTCode();
args_.resize(nargs_);
for (int i = 0; i < nargs_; ++i) {
args_[i].row = 0;
}
idx = 0;
SetName(tmplate->GetName());
idx_ = 0;
SetName(tmplate_->GetName());
}
MathMacro::MathMacro(MathMacro * m):
MathParInset(LM_ST_TEXT, m->GetName(), LM_OT_MACRO)
{
tmplate = m->tmplate;
nargs = tmplate->getNoArgs();
tcode = tmplate->getTCode();
args_.resize(nargs);
idx = 0;
SetName(tmplate->GetName());
for (int i = 0; i < tmplate->nargs; ++i) {
tmplate_ = m->tmplate_;
nargs_ = tmplate_->getNoArgs();
tcode_ = tmplate_->getTCode();
args_.resize(nargs_);
idx_ = 0;
SetName(tmplate_->GetName());
for (int i = 0; i < tmplate_->getNoArgs(); ++i) {
m->setArgumentIdx(i);
MathedIter it(m->GetData());
args_[i].row = m->args_[i].row;
@ -78,10 +78,10 @@ MathMacro::MathMacro(MathMacro * m):
MathMacro::~MathMacro()
{
for (idx = 0; idx < nargs; ++idx) {
MathedIter it(args_[idx].array);
for (idx_ = 0; idx_ < nargs_; ++idx_) {
MathedIter it(args_[idx_].array);
it.Clear();
delete args_[idx].row;
delete args_[idx_].row;
}
}
@ -94,34 +94,34 @@ MathedInset * MathMacro::Clone()
void MathMacro::Metrics()
{
if (nargs > 0)
tmplate->update(this);
tmplate->SetStyle(size);
tmplate->Metrics();
width = tmplate->Width();
ascent = tmplate->Ascent();
descent = tmplate->Descent();
if (nargs_ > 0)
tmplate_->update(this);
tmplate_->SetStyle(size());
tmplate_->Metrics();
width = tmplate_->Width();
ascent = tmplate_->Ascent();
descent = tmplate_->Descent();
}
void MathMacro::draw(Painter & pain, int x, int y)
{
xo = x;
yo = y;
xo(x);
yo(y);
Metrics();
tmplate->update(this);
tmplate->SetStyle(size);
tmplate->draw(pain, x, y);
for (int i = 0; i < nargs; ++i) {
tmplate->GetMacroXY(i, args_[i].x, args_[i].y);
tmplate_->update(this);
tmplate_->SetStyle(size());
tmplate_->draw(pain, x, y);
for (int i = 0; i < nargs_; ++i) {
tmplate_->GetMacroXY(i, args_[i].x, args_[i].y);
}
}
bool MathMacro::setArgumentIdx(int i)
{
if (i >= 0 && i < nargs) {
idx = i;
if (i >= 0 && i < nargs_) {
idx_ = i;
return true;
} else
return false;
@ -130,52 +130,52 @@ bool MathMacro::setArgumentIdx(int i)
int MathMacro::getArgumentIdx() const
{
return idx;
return idx_;
}
int MathMacro::getMaxArgumentIdx() const
{
return nargs - 1;
return nargs_ - 1;
}
MathedArray * MathMacro::GetData()
{
return args_[idx].array;
return args_[idx_].array;
}
int MathMacro::GetColumns() const
{
return tmplate->getMacroPar(idx)->GetColumns();
return tmplate_->getMacroPar(idx_)->GetColumns();
}
void MathMacro::GetXY(int & x, int & y) const
{
x = args_[idx].x;
y = args_[idx].y;
x = args_[idx_].x;
y = args_[idx_].y;
}
bool MathMacro::Permit(short f) const
{
return (nargs > 0) ?
tmplate->getMacroPar(idx)->Permit(f) : MathParInset::Permit(f);
return (nargs_ > 0) ?
tmplate_->getMacroPar(idx_)->Permit(f) : MathParInset::Permit(f);
}
void MathMacro::SetFocus(int x, int y)
{
tmplate->update(this);
tmplate->SetMacroFocus(idx, x, y);
tmplate_->update(this);
tmplate_->SetMacroFocus(idx_, x, y);
}
void MathMacro::SetData(MathedArray * a)
{
args_[idx].array = a;
args_[idx_].array = a;
}
@ -183,25 +183,25 @@ void MathMacro::SetData(MathedArray * a)
MathedRowSt * MathMacro::getRowSt() const
{
return args_[idx].row;
return args_[idx_].row;
}
MathedTextCodes MathMacro::getTCode() const
{
return tcode;
return tcode_;
}
void MathMacro::Write(ostream & os, bool fragile)
{
if (tmplate->flags & MMF_Exp) {
lyxerr[Debug::MATHED] << "Expand " << tmplate->flags
if (tmplate_->flags() & MMF_Exp) {
lyxerr[Debug::MATHED] << "Expand " << tmplate_->flags()
<< ' ' << MMF_Exp << endl;
tmplate->update(this);
tmplate->Write(os, fragile);
tmplate_->update(this);
tmplate_->Write(os, fragile);
} else {
if (tmplate->flags & MMF_Env) {
if (tmplate_->flags() & MMF_Env) {
os << "\\begin{"
<< name
<< "} ";
@ -214,21 +214,21 @@ void MathMacro::Write(ostream & os, bool fragile)
// file += ']';
// }
if (!(tmplate->flags & MMF_Env) && nargs > 0)
if (!(tmplate_->flags() & MMF_Env) && nargs_ > 0)
os << '{';
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
array = args_[i].array;
MathParInset::Write(os, fragile);
if (i < nargs - 1)
if (i < nargs_ - 1)
os << "}{";
}
if (tmplate->flags & MMF_Env) {
if (tmplate_->flags() & MMF_Env) {
os << "\\end{"
<< name
<< '}';
} else {
if (nargs > 0)
if (nargs_ > 0)
os << '}';
else
os << ' ';

14
src/mathed/math_macro.h
View File

@ -71,7 +71,7 @@ public:
bool Permit(short) const;
private:
///
MathMacroTemplate * tmplate;
MathMacroTemplate * tmplate_;
///
struct MacroArgumentBase {
/// Position of the macro
@ -83,16 +83,16 @@ private:
///
MathedArray * array;
///
MacroArgumentBase() { x = y = 0; array = 0; row = 0; }
MacroArgumentBase()
: x(0), y(0), row(0), array(0)
{}
};
std::vector<MacroArgumentBase> args_;
///
int idx;
int idx_;
///
int nargs;
int nargs_;
///
MathedTextCodes tcode;
///
friend class MathMacroTemplate;
MathedTextCodes tcode_;
};
#endif

9
src/mathed/math_macroarg.C
View File

@ -53,11 +53,10 @@ void MathMacroArgument::draw(Painter & pain, int x, int baseline)
{
if (expnd_mode_) {
MathParInset::draw(pain, x, baseline);
}
else {
} else {
std::ostringstream ost;
ost << '#' << number_;
drawStr(pain, LM_TC_TEX, size, x, baseline, ost.str().c_str());
drawStr(pain, LM_TC_TEX, size(), x, baseline, ost.str().c_str());
}
}
@ -68,8 +67,8 @@ void MathMacroArgument::Metrics()
} else {
std::ostringstream ost;
ost << '#' << number_;
width = mathed_string_width(LM_TC_TEX, size, ost.str().c_str());
mathed_string_height(LM_TC_TEX, size, ost.str().c_str(),
width = mathed_string_width(LM_TC_TEX, size(), ost.str().c_str());
mathed_string_height(LM_TC_TEX, size(), ost.str().c_str(),
ascent, descent);
}
}

74
src/mathed/math_macrotemplate.C
View File

@ -10,34 +10,34 @@ using std::ostream;
void MathMacroTemplate::setTCode(MathedTextCodes t)
{
tcode = t;
tcode_ = t;
}
MathedTextCodes MathMacroTemplate::getTCode() const
{
return tcode;
return tcode_;
}
int MathMacroTemplate::getNoArgs() const
{
return nargs;
return nargs_;
}
MathMacroTemplate::MathMacroTemplate(string const & nm, int na, int flg):
MathParInset(LM_ST_TEXT, nm, LM_OT_MACRO),
flags(flg), nargs(na)
flags_(flg), nargs_(na)
{
if (nargs > 0) {
tcode = LM_TC_ACTIVE_INSET;
args_.resize(nargs);
for (int i = 0; i < nargs; ++i) {
if (nargs_ > 0) {
tcode_ = LM_TC_ACTIVE_INSET;
args_.resize(nargs_);
for (int i = 0; i < nargs_; ++i) {
args_[i].setNumber(i + 1);
}
} else {
tcode = LM_TC_INSET;
tcode_ = LM_TC_INSET;
// Here is nargs != args_.size()
//args = 0;
}
@ -47,7 +47,7 @@ MathMacroTemplate::MathMacroTemplate(string const & nm, int na, int flg):
MathMacroTemplate::~MathMacroTemplate()
{
// prevent to delete already deleted objects
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
args_[i].SetData(0);
}
}
@ -56,14 +56,14 @@ MathMacroTemplate::~MathMacroTemplate()
void MathMacroTemplate::setEditMode(bool ed)
{
if (ed) {
flags |= MMF_Edit;
for (int i = 0; i < nargs; ++i) {
flags_ |= MMF_Edit;
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(false);
}
}
else {
flags &= ~MMF_Edit;
for (int i = 0; i < nargs; ++i) {
flags_ &= ~MMF_Edit;
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(true);
}
}
@ -72,23 +72,27 @@ void MathMacroTemplate::setEditMode(bool ed)
void MathMacroTemplate::draw(Painter & pain, int x, int y)
{
int x2, y2;
bool expnd = (nargs > 0) ? args_[0].getExpand(): false;
if (flags & MMF_Edit) {
for (int i = 0; i < nargs; ++i) {
int x2;
int y2;
bool expnd = (nargs_ > 0) ? args_[0].getExpand(): false;
if (flags_ & MMF_Edit) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(false);
}
x2 = x; y2 = y;
x2 = x;
y2 = y;
} else {
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(true);
}
x2 = xo; y2 = yo;
x2 = xo();
y2 = yo();
}
MathParInset::draw(pain, x, y);
xo = x2; yo = y2;
xo(x2);
yo(y2);
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(expnd);
}
}
@ -96,20 +100,20 @@ void MathMacroTemplate::draw(Painter & pain, int x, int y)
void MathMacroTemplate::Metrics()
{
bool expnd = (nargs > 0) ? args_[0].getExpand(): false;
bool expnd = (nargs_ > 0) ? args_[0].getExpand(): false;
if (flags & MMF_Edit) {
for (int i = 0; i < nargs; ++i) {
if (flags_ & MMF_Edit) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(false);
}
} else {
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(true);
}
}
MathParInset::Metrics();
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(expnd);
}
}
@ -118,7 +122,7 @@ void MathMacroTemplate::Metrics()
void MathMacroTemplate::update(MathMacro * macro)
{
int idx = (macro) ? macro->getArgumentIdx() : 0;
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
if (macro) {
macro->setArgumentIdx(i);
args_[i].SetData(macro->GetData());
@ -135,15 +139,15 @@ void MathMacroTemplate::WriteDef(ostream & os, bool fragile)
{
os << "\n\\newcommand{\\" << name << "}";
if (nargs > 0 )
os << "[" << nargs << "]";
if (nargs_ > 0 )
os << "[" << nargs_ << "]";
os << "{";
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
args_[i].setExpand(false);
}
Write(os, fragile);
Write(os, fragile);
os << "}\n";
}
@ -162,7 +166,7 @@ void MathMacroTemplate::GetMacroXY(int i, int & x, int & y) const
MathParInset * MathMacroTemplate::getMacroPar(int i) const
{
if (i >= 0 && i < nargs)
if (i >= 0 && i < nargs_)
return const_cast<MathParInset *>
(static_cast<MathParInset const *>(&args_[i]));
else
@ -172,7 +176,7 @@ MathParInset * MathMacroTemplate::getMacroPar(int i) const
void MathMacroTemplate::SetMacroFocus(int &idx, int x, int y)
{
for (int i = 0; i < nargs; ++i) {
for (int i = 0; i < nargs_; ++i) {
if (args_[i].Inside(x, y)) {
idx = i;
break;

86
src/mathed/math_macrotemplate.h
View File

@ -10,48 +10,50 @@
class MathMacro;
/// This class contains the macro definition
class MathMacroTemplate: public MathParInset {
public:
/// A template constructor needs all the data
explicit
MathMacroTemplate(string const &, int na = 0, int f = 0);
///
~MathMacroTemplate();
///
void draw(Painter &, int, int);
///
void Metrics();
///
void WriteDef(std::ostream &, bool fragile);
/// useful for special insets
void setTCode(MathedTextCodes t);
///
MathedTextCodes getTCode() const;
///
void setArgument(MathedArray *, int i= 0);
/// Number of arguments
int getNoArgs() const;
///
void GetMacroXY(int, int &, int &) const;
///
MathParInset * getMacroPar(int) const;
///
void SetMacroFocus(int &, int, int);
///
void setEditMode(bool);
/// Replace the appropriate arguments with a specific macro's data
void update(MathMacro * m = 0);
class MathMacroTemplate : public MathParInset {
public:
/// A template constructor needs all the data
explicit
MathMacroTemplate(string const &, int na = 0, int f = 0);
///
~MathMacroTemplate();
///
void draw(Painter &, int, int);
///
void Metrics();
///
void WriteDef(std::ostream &, bool fragile);
/// useful for special insets
void setTCode(MathedTextCodes t);
///
MathedTextCodes getTCode() const;
///
void setArgument(MathedArray *, int i= 0);
/// Number of arguments
int getNoArgs() const;
///
void GetMacroXY(int, int &, int &) const;
///
MathParInset * getMacroPar(int) const;
///
void SetMacroFocus(int &, int, int);
///
void setEditMode(bool);
/// Replace the appropriate arguments with a specific macro's data
void update(MathMacro * m = 0);
///
short flags() const {
return flags_;
}
private:
///
short flags;
///
MathedTextCodes tcode;
///
std::vector<MathMacroArgument> args_;
///
int nargs;
///
friend class MathMacro;
///
short flags_;
///
MathedTextCodes tcode_;
///
std::vector<MathMacroArgument> args_;
///
int nargs_;
};
#endif

192
src/mathed/math_panel.h
View File

@ -25,113 +25,125 @@
///
enum SomeMathValues {
///
MM_GREEK,
///
MM_ARROW,
///
MM_BOP,
///
MM_BRELATS,
///
MM_VARSIZE,
///
MM_MISC,
///
MM_FRAC,
///
MM_SQRT,
///
MM_DELIM,
///
MM_MATRIX,
///
MM_EQU,
///
MM_DECO,
///
MM_SPACE,
///
MM_DOTS,
///
MM_FUNC,
///
MM_MAX,
///
MM_CLOSE = 1024,
///
MM_APPLY,
///
MM_OK
///
MM_GREEK,
///
MM_ARROW,
///
MM_BOP,
///
MM_BRELATS,
///
MM_VARSIZE,
///
MM_MISC,
///
MM_FRAC,
///
MM_SQRT,
///
MM_DELIM,
///
MM_MATRIX,
///
MM_EQU,
///
MM_DECO,
///
MM_SPACE,
///
MM_DOTS,
///
MM_FUNC,
///
MM_MAX,
///
MM_CLOSE = 1024,
///
MM_APPLY,
///
MM_OK
};
///
/// Class to manage bitmap menu bars
class BitmapMenu {
///
static BitmapMenu * active;
///
friend int peek_event(FL_FORM *, void *);
///
typedef std::vector<FL_OBJECT *> bitmaps_type;
///
typedef bitmaps_type::size_type size_type;
///
BitmapMenu * next, * prev;
/// Current bitmap
size_type current_;
/// Border width
int ww;
///
int x, y, w, h;
///
FL_FORM * form;
///
bitmaps_type bitmaps_;
///
FL_OBJECT * button;
public:
///
BitmapMenu(int n, FL_OBJECT * bt, BitmapMenu * prevx= 0);
///
~BitmapMenu();
///
FL_OBJECT * AddBitmap(int id,
int nx, int ny, int bw, int bh,
unsigned char const * data,
Bool vert= True); // Why Bool?
///
void Create();
///
void Hide();
///
void Show();
///
void Prev();
///
void Next();
///
int GetIndex(FL_OBJECT * ob);
///
static BitmapMenu * active;
///
friend int peek_event(FL_FORM *, void *);
///
typedef std::vector<FL_OBJECT *> bitmaps_type;
///
typedef bitmaps_type::size_type size_type;
///
BitmapMenu * next, * prev;
/// Current bitmap
size_type current_;
/// Border width
int ww;
///
int x;
///
int y;
///
int w;
///
int h;
///
FL_FORM * form;
///
bitmaps_type bitmaps_;
///
FL_OBJECT * button;
public:
///
BitmapMenu(int n, FL_OBJECT * bt, BitmapMenu * prevx= 0);
///
~BitmapMenu();
///
FL_OBJECT * AddBitmap(int id,
int nx, int ny, int bw, int bh,
unsigned char const * data,
Bool vert = True); // Why Bool?
///
void Create();
///
void Hide();
///
void Show();
///
void Prev();
///
void Next();
///
int GetIndex(FL_OBJECT * ob);
};
/// This is just a wrapper around peek_event()
extern "C" int C_peek_event(FL_FORM * form, void * ptr);
inline
void BitmapMenu::Prev() {
Hide();
if (prev)
prev->Show();
void BitmapMenu::Prev()
{
Hide();
if (prev)
prev->Show();
}
inline
void BitmapMenu::Next() {
Hide();
if (next)
next->Show();
void BitmapMenu::Next()
{
Hide();
if (next)
next->Show();
}
#include "math_forms.h"
///

39
src/mathed/math_parinset.C
View File

@ -85,10 +85,12 @@ MathParInset::draw(Painter & pain, int x, int y)
{
byte cxp = 0;
int xp = 0;
int asc = df_asc, des = 0;
int asc = df_asc;
int des = 0;
bool limits = false;
xo = x; yo = y;
xo_ = x;
yo_ = y;
if (!array || array->empty()) {
if (array) {
MathedXIter data(this);
@ -104,8 +106,8 @@ MathParInset::draw(Painter & pain, int x, int y)
byte cx = data.GetChar();
if (cx >= ' ') {
string s = data.GetString();
drawStr(pain, data.FCode(), size, x, y, s);
mathed_char_height(LM_TC_CONST, size, 'y', asc, des);
drawStr(pain, data.FCode(), size(), x, y, s);
mathed_char_height(LM_TC_CONST, size(), 'y', asc, des);
limits = false;
}
else {
@ -195,15 +197,16 @@ MathParInset::Metrics()
cx = data.GetChar();
if (cx >= ' ') {
string s = data.GetString();
mathed_string_height(data.FCode(), size, s, asc, des);
mathed_string_height(data.FCode(),
size(), s, asc, des);
if (asc > ascent) ascent = asc;
if (des > descent) descent = des;
limits = false;
mathed_char_height(LM_TC_CONST, size, 'y', asc, des);
mathed_char_height(LM_TC_CONST, size(), 'y', asc, des);
} else
if (MathIsInset(cx)) {
MathedInset * p = data.GetInset();
p->SetStyle(size);
p->SetStyle(size());
p->Metrics();
if (cx == LM_TC_UP) {
asc += (limits) ? p->Height() + 4: p->Ascent() +
@ -290,7 +293,7 @@ void MathParInset::Write(ostream & os, bool fragile)
data.Reset();
if (!Permit(LMPF_FIXED_SIZE)) {
l = lm_get_key_by_id(size, LM_TK_STY);
l = lm_get_key_by_id(size(), LM_TK_STY);
if (l) {
os << '\\' << l->name << ' ';
}
@ -397,22 +400,22 @@ void MathParInset::Write(ostream & os, bool fragile)
bool MathParInset::Inside(int x, int y)
{
return (x >= xo && x <= xo + width
&& y <= yo + descent && y >= yo - ascent);
return (x >= xo() && x <= xo() + width
&& y <= yo() + descent && y >= yo() - ascent);
}
void MathParInset::GetXY(int & x, int & y) const
{
x = xo;
y = yo;
x = xo();
y = yo();
}
void MathParInset::UserSetSize(short sz)
{
if (sz >= 0) {
size = sz;
size(sz);
flag = flag & ~LMPF_FIXED_SIZE;
}
}
@ -431,12 +434,6 @@ void MathParInset::SetStyle(short sz)
}
void MathParInset::setFlag(MathedParFlag f)
{
flag |= f;
}
bool MathParInset::Permit(short f) const
{
return bool(f & flag);
@ -451,6 +448,6 @@ MathedArray * MathParInset::GetData()
void MathParInset::setXY(int x, int y)
{
xo = x;
yo = y;
xo_ = x;
yo_ = y;
}

164
src/mathed/math_parinset.h
View File

@ -11,86 +11,88 @@ class MathedArray;
/** The math paragraph base class, base to all editable math objects */
class MathParInset: public MathedInset {
public:
///
MathParInset(short st = LM_ST_TEXT, string const & nm = string(),
short ot = LM_OT_MIN);
///
explicit
MathParInset(MathParInset *);
///
virtual ~MathParInset();
///
virtual MathedInset * Clone();
/// Draw the object on a drawable
virtual void draw(Painter &, int x, int baseline);
/// Write LaTeX code
virtual void Write(std::ostream &, bool fragile);
///
virtual void Metrics();
///
virtual void UserSetSize(short);
/// Data is stored in a LyXArray
virtual void SetData(MathedArray *);
///
virtual MathedArray * GetData();
/// Paragraph position
virtual void GetXY(int &, int &) const;
///
virtual void setXY(int x, int y);
///
virtual void SetFocus(int, int) {}
///
virtual bool Inside(int, int);
// Tab stuff used by Matrix.
///
virtual void SetAlign(char, string const &) {}
///
virtual int GetColumns() const { return 1; }
///
virtual int GetRows() const { return 1; }
///
virtual bool isMatrix() const { return false; }
// Vertical switching
///
virtual bool setArgumentIdx(int i) { return (i == 0); }
///
virtual bool setNextArgIdx() { return false; }
///
virtual int getArgumentIdx() const { return 0; }
///
virtual int getMaxArgumentIdx() const { return 0; }
///
virtual void SetStyle(short);
///
virtual MathedRowSt * getRowSt() const;
///
virtual void setRowSt(MathedRowSt *) {}
///
virtual bool Permit(short f) const;
protected:
/// Paragraph data is stored here
MathedArray * array;
/// Cursor start position
int xo;
///
int yo;
///
short flag;
private:
///
virtual void setFlag(MathedParFlag f);
///
friend class InsetFormula;
///
friend class MathedXIter;
///
friend class MathedCursor;
///
friend MathedArray * mathed_parse(unsigned flags = 0,
MathedArray * a = 0,
MathParInset ** p = 0);
public:
///
MathParInset(short st = LM_ST_TEXT, string const & nm = string(),
short ot = LM_OT_MIN);
///
explicit
MathParInset(MathParInset *);
///
virtual ~MathParInset();
///
virtual MathedInset * Clone();
/// Draw the object on a drawable
virtual void draw(Painter &, int x, int baseline);
/// Write LaTeX code
virtual void Write(std::ostream &, bool fragile);
///
virtual void Metrics();
///
virtual void UserSetSize(short);
/// Data is stored in a LyXArray
virtual void SetData(MathedArray *);
///
virtual MathedArray * GetData();
/// Paragraph position
virtual void GetXY(int &, int &) const;
///
virtual void setXY(int x, int y);
///
virtual void SetFocus(int, int) {}
///
virtual bool Inside(int, int);
// Tab stuff used by Matrix.
///
virtual void SetAlign(char, string const &) {}
///
virtual int GetColumns() const { return 1; }
///
virtual int GetRows() const { return 1; }
///
virtual bool isMatrix() const { return false; }
// Vertical switching
///
virtual bool setArgumentIdx(int i) { return (i == 0); }
///
virtual bool setNextArgIdx() { return false; }
///
virtual int getArgumentIdx() const { return 0; }
///
virtual int getMaxArgumentIdx() const { return 0; }
///
virtual void SetStyle(short);
///
virtual MathedRowSt * getRowSt() const;
///
virtual void setRowSt(MathedRowSt *) {}
///
virtual bool Permit(short f) const;
///
int xo() const {
return xo_;
}
///
int yo() const {
return yo_;
}
protected:
/// Paragraph data is stored here
MathedArray * array;
///
short flag;
///
void xo(int tx) {
xo_ = tx;
}
///
void yo(int ty) {
yo_ = ty;
}
private:
/// Cursor start position
int xo_;
///
int yo_;
};
#endif

4
src/mathed/math_parser.C
View File

@ -390,8 +390,8 @@ MathedInset * doAccent(MathedInset * p)
}
MathedArray * mathed_parse(unsigned flags, MathedArray * array,
MathParInset ** mtx)
MathedArray * mathed_parse(unsigned flags = 0, MathedArray * array = 0,
MathParInset ** mtx = 0)
{
int t = yylex();
int tprev = 0;

104
src/mathed/math_root.C
View File

@ -28,113 +28,113 @@ using std::ostream;
MathRootInset::MathRootInset(short st)
: MathSqrtInset(st)
{
idx = 1;
uroot = new MathParInset(LM_ST_TEXT);
idx = 1;
uroot = new MathParInset(LM_ST_TEXT);
}
MathRootInset::~MathRootInset()
{
delete uroot;
delete uroot;
}
MathedInset * MathRootInset::Clone()
{
MathRootInset * p = new MathRootInset(GetStyle());
MathedIter it(array), itr(uroot->GetData());
p->SetData(it.Copy());
p->setArgumentIdx(0);
p->SetData(itr.Copy());
return p;
MathRootInset * p = new MathRootInset(GetStyle());
MathedIter it(array), itr(uroot->GetData());
p->SetData(it.Copy());
p->setArgumentIdx(0);
p->SetData(itr.Copy());
return p;
}
void MathRootInset::SetData(MathedArray * d)
{
if (idx == 1)
MathParInset::SetData(d);
else {
uroot->SetData(d);
}
if (idx == 1)
MathParInset::SetData(d);
else {
uroot->SetData(d);
}
}
bool MathRootInset::setArgumentIdx(int i)
{
if (i == 0 || i == 1) {
idx = i;
return true;
} else
return false;
if (i == 0 || i == 1) {
idx = i;
return true;
} else
return false;
}
void MathRootInset::GetXY(int & x, int & y) const
{
if (idx == 1)
MathParInset::GetXY(x, y);
else
uroot->GetXY(x, y);
if (idx == 1)
MathParInset::GetXY(x, y);
else
uroot->GetXY(x, y);
}
MathedArray * MathRootInset::GetData()
{
if (idx == 1)
return array;
else
return uroot->GetData();
if (idx == 1)
return array;
else
return uroot->GetData();
}
bool MathRootInset::Inside(int x, int y)
{
return (uroot->Inside(x, y) || MathSqrtInset::Inside(x, y));
return (uroot->Inside(x, y) || MathSqrtInset::Inside(x, y));
}
void MathRootInset::Metrics()
{
int idxp = idx;
idx = 1;
MathSqrtInset::Metrics();
uroot->Metrics();
wroot = uroot->Width();
dh = Height()/2;
width += wroot;
// if (uroot->Ascent() > dh)
if (uroot->Height() > dh)
ascent += uroot->Height() - dh;
dh -= descent - uroot->Descent();
idx = idxp;
int idxp = idx;
idx = 1;
MathSqrtInset::Metrics();
uroot->Metrics();
wroot = uroot->Width();
dh = Height()/2;
width += wroot;
// if (uroot->Ascent() > dh)
if (uroot->Height() > dh)
ascent += uroot->Height() - dh;
dh -= descent - uroot->Descent();
idx = idxp;
}
void MathRootInset::draw(Painter & pain, int x, int y)
{
int idxp = idx;
idx = 1;
uroot->draw(pain, x, y - dh);
MathSqrtInset::draw(pain, x + wroot, y);
idx = idxp;
int idxp = idx;
idx = 1;
uroot->draw(pain, x, y - dh);
MathSqrtInset::draw(pain, x + wroot, y);
idx = idxp;
}
void MathRootInset::SetStyle(short st)
{
MathSqrtInset::SetStyle(st);
uroot->SetStyle((size<LM_ST_SCRIPTSCRIPT) ? size+1: size);
MathSqrtInset::SetStyle(st);
uroot->SetStyle((size() < LM_ST_SCRIPTSCRIPT) ? size() + 1 : size());
}
void MathRootInset::SetFocus(int x, int)
{
idx = (x > xo + wroot) ? 1: 0;
idx = (x > xo() + wroot) ? 1: 0;
}

10
src/mathed/math_sqrtinset.C
View File

@ -24,10 +24,10 @@ MathedInset * MathSqrtInset::Clone()
bool MathSqrtInset::Inside(int x, int y)
{
return x >= xo - hmax
&& x <= xo + width - hmax
&& y <= yo + descent
&& y >= yo - ascent;
return x >= xo() - hmax
&& x <= xo() + width - hmax
&& y <= yo() + descent
&& y >= yo() - ascent;
}
@ -55,7 +55,7 @@ MathSqrtInset::Metrics()
ascent += 4;
descent += 2;
int a, b;
hmax = mathed_char_height(LM_TC_VAR, size, 'I', a, b);
hmax = mathed_char_height(LM_TC_VAR, size(), 'I', a, b);
if (hmax < 10) hmax = 10;
wbody = width + 4;
width += hmax + 4;

1
src/mathed/math_xiter.h
View File

@ -103,7 +103,6 @@ protected:
///
MathedRowSt * crow;
private:
///
friend class MathedCursor;
};

52
src/mathed/matriz.C
View File

@ -4,57 +4,55 @@
#include "matriz.h"
inline
static inline
int odd(int x) { return ((x) & 1); }
typedef float matriz_data[2][2];
const matriz_data MATIDEN= { {1, 0}, {0, 1}};
#define mateq(m1, m2) memcpy(m1, m2, sizeof(matriz_data))
Matriz::matriz_data const Matriz::MATIDEN = { {1, 0}, {0, 1}};
Matriz::Matriz()
{
mateq(m, MATIDEN);
mateq(m_, MATIDEN);
}
void Matriz::rota(int code)
{
float cs, sn;
matriz_data r;
mateq(r, MATIDEN);
cs = (odd(code)) ? 0: 1 - code;
sn = (odd(code)) ? 2 - code: 0;
r[0][0] = cs; r[0][1] = sn;
r[1][0] = -r[0][1]; r[1][1] = r[0][0];
matmat(r);
matriz_data r;
mateq(r, MATIDEN);
float const cs = (odd(code)) ? 0 : (1 - code);
float const sn = (odd(code)) ? (2 - code) : 0;
r[0][0] = cs; r[0][1] = sn;
r[1][0] = -r[0][1]; r[1][1] = r[0][0];
matmat(r);
}
void Matriz::escala(float x, float y)
{
matriz_data s;
mateq(s, MATIDEN);
s[0][0] = x; s[1][1] = y;
matmat(s);
matriz_data s;
mateq(s, MATIDEN);
s[0][0] = x; s[1][1] = y;
matmat(s);
}
void Matriz::matmat(matriz_data & a)
{
matriz_data c;
for (int i = 0;i < 2; ++i) {
c[0][i] = a[0][0] * m[0][i] + a[0][1] * m[1][i];
c[1][i] = a[1][0] * m[0][i] + a[1][1] * m[1][i];
}
mateq(m, c);
matriz_data c;
for (int i = 0; i < 2; ++i) {
c[0][i] = a[0][0] * m_[0][i] + a[0][1] * m_[1][i];
c[1][i] = a[1][0] * m_[0][i] + a[1][1] * m_[1][i];
}
mateq(m_, c);
}
void Matriz::transf(float xp, float yp, float & x, float & y)
{
x = m[0][0] * xp + m[0][1] * yp;
y = m[1][0] * xp + m[1][1] * yp;
x = m_[0][0] * xp + m_[0][1] * yp;
y = m_[1][0] * xp + m_[1][1] * yp;
}

29
src/mathed/matriz.h
View File

@ -3,17 +3,26 @@
#ifndef MATH_MATRIZ_H
#define MATH_MATRIZ_H
typedef float matriz_data[2][2];
///
class Matriz {
public:
Matriz();
void rota(int);
void escala(float, float);
void transf(float, float, float &, float &);
protected:
matriz_data m;
void matmat(matriz_data & a);
public:
///
typedef float matriz_data[2][2];
///
Matriz();
///
void rota(int);
///
void escala(float, float);
///
void transf(float, float, float &, float &);
private:
///
matriz_data m_;
///
void matmat(matriz_data & a);
///
static matriz_data const MATIDEN;
};
#endif

2
src/mathed/support.C
View File

@ -376,7 +376,7 @@ void mathed_draw_deco(Painter & pain, int x, int y, int w, int h, int code)
mt.rota(r);
mt.escala(w, h);
int n = (w < h) ? w: h;
int n = (w < h) ? w : h;
sqmt.rota(r);
sqmt.escala(n, n);
if (r > 0 && r < 3) y += h;