lyx_mirror/src/mathed/math_support.C

#include <config.h>

#include <map>

#include "math_support.h"
#include "lyxfont.h"
#include "frontends/font_loader.h"
#include "frontends/font_metrics.h"
#include "math_cursor.h"
#include "math_defs.h"
#include "math_inset.h"
#include "math_parser.h"
#include "frontends/Painter.h"
#include "debug.h"
#include "commandtags.h"

using std::map;
using std::endl;
using std::max;


///
class Matrix {
public:
	///
	Matrix(int, double, double);
	///
	void transform(double &, double &);
private:
	///
	double m_[2][2];
};


Matrix::Matrix(int code, double x, double y)
{
	double const cs = (code & 1) ? 0 : (1 - code);
	double const sn = (code & 1) ? (2 - code) : 0;
	m_[0][0] =  cs * x;
	m_[0][1] =  sn * x;
	m_[1][0] = -sn * y;
	m_[1][1] =  cs * y;
}


void Matrix::transform(double & x, double & y)
{
	double xx = m_[0][0] * x + m_[0][1] * y;
	double yy = m_[1][0] * x + m_[1][1] * y;
	x = xx;
	y = yy;
}



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
 */


double const parenthHigh[] = {
	2, 13,
	0.9840, 0.0014, 0.7143, 0.0323, 0.4603, 0.0772,
	0.2540, 0.1278, 0.1746, 0.1966, 0.0952, 0.3300,
	0.0950, 0.5000, 0.0952, 0.6700, 0.1746, 0.8034,
	0.2540, 0.8722, 0.4603, 0.9228, 0.7143, 0.9677,
	0.9840, 0.9986,
	0
};


double const parenth[] = {
	2, 13,
	0.9930, 0.0071, 0.7324, 0.0578, 0.5141, 0.1126,
	0.3380, 0.1714, 0.2183, 0.2333, 0.0634, 0.3621,
	0.0141, 0.5000, 0.0563, 0.6369, 0.2113, 0.7647,
	0.3310, 0.8276, 0.5070, 0.8864, 0.7254, 0.9412,
	0.9930, 0.9919,
	0
};


double const brace[] = {
	2, 21,
	0.9492, 0.0020, 0.9379, 0.0020, 0.7458, 0.0243,
	0.5819, 0.0527, 0.4859, 0.0892, 0.4463, 0.1278,
	0.4463, 0.3732, 0.4011, 0.4199, 0.2712, 0.4615,
	0.0734, 0.4919, 0.0113, 0.5000, 0.0734, 0.5081,
	0.2712, 0.5385, 0.4011, 0.5801, 0.4463, 0.6268,
	0.4463, 0.8722, 0.4859, 0.9108, 0.5819, 0.9473,
	0.7458, 0.9757, 0.9379, 0.9980, 0.9492, 0.9980,
	0
};


double const arrow[] = {
	4, 7,
	0.0150, 0.7500, 0.2000, 0.6000, 0.3500, 0.3500,
	0.5000, 0.0500, 0.6500, 0.3500, 0.8000, 0.6000,
	0.9500, 0.7500,
	3, 0.5000, 0.1500, 0.5000, 0.9500,
	0
};


double const Arrow[] = {
	4, 7,
	0.0150, 0.7500, 0.2000, 0.6000, 0.3500, 0.3500,
	0.5000, 0.0500, 0.6500, 0.3500, 0.8000, 0.6000,
	0.9500, 0.7500,
	3, 0.3500, 0.5000, 0.3500, 0.9500,
	3, 0.6500, 0.5000, 0.6500, 0.9500,
	0
};


double const udarrow[] = {
	2, 3,
	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,
	0
};


double const Udarrow[] = {
	2, 3,
	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.35, 0.2, 0.35, 0.8,
	1, 0.65, 0.2, 0.65, 0.8,
	0
};


double const brack[] = {
	2, 4,
	0.95, 0.05,  0.05, 0.05,  0.05, 0.95,  0.95, 0.95,
	0
};


double const corner[] = {
	2, 3,
	0.95, 0.05,  0.05, 0.05,  0.05, 0.95,
	0
};


double const angle[] = {
	2, 3,
	1, 0,  0.05, 0.5,  1, 1,
	0
};


double const slash[] = {
	1, 0.95, 0.05, 0.05, 0.95,
	0
};


double const hline[] = {
	1, 0.00, 0.5, 1.0, 0.5,
	0
};


double const ddot[] = {
	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.45, 0.5, 0.55, 0.5,
	1, 0.8, 0.5,  0.9, 0.5,
	0
};


double const hline3[] = {
	1, 0.1,   0,  0.15,  0,
	1, 0.475, 0,  0.525, 0,
	1, 0.85,  0,  0.9,   0,
	0
};


double const dline3[] = {
	1, 0.1,   0.1,   0.15,  0.15,
	1, 0.475, 0.475, 0.525, 0.525,
	1, 0.85,  0.85,  0.9,   0.9,
	0
};


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,
	0
};


double const vert[] = {
	1, 0.5, 0.05,  0.5, 0.95,
	0
};


double const  Vert[] = {
	1, 0.3, 0.05,  0.3, 0.95,
	1, 0.7, 0.05,  0.7, 0.95,
	0
};


double const tilde[] = {
	2, 4,
	0.05, 0.8,  0.25, 0.2,  0.75, 0.8,  0.95, 0.2,
	0
};


struct deco_struct {
	double const * data;
	int angle;
};

struct named_deco_struct {
	char const * name;
	double const * data;
	int angle;
};

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 },

	// Delimiters
	{"(",              parenth,    0 },
	{")",              parenth,    2 },
	{"{",              brace,      0 },
	{"}",              brace,      2 },
	{"[",              brack,      0 },
	{"]",              brack,      2 },
	{"|",              vert,       0 },
	{"/",              slash,      0 },
	{"vert",           vert,       0 },
	{"Vert",           Vert,       0 },
	{"'",              slash,      1 },
	{"backslash",      slash,      1 },
	{"langle",         angle,      0 },
	{"lceil",          corner,     0 },
	{"lfloor",         corner,     1 },
	{"rangle",         angle,      2 },
	{"rceil",          corner,     3 },
	{"rfloor",         corner,     2 },
	{"downarrow",      arrow,      2 },
	{"Downarrow",      Arrow,      2 },
	{"uparrow",        arrow,      0 },
	{"Uparrow",        Arrow,      0 },
	{"updownarrow",    udarrow,    0 },
	{"Updownarrow",    Udarrow,    0 },

	// Accents
	{"ddot",           ddot,       0 },
	{"dddot",          dddot,      0 },
	{"hat",            angle,      3 },
	{"grave",          slash,      1 },
	{"acute",          slash,      0 },
	{"tilde",          tilde,      0 },
	{"bar",            hline,      0 },
	{"dot",            hlinesmall, 0 },
	{"check",          angle,      1 },
	{"breve",          parenth,    1 },
	{"vec",            arrow,      3 },
	{"not",            slash,      0 },
	{"mathring",       ring,       0 },

	// Dots
	{"ldots",          hline3,     0 },
	{"cdots",          hline3,     0 },
	{"vdots",          hline3,     1 },
	{"ddots",          dline3,     0 },
	{"dotsb",          hline3,     0 },
	{"dotsc",          hline3,     0 },
	{"dotsi",          hline3,     0 },
	{"dotsm",          hline3,     0 },
	{"dotso",          hline3,     0 }
};


map<string, deco_struct> deco_list;

// sort the table on startup
struct init_deco_table {
	init_deco_table() {
		unsigned const n = sizeof(deco_table) / sizeof(deco_table[0]);
		for (named_deco_struct * p = deco_table; p != deco_table + n; ++p) {
			deco_struct d;
			d.data  = p->data;
			d.angle = p->angle;
			deco_list[p->name]= d;
		}
	}
};

static init_deco_table dummy;


deco_struct const * search_deco(string const & name)
{
	map<string, deco_struct>::const_iterator p = deco_list.find(name);
	return (p == deco_list.end()) ? 0 : &(p->second);
}


} // namespace anon


void mathed_char_dim(LyXFont const & font,
	unsigned char c, int & asc, int & des, int & wid)
{
	des = font_metrics::descent(c, font);
	asc = font_metrics::ascent(c, font);
	wid = mathed_char_width(font, c);
}


int mathed_char_ascent(LyXFont const & font, unsigned char c)
{
	return font_metrics::ascent(c, font);
}


int mathed_char_descent(LyXFont const & font, unsigned char c)
{
	return font_metrics::descent(c, font);
}


int mathed_char_width(LyXFont const & font, unsigned char c)
{
	return font_metrics::width(c, font);
}


void mathed_string_dim(LyXFont const & font,
	string const & s, int & asc, int & des, int & wid)
{
	asc = des = 0;
	for (string::const_iterator it = s.begin(); it != s.end(); ++it) {
		des = max(des, font_metrics::descent(*it, font));
		asc = max(asc, font_metrics::ascent(*it, font));
	}
	wid = font_metrics::width(s, font);
}


int mathed_string_width(LyXFont const & font, string const & s)
{
	return font_metrics::width(s, font);
}


int mathed_string_ascent(LyXFont const & font, string const & s)
{
	int asc = 0;
	for (string::const_iterator it = s.begin(); it != s.end(); ++it)
		asc = max(asc, font_metrics::ascent(*it, font));
	return asc;
}


int mathed_string_descent(LyXFont const & font, string const & s)
{
	int des = 0;
	for (string::const_iterator it = s.begin(); it != s.end(); ++it)
		des = max(des, font_metrics::descent(*it, font));
	return des;
}



void mathed_draw_deco(MathPainterInfo & pain, int x, int y, int w, int h,
	const string & name)
{
	if (name == ".") {
		pain.pain.line(x + w/2, y, x + w/2, y + h,
			  LColor::mathcursor, Painter::line_onoffdash);
		return;
	}

	deco_struct const * mds = search_deco(name);
	if (!mds) {
		lyxerr << "Deco was not found. Programming error?\n";
		lyxerr << "name: '" << name << "'\n";
		return;
	}

	int const n = (w < h) ? w : h;
	int const r = mds->angle;
	double const * d = mds->data;

	if (h > 70 && (name == "(" || name == ")"))
		d = parenthHigh;

	Matrix mt(r, w, h);
	Matrix sqmt(r, n, n);

	if (r > 0 && r < 3)
		y += h;

	if (r >= 2)
		x += w;

	for (int i = 0; d[i]; ) {
		int code = int(d[i++]);
		if (code & 1) {  // code == 1 || code == 3
			double xx = d[i++];
			double yy = d[i++];
			double x2 = d[i++];
			double y2 = d[i++];
			if (code == 3)
				sqmt.transform(xx, yy);
			else
				mt.transform(xx, yy);
			mt.transform(x2, y2);
			pain.pain.line(
				x + int(xx + 0.5), y + int(yy + 0.5),
				x + int(x2 + 0.5), y + int(y2 + 0.5),
				LColor::math);
		}	else {
			int xp[32];
			int yp[32];
			int const n = int(d[i++]);
			for (int j = 0; j < n; ++j) {
				double xx = d[i++];
				double yy = d[i++];
//	     lyxerr << " " << xx << " " << yy << " ";
				if (code == 4)
					sqmt.transform(xx, yy);
				else
					mt.transform(xx, yy);
				xp[j] = x + int(xx + 0.5);
				yp[j] = y + int(yy + 0.5);
				//  lyxerr << "P[" << j " " << xx << " " << yy << " " << x << " " << y << "]";
			}
			pain.pain.lines(xp, yp, n, LColor::math);
		}
	}
}


void mathed_draw_framebox(MathPainterInfo & pain, int x, int y, MathInset const * p)
{
	if (mathcursor && mathcursor->isInside(p))
		pain.pain.rectangle(x, y - p->ascent(), p->width(), p->height(),
			LColor::mathframe);
}


// In the future maybe we use a better fonts renderer
void drawStr(MathPainterInfo & pain, LyXFont const & font,
	int x, int y, string const & str)
{
	pain.pain.text(x, y, str, font);
}


void drawStrRed(MathPainterInfo & pi, int x, int y, string const & str)
{
	LyXFont f = pi.base.font;
	f.setColor(LColor::latex);
	pi.pain.text(x, y, str, f);
}


void drawStrBlack(MathPainterInfo & pi, int x, int y, string const & str)
{
	LyXFont f = pi.base.font;
	f.setColor(LColor::black);
	pi.pain.text(x, y, str, f);
}


void drawChar(MathPainterInfo & pi, LyXFont const & font, int x, int y, char c)
{
	pi.pain.text(x, y, c, font);
}


void math_font_max_dim(LyXFont const & font, int & asc, int & des)
{
	asc = font_metrics::maxAscent(font);
	des = font_metrics::maxDescent(font);
}


string convertDelimToLatexName(string const & name)
{
	if (name == "(")
		return name;
	if (name == "[")
		return name;
	if (name == ".")
		return name;
	if (name == ")")
		return name;
	if (name == "]")
		return name;
	if (name == "/")
		return name;
	if (name == "|")
		return name;
	return "\\" + name + " ";
}




struct fontinfo {
	string cmd_;
	LyXFont::FONT_FAMILY family_;
	LyXFont::FONT_SERIES series_;
	LyXFont::FONT_SHAPE  shape_;
	LColor::color        color_;
};


LyXFont::FONT_FAMILY const def_family = LyXFont::INHERIT_FAMILY;
LyXFont::FONT_SERIES const def_series = LyXFont::INHERIT_SERIES;
LyXFont::FONT_SHAPE  const def_shape  = LyXFont::INHERIT_SHAPE; 



fontinfo fontinfos[] = {
	{"cmex",   LyXFont::CMEX_FAMILY, def_series, def_shape, LColor::math},
	{"cmm",    LyXFont::CMM_FAMILY, def_series, def_shape, LColor::math},
	{"cmr",    LyXFont::CMR_FAMILY, def_series, def_shape, LColor::math},
	{"cmsy",   LyXFont::CMSY_FAMILY, def_series, def_shape, LColor::math},
	{"eufrak", LyXFont::EUFRAK_FAMILY, def_series, def_shape, LColor::math},
	{"mathbf", def_family, LyXFont::BOLD_SERIES, def_shape, LColor::math},
	{"mathcal",LyXFont::CMSY_FAMILY, def_series, def_shape, LColor::math},
	{"mathnormal", def_family,def_series, LyXFont::ITALIC_SHAPE, LColor::math},
	{"mathrm", LyXFont::ROMAN_FAMILY, def_series, def_shape, LColor::math},
	{"mathsf", LyXFont::SANS_FAMILY, def_series, def_shape, LColor::math},
	{"msa",    LyXFont::MSA_FAMILY, def_series, def_shape, LColor::math},
	{"msb",    LyXFont::MSB_FAMILY, def_series, def_shape, LColor::math},
	{"textbf", def_family, LyXFont::BOLD_SERIES, def_shape, LColor::black},
	{"textit", def_family, def_series, LyXFont::ITALIC_SHAPE, LColor::black},
	{"textmd", def_family, LyXFont::MEDIUM_SERIES, def_shape, LColor::black},
	{"textnormal", def_family, def_series, LyXFont::UP_SHAPE, LColor::black},
	{"textrm", LyXFont::ROMAN_FAMILY, def_series,LyXFont::UP_SHAPE,LColor::black},
	{"textsc", def_family, def_series, LyXFont::SMALLCAPS_SHAPE, LColor::black},
	{"textsf", LyXFont::SANS_FAMILY, def_series, def_shape, LColor::black},
	{"textsl", def_family, def_series, LyXFont::SLANTED_SHAPE, LColor::black},
	{"texttt", LyXFont::TYPEWRITER_FAMILY, def_series, def_shape, LColor::black},
	{"textup", def_family, def_series, LyXFont::UP_SHAPE, LColor::black},

	{"lyxtex", def_family, def_series, def_shape, LColor::latex},
	{"lyxsymbol", LyXFont::SYMBOL_FAMILY, def_series, def_shape, LColor::math},
	{"lyxitsymbol", LyXFont::SYMBOL_FAMILY, def_series, LyXFont::ITALIC_SHAPE, LColor::math},
};


fontinfo * searchFont(string const & name)
{
	int const n = sizeof(fontinfos) / sizeof(fontinfo);
	//lyxerr << "searching font '" << name << "'\n"; 
	for (int i = 0; i < n; ++i)
		if (fontinfos[i].cmd_ == name) {
			//lyxerr << "found '" << i << "'\n"; 
			return fontinfos + i;
		}
	return searchFont("mathnormal");
}


void augmentFont(LyXFont & font, string const & name)
{
	static bool initialized = false;
	
	if (!initialized) {
		initialized = true;

		LyXFont f1;
		augmentFont(f1, "msb");
		if (!fontloader.available(f1)) {
			lyxerr << "faking msb\n";
			fontinfo * info = searchFont("msb");
			info->family_ = LyXFont::TYPEWRITER_FAMILY;
			info->series_ = LyXFont::BOLD_SERIES;
		}

		LyXFont f2;
		augmentFont(f2, "msex");
		if (!fontloader.available(f2)) {
			lyxerr << "faking msex\n";
			fontinfo * info = searchFont("msex");
			info->family_ = LyXFont::SANS_FAMILY;
			info->series_ = LyXFont::BOLD_SERIES;
			info->shape_  = LyXFont::ITALIC_SHAPE;
		}

		//{"fakebb", LyXFont::TYPEWRITER_FAMILY, LyXFont::BOLD_SERIES,
		//	LyXFont::UP_SHAPE, LColor::math},
		//{"fakecal", LyXFont::SANS_FAMILY, LyXFont::MEDIUM_SERIES,
		//	LyXFont::ITALIC_SHAPE, LColor::math},
		//{"fakefrak", LyXFont::SANS_FAMILY, LyXFont::BOLD_SERIES,
		//	LyXFont::ITALIC_SHAPE, LColor::math}

	}


	fontinfo * info = searchFont(name);
	if (info->family_ != def_family)
		font.setFamily(info->family_);

	if (info->series_ != def_series)
		font.setSeries(info->series_);

	if (info->shape_ != def_shape)
		font.setShape(info->shape_);

	if (info->color_ != LColor::none)
		font.setColor(info->color_);
}


bool math_font_available(string const & /*name*/)
{
	return true;
}