implement Brutusext;

# <Extension table tablefile>

include "sys.m";
	sys: Sys;

include "draw.m";
	draw: Draw;
	Point, Font, Rect: import draw;

include "tk.m";
	tk: Tk;

include "tklib.m";
	tklib: Tklib;

include "bufio.m";

include "string.m";
	S: String;

include "html.m";
	html: HTML;
	Lex, Attr, RBRA, Data, Ttable, Tcaption, Tcol, Ttr, Ttd: import html;

include "brutus.m";
	Size6, Size8, Size10, Size12, Size16, NSIZE,
	Roman, Italic, Bold, Type, NFONT, NFONTTAG,
	Example, List, Listelem, Heading, Nofill, Author, Title,
	DefFont, DefSize, TitleFont, TitleSize, HeadingFont, HeadingSize: import Brutus;

include "brutusext.m";
	SGML, Text, Par, Extension, Special, Celem,
	FLatex, FLatexProc, FLatexBook, FHtml: import Brutusext;

Name: con "Table";

# alignment types
Anone, Aleft, Acenter, Aright, Ajustify, Atop, Amiddle, Abottom, Abaseline: con iota;

# A cell has a number of Lines, each of which has a number of Items.
# Each Item is a string in one font.
Item: adt
{
	itemid: int;	# canvas text item id
	s: string;
	fontnum: int;	# (style*NumSizes + size)
	pos: Point;	# nw corner of text item, relative to line origin
	width: int;		# of s, in pixels,  when displayed in font
	line: cyclic ref Line;   # containing line
	prev: cyclic ref Item;
	next: cyclic ref Item;
};

Line: adt
{
	items: cyclic ref Item;
	pos: Point;	# nw corner of Line relative to containing cell;
	height: int;
	ascent: int;
	width: int;
	cell: cyclic ref Tablecell;  # containing cell
	next: cyclic ref Line;
};

Align: adt
{
	halign: int;
	valign: int;
};

Tablecell: adt
{
	cellid: int;
	content: array of ref Lex;
	lines: cyclic ref Line;
	rowspan: int;
	colspan: int;
	nowrap: int;
	align: Align;
	width: int;
	height: int;
	ascent: int;
	row: int;
	col: int;
	pos: Point;	# nw corner of cell, in canvas coords
};

Tablegcell: adt
{
	cell: ref Tablecell;
	drawnhere: int;
};

Tablerow: adt
{
	cells: list of ref Tablecell;
	height: int;
	ascent: int;
	align: Align;
	pos: Point;
	rule: int;			# width of rule below row, if > 0
	ruleids: list of int;	# canvas ids of lines used to draw rule
};

Tablecol: adt
{
	width: int;
	align: Align;
	pos: Point;
	rule: int;			# width of rule to right of col, if > 0
	ruleids: list of int;	# canvas ids of lines used to draw rule
};

Table: adt
{
	nrow: int;
	ncol: int;
	ncell: int;
	width: int;
	height: int;
	capcell: ref Tablecell;
	border: int;
	brectid: int;
	cols: array of ref Tablecol;
	rows: array of ref Tablerow;
	cells: list of ref Tablecell;
	grid: array of array of ref Tablegcell;
	colw: array of int;
	rowh: array of int;
};

# Font stuff

DefaultFnum: con (DefFont*NSIZE + Size10);

fontnames := array[NFONTTAG] of {
	"/fonts/lucidasans/unicode.6.font",
	"/fonts/lucidasans/unicode.7.font",
	"/fonts/lucidasans/unicode.8.font",
	"/fonts/lucidasans/unicode.10.font",
	"/fonts/lucidasans/unicode.13.font",
	"/fonts/lucidasans/italiclatin1.6.font",
	"/fonts/lucidasans/italiclatin1.7.font",
	"/fonts/lucidasans/italiclatin1.8.font",
	"/fonts/lucidasans/italiclatin1.10.font",
	"/fonts/lucidasans/italiclatin1.13.font",
	"/fonts/lucidasans/boldlatin1.6.font",
	"/fonts/lucidasans/boldlatin1.7.font",
	"/fonts/lucidasans/boldlatin1.8.font",
	"/fonts/lucidasans/boldlatin1.10.font",
	"/fonts/lucidasans/boldlatin1.13.font",
	"/fonts/lucidasans/typelatin1.6.font",
	" /fonts/lucidasans/typelatin1.7.font",
	"/fonts/pelm/latin1.9.font",
	"/fonts/pelm/ascii.12.font",
	"/fonts/pelm/ascii.16.font"
};

fontrefs := array[NFONTTAG] of ref Font;
fontused := array[NFONTTAG] of { DefaultFnum => 1, * => 0};

# TABHPAD, TABVPAD are extra space between columns, rows
TABHPAD: con 10;
TABVPAD: con 4;

tab: ref Table;
top: ref Tk->Toplevel;
display: ref Draw->Display;
canv: string;

init(asys: Sys, adraw: Draw, nil: Bufio, atk: Tk, atklib: Tklib)
{
	sys = asys;
	draw = adraw;
	tk = atk;
	tklib = atklib;
	html = load HTML HTML->PATH;
	S = load String String->PATH;
}

create(t: ref Tk->Toplevel, name, args: string): string
{
	if(html == nil)
		return "can't load HTML module";
	top = t;
	display = t.image.display;
	canv = name;
	err := tk->cmd(t, "canvas " + canv);
	if(tklib->is_err(err))
		return err_ret(err);

	spec: array of ref Lex;
	(spec, err) = getspec(args);
	if(err != "")
		return err_ret(err);

	err = parsetab(spec);
	if(err != "")
		return err_ret(err);

	err = build();
	if(err != "")
		return err_ret(err);
	return "";
}

err_ret(s: string) : string
{
	return Name + ": " + s;
}

getspec(args: string) : (array of ref Lex, string)
{
	(n, argl) := sys->tokenize(args, " ");
	if(n != 1)
		return (nil, "usage: " + Name + " file");
	(filebytes, err) := readfile(hd argl);
	if(err != "")
		return (nil, err);
	return(html->lex(filebytes, 1), "");
}

readfile(path: string): (array of byte, string)
{
	fd := sys->open(path, sys->OREAD);
	if(fd == nil)
		return (nil, sys->sprint("can't open %s, the error was: %r", path));
	(ok, d) := sys->fstat(fd);
	if(ok < 0)
		return (nil, sys->sprint("can't stat %s, the error was: %r", path));
	if(d.mode & sys->CHDIR)
		return (nil, sys->sprint("%s is a directory", path));

	buf := array[d.length] of byte;
	tot := 0;
	while(tot < d.length) {
		need := d.length - tot;
		n := sys->read(fd, buf[tot:], need);
		if(n <= 0)
			return (nil, sys->sprint("error reading %s, the error was: %r", path));
		tot += n;
	}
	return (buf, "");
}

# Use HTML 3.2 table spec as external representation
# (But no th cells, width specs; and extra "rule" attribute
# for col and tr meaning that a rule of given width is to
# follow the given column or row).
# DTD elements:
#	table: - O (caption?, col*, tr*)
#	caption: - - (%text+)
#	col: - O empty
#	tr: - O td*
#	td: - O (%body.content)
parsetab(toks: array of ref Lex) : string
{
	tabletlex := toks[0];
	n := len toks;
	(tlex, i) := nexttok(toks, n, 0);

	# caption
	capcell: ref Tablecell = nil;
	if(tlex != nil && tlex.tag == Tcaption) {
		for(j := i+1; j < n; j++) {
			tlex = toks[j];
			if(tlex.tag == Tcaption + RBRA)
				break;
		}
		if(j >= n)
			return syntax_err(tlex, j);
		if(j > i+1) {
			captoks := toks[i+1:j];
			(caplines, e) := lexes2lines(captoks);
			if(e != nil)
				return e;
			capcell = ref Tablecell(0, captoks, caplines, 1, 1, 1, Align(Anone, Anone),
						0, 0, 0, 0, 0, Point(0,0));
		}
		(tlex, i) = nexttok(toks, n, j);
	}

	# col*
	cols: list of ref Tablecol = nil;
	while(tlex != nil && tlex.tag == Tcol) {
		col := makecol(tlex);
		if(col.align.halign == Anone)
			col.align.halign = Aleft;
		cols = col :: cols;
		(tlex, i) = nexttok(toks, n, i);
	}
	cols = revcols(cols);

	body : list of ref Tablerow = nil;
	cells : list of ref Tablecell = nil;
	cellid := 0;
	rows: list of ref Tablerow = nil;

	# tr*
	while(tlex != nil && tlex.tag == Ttr) {
		currow := ref Tablerow(nil, 0, 0, makealign(tlex), Point(0,0), makelinew(tlex, "rule"), nil);
		rows = currow :: rows;

		# td*
		(tlex, i) = nexttok(toks, n, i);
		while(tlex != nil && tlex.tag == Ttd) {
			rowspan := 1;
			(rsfnd, rs) := html->attrvalue(tlex.attr, "rowspan");
			if(rsfnd && rs != "")
				rowspan = int rs;
			colspan := 1;
			(csfnd, cs) := html->attrvalue(tlex.attr, "colspan");
			if(csfnd && cs != "")
				colspan = int cs;
			nowrap := 0;
			(nwfnd, nil) := html->attrvalue(tlex.attr, "nowrap");
			if(nwfnd)
				nowrap = 1;
			align := makealign(tlex);
			for(j := i+1; j < n; j++) {
				tlex = toks[j];
				tg := tlex.tag;
				if(tg == Ttd + RBRA || tg == Ttd || tg == Ttr + RBRA || tg == Ttr)
					break;
			}
			if(j == n)
				tlex = nil;
			content: array of ref Lex = nil;
			if(j > i+1)
				content = toks[i+1:j];
			(lines, err) := lexes2lines(content);
			if(err != "")
				return err;
			curcell := ref Tablecell(cellid, content, lines, rowspan, colspan, nowrap, align, 0, 0, 0, 0, 0, Point(0,0));
			currow.cells = curcell :: currow.cells;
			cells = curcell :: cells;
			cellid++;
			if(tlex != nil && tlex.tag == Ttd + RBRA)
				(tlex, i) = nexttok(toks, n, j);
			else
				i = j;
		}
		if(tlex != nil && tlex.tag == Ttr + RBRA)
			(tlex, i) = nexttok(toks, n, i);
	}
	if(tlex == nil || tlex.tag != Ttable + RBRA)
		return syntax_err(tlex, i);

	# now reverse all the lists that were built in reverse order
	# and calculate nrow, ncol

	rows = revrowl(rows);
	nrow := len rows;
	rowa := array[nrow] of ref Tablerow;
	ncol := 0;
	r := 0;
	for(rl := rows; rl != nil; rl = tl rl) {
		row := hd rl;
		rowa[r++] = row;
		rcols := 0;
		cl := row.cells;
		row.cells = nil;
		while(cl != nil) {
			c := hd cl;
			row.cells = c :: row.cells;
			rcols += c.colspan;
			cl = tl cl;
		}
		if(rcols > ncol)
			ncol = rcols;
	}
	cells = revcelll(cells);

	cola := array[ncol] of ref Tablecol;
	for(c := 0; c < ncol; c++) {
		if(cols != nil) {
			cola[c] = hd cols;
			cols = tl cols;
		}
		else
			cola[c] = ref Tablecol(0, Align(Anone, Anone), Point(0,0), 0, nil);
	}

	if(tabletlex.tag != Ttable)
		return syntax_err(tabletlex, 0);
	border := makelinew(tabletlex, "border");
	tab = ref Table(nrow, ncol, cellid, 0, 0, capcell, border, 0, cola, rowa, cells, nil, nil, nil);

	return "";
}

syntax_err(tlex: ref Lex, i: int) : string
{
	if(tlex == nil)
		return "syntax error in table: premature end";
	else
		return "syntax error in table at token " + string i + ": " + html->lex2string(tlex);
}

# next token after toks[i], skipping whitespace
nexttok(toks: array of ref Lex, ntoks, i: int) : (ref Lex, int)
{
	i++;
	if(i >= ntoks)
		return (nil, i);
	t := toks[i];
	while(t.tag == Data) {
		if(S->drop(t.text, " \t\n\r") != "")
			break;
		i++;
		if(i >= ntoks)
			return (nil, i);
		t = toks[i];
	}
# sys->print("nexttok returning (%s,%d)\n", html->lex2string(t), i);
	return(t, i);
}

makecol(tlex: ref Lex) : ref Tablecol
{
	return ref Tablecol(0, makealign(tlex), Point(0,0), makelinew(tlex, "rule"), nil);
}

makelinew(tlex: ref Lex, aname: string) : int
{
	ans := 0;
	(fnd, val) := html->attrvalue(tlex.attr, aname);
	if(fnd) {
		if(val == "")
			ans = 1;
		else
			ans = int val;
	}
	return ans;
}

makealign(tlex: ref Lex) : Align
{
	(nil,h) := html->attrvalue(tlex.attr, "align");
	(nil,v) := html->attrvalue(tlex.attr, "valign");
	hal := align_val(h, Anone);
	val := align_val(v, Anone);
	return Align(hal, val);
}

align_val(sal: string, dflt: int) : int
{
	ans := dflt;
	case sal {
		"left" => ans = Aleft;
		"center" => ans = Acenter;
		"right" => ans = Aright;
		"justify" => ans = Ajustify;
		"top" => ans = Atop;
		"middle" => ans = Amiddle;
		"bottom" => ans = Abottom;
		"baseline" => ans = Abaseline;
	}
	return ans;
}

revcols(l : list of ref Tablecol) : list of ref Tablecol
{
	ans : list of ref Tablecol = nil;
	while(l != nil) {
		ans = hd l :: ans;
		l = tl l;
	}
	return ans;
}

revrowl(l : list of ref Tablerow) : list of ref Tablerow
{
	ans : list of ref Tablerow = nil;
	while(l != nil) {
		ans = hd l :: ans;
		l = tl l;
	}
	return ans;
}

revcelll(l : list of ref Tablecell) : list of ref Tablecell
{
	ans : list of ref Tablecell = nil;
	while(l != nil) {
		ans = hd l :: ans;
		l = tl l;
	}
	return ans;
}

revintl(l : list of int) : list of int
{
	ans : list of int = nil;
	while(l != nil) {
		ans = hd l :: ans;
		l = tl l;
	}
	return ans;
}

# toks should contain only Font (i.e., size) and style changes, along with text.
lexes2lines(toks: array of ref Lex) : (ref Line, string)
{
	n := len toks;
	(tlex, i) := nexttok(toks, n, -1);
	ans: ref Line = nil;
	if(tlex == nil)
		return(ans, "");
	curline : ref Line = nil;
	curitem : ref Item = nil;
	stylestk := DefFont :: nil;
	sizestk := DefSize :: nil;
	f := DefaultFnum;
	fontstk:= f :: nil;
	for(;;) {
		if(i >= n)
			break;
		tlex = toks[i++];
		case tlex.tag {
		Data =>
			text := tlex.text;
			while(text != "") {
				if(curline == nil) {
					curline = ref Line(nil, Point(0,0), 0, 0, 0, nil, nil);
					ans = curline;
				}
				s : string;
				(s, text) = S->splitl(text, "\n");
				if(s != "") {
					f = hd fontstk;
					it := ref Item(0, s, f, Point(0,0), 0, curline, curitem, nil);
					if(curitem == nil)
						curline.items = it;
					else
						curitem.next = it;
					curitem = it;
				}
				if(text != "") {
					text = text[1:];
					curline.next = ref Line(nil, Point(0,0), 0, 0, 0, nil, nil);
					curline = curline.next;
					curitem = nil;
				}
			}
		HTML->Tfont =>
			(fnd, ssize) := html->attrvalue(tlex.attr, "size");
			if(fnd && len ssize > 0) {
				# HTML size 3 == our Size10
				sz := (int ssize) + (Size10 - 3);
				if(sz < 0 || sz >= NSIZE)
					return (nil, "bad font size " + ssize);
				sizestk = sz :: sizestk;
				fontstk = fnum(hd stylestk, sz) :: fontstk;
			}
			else
				return (nil, "bad font command: no size");
		HTML->Tfont + RBRA =>
			fontstk = tl fontstk;
			sizestk = tl sizestk;
			if(sizestk == nil)
				return (nil, "unmatched </FONT>");
		HTML->Tb =>
			stylestk = Bold :: stylestk;
			fontstk = fnum(Bold, hd sizestk) :: fontstk;
		HTML->Ti =>
			stylestk = Italic :: stylestk;
			fontstk = fnum(Italic, hd sizestk) :: fontstk;
		HTML->Ttt =>
			stylestk = Type :: stylestk;
			fontstk = fnum(Type, hd sizestk) :: fontstk;
		HTML->Tb + RBRA or HTML->Ti + RBRA or HTML->Ttt + RBRA =>
			fontstk = tl fontstk;
			stylestk = tl stylestk;
			if(stylestk == nil)
				return (nil, "unmatched </B>, </I>, or </TT>");
		}
	}
	return (ans, "");
}

fnum(fstyle, fsize: int) : int
{
	ans := fstyle*NSIZE + fsize;
	fontused[ans] = 1;
	return ans;
}

loadfonts() : string
{
	for(i := 0; i < NFONTTAG; i++) {
		if(fontused[i] && fontrefs[i] == nil) {
			fname := fontnames[i];
			f := Font.open(display, fname);
			if(f == nil)
				return "can't open font " + fname;
			fontrefs[i] = f;
		}
	}
	return "";
}

# Find where each cell goes in nrow x ncol grid
setgrid()
{
	gcells := array[tab.nrow] of { * => array[tab.ncol] of { * => ref Tablegcell(nil, 1)} };

	# The following arrays keep track of cells that are spanning
	# multiple rows;  rowspancnt[i] is the number of rows left
	# to be spanned in column i.
	# When done, cell's (row,col) is upper left grid point.
	rowspancnt := array[tab.ncol] of { * => 0};
	rowspancell := array[tab.ncol] of ref Tablecell;

	ri := 0;
	ci := 0;
	for(ri = 0; ri < tab.nrow; ri++) {
		row := tab.rows[ri];
		cl := row.cells;
		for(ci = 0; ci < tab.ncol; ) {
			if(rowspancnt[ci] > 0) {
				gcells[ri][ci].cell = rowspancell[ci];
				gcells[ri][ci].drawnhere = 0;
				rowspancnt[ci]--;
				ci++;
			}
			else {
				if(cl == nil) {
					ci++;
					continue;
				}
				c := hd cl;
				cl = tl cl;
				cspan := c.colspan;
				if(cspan == 0) {
					cspan = tab.ncol - ci;
					c.colspan = cspan;
				}
				rspan := c.rowspan;
				if(rspan == 0) {
					rspan = tab.nrow - ri;
					c.rowspan = rspan;
				}
				c.row = ri;
				c.col = ci;
				for(i := 0; i < cspan && ci < tab.ncol; i++) {
					gcells[ri][ci].cell = c;
					if(i > 0)
						gcells[ri][ci].drawnhere = 0;
					if(rspan > 1) {
						rowspancnt[ci] = rspan-1;
						rowspancell[ci] = c;
					}
					ci++;
				}
			}
		}
	}
	tab.grid = gcells;
}

build() : string
{
	ri, ci: int;

#	sys->print("\n\ninitial table\n"); printtable();
	if(tab.ncol == 0 || tab.nrow == 0)
		return "";

	setgrid();

	err := loadfonts();
	if(err != "")
		return err;

	for(cl := tab.cells; cl != nil; cl = tl cl)
		cell_geom(hd cl);

	for(ci = 0; ci < tab.ncol; ci++)
		col_geom(ci);

	for(ri = 0; ri < tab.nrow; ri++)
		row_geom(ri);

	caption_geom();

	table_geom();
#	sys->print("\n\ntable after geometry set\n"); printtable();

	h := tab.height;
	w := tab.width;
	if(tab.capcell != nil) {
		h += tab.capcell.height;
		if(tab.capcell.width > w)
			w = tab.capcell.width;
	}

	err = tk->cmd(top, canv + " configure -width " + string w
		+ " -height " + string h);
	if(tklib->is_err(err))
		return err;
	err = create_cells();
	if(err != "")
		return err;
	err = create_border();
	if(err != "")
		return err;
	err = create_rules();
	if(err != "")
		return err;
	err = create_caption();
	if(err != "")
		return err;
	tk->cmd(top, "update");

	return "";
}

create_cells() : string
{
	for(cl := tab.cells; cl != nil; cl = tl cl) {
		c := hd cl;
		cpos := c.pos;
		for(l := c.lines; l != nil; l = l.next) {
			lpos := l.pos;
			for(it := l.items; it != nil; it = it.next) {
				ipos := it.pos;
				pos := ipos.add(lpos.add(cpos));
				fnt := fontrefs[it.fontnum];
				v := tk->cmd(top, canv + " create text " + string pos.x + " "
					+ string pos.y + " -anchor nw -font " + fnt.name
					+ " -text '" + it.s);
				if(tklib->is_err(v))
					return v;
				it.itemid = int v;
			}
		}
	}
	return "";
}

create_border() : string
{
	bd := tab.border;
	if(bd > 0) {
		x1 := string (bd / 2);
		y1 := x1;
		x2 := string (tab.width - bd/2 -1);
		y2 := string (tab.height - bd/2 -1);
		v := tk->cmd(top, canv + " create rectangle "
			+ x1 + " " + y1 + " " + x2 + " " + y2 + " -width " + string bd);
		if(tklib->is_err(v))
			return v;
		tab.brectid = int v;
	}
	return "";
}

create_rules() : string
{
	ci, ri, i: int;
	err : string;
	c : ref Tablecell;
	for(ci = 0; ci < tab.ncol; ci++) {
		col := tab.cols[ci];
		rw := col.rule;
		if(rw > 0) {
			x := col.pos.x + col.width + TABHPAD/2 - rw/2;
			ids: list of int = nil;
			startri := 0;
			for(ri = 0; ri < tab.nrow; ri++) {
				c = tab.grid[ri][ci].cell;
				if(c.col+c.colspan-1 > ci) {
					# rule would cross a spanning cell at this column
					if(ri > startri) {
						(err, i) = create_col_rule(startri, ri-1, x, rw);
						if(err != "")
							return err;
						ids = i :: ids;
					}
					startri = ri+1;
				}
			}
			if(ri > startri)
				(err, i) = create_col_rule(startri, ri-1, x, rw);
			ids = i :: ids;
			col.ruleids = revintl(ids);
		}
	}
	for(ri = 0; ri < tab.nrow; ri++) {
		row := tab.rows[ri];
		rw := row.rule;
		if(rw > 0) {
			y := row.pos.y + row.height + TABVPAD/2 - rw/2;
			ids: list of int = nil;
			startci := 0;
			for(ci = 0; ci < tab.ncol; ci++) {
				c = tab.grid[ri][ci].cell;
				if(c.row+c.rowspan-1 > ri) {
					# rule would cross a spanning cell at this row
					if(ci > startci) {
						(err, i) = create_row_rule(startci, ci-1, y, rw);
						if(err != "")
							return err;
						ids = i :: ids;
					}
					startci = ci+1;
				}
			}
			if(ci > startci)
				(err, i) = create_row_rule(startci, ci-1, y, rw);
			ids = i :: ids;
			row.ruleids = revintl(ids);
		}
	}
	return "";
}

create_col_rule(topri, botri, x, rw: int) : (string, int)
{
	y1, y2: int;
	if(topri == 0)
		y1 = 0;
	else
		y1 = tab.rows[topri].pos.y - TABVPAD/2;
	if(botri == tab.nrow-1)
		y2 = tab.height;
	else
		y2 = tab.rows[botri].pos.y + tab.rows[botri].height + TABVPAD/2;
	sx := string x;
	v := tk->cmd(top, canv + " create line " + sx + " "
		+ string y1 + " " + sx + " " + string y2 + " -width " + string rw);
	if(tklib->is_err(v))
		return (v, 0);
	return ("", int v);
}

create_row_rule(leftci, rightci, y, rw: int) : (string, int)
{
	x1, x2: int;
	if(leftci == 0)
		x1 = 0;
	else
		x1 = tab.cols[leftci].pos.x - TABHPAD/2;
	if(rightci == tab.ncol-1)
		x2 = tab.width;
	else
		x2 = tab.cols[rightci].pos.x + tab.cols[rightci].width + TABHPAD/2;
	sy := string y;
	v := tk->cmd(top, canv + " create line " + string x1 + " "
		+ sy + " " + string x2 + " " + sy + " -width " + string rw);
	if(tklib->is_err(v))
		return (v, 0);
	return ("", int v);
}

create_caption() : string
{
	cpos := Point(0, tab.height + 2*TABVPAD);
	for(l := tab.capcell.lines; l != nil; l = l.next) {
		lpos := l.pos;
		for(it := l.items; it != nil; it = it.next) {
			ipos := it.pos;
			pos := ipos.add(lpos.add(cpos));
			fnt := fontrefs[it.fontnum];
			v := tk->cmd(top, canv + " create text " + string pos.x + " "
				+ string pos.y + " -anchor nw -font " + fnt.name
				+ " -text '" + it.s);
			if(tklib->is_err(v))
				return v;
			it.itemid = int v;
		}
	}
	return "";
}

# Assuming row and col geoms correct, set row, col, and cell origins
table_geom()
{
	row: ref Tablerow;
	col: ref Tablecol;
	orig := Point(0,0);
	bd := tab.border;
	if(bd > 0)
		orig = orig.add(Point(TABHPAD+bd, TABVPAD+bd));
	o := orig;
	for(ci := 0; ci < tab.ncol; ci++) {
		col = tab.cols[ci];
		col.pos = o;
		o.x += col.width + col.rule;
		if(ci < tab.ncol-1)
			o.x += TABHPAD;
	}
	if(bd > 0)
		o.x += TABHPAD + bd;
	tab.width = o.x;

	o = orig;
	for(ri := 0; ri < tab.nrow; ri++) {
		row = tab.rows[ri];
		row.pos = o;
		o.y += row.height + row.rule;
		if(ri < tab.nrow-1)
			o.y += TABVPAD;
	}
	if(bd > 0)
		o.y += TABVPAD + bd;
	tab.height = o.y;

	if(tab.capcell != nil) {
		tabw := tab.width;
		if(tab.capcell.width > tabw)
			tabw = tab.capcell.width;
		for(l := tab.capcell.lines; l != nil; l = l.next)
			l.pos.x += (tabw - l.width)/2;
	}

	for(cl := tab.cells; cl != nil; cl = tl cl) {
		c := hd cl;
		row = tab.rows[c.row];
		col = tab.cols[c.col];
		x := col.pos.x;
		y := row.pos.y;
		w := spanned_col_width(c.col, c.col+c.colspan-1);
		case (cellhalign(c)) {
		Aright =>
			x += w - c.width;
		Acenter =>
			x += (w - c.width) / 2;
		}
		h := spanned_row_height(c.row, c.row+c.rowspan-1);
		case (cellvalign(c)) {
		Abottom =>
			y += h - c.height;
		Anone or Amiddle =>
			y += (h - c.height) / 2;
		Abaseline =>
			y += row.ascent - c.ascent;
		}
		c.pos = Point(x,y);
	}
}

spanned_col_width(firstci, lastci: int) : int
{
	firstcol := tab.cols[firstci];
	if(firstci == lastci)
		return firstcol.width;
	lastcol := tab.cols[lastci];
	return (lastcol.pos.x + lastcol.width - firstcol.pos.x);
}

spanned_row_height(firstri, lastri: int) : int
{
	firstrow := tab.rows[firstri];
	if(firstri == lastri)
		return firstrow.height;
	lastrow := tab.rows[lastri];
	return (lastrow.pos.y + lastrow.height - firstrow.pos.y);
}

# Assuming cell geoms are correct, set col widths.
# This code is sloppy for spanned columns;
# it will allocate too much space for them because
# inter-column pad is ignored, and it may make
# narrow columns wider than they have to be.
col_geom(ci: int)
{
	col := tab.cols[ci];
	col.width = 0;
	for(ri := 0; ri < tab.nrow; ri++) {
		c := tab.grid[ri][ci].cell;
		if(c == nil)
			continue;
		cwd := c.width / c.colspan;
		if(cwd > col.width)
			col.width = cwd;
	}
}

# Assuming cell geoms are correct, set row heights
row_geom(ri: int)
{
	row := tab.rows[ri];
	# find rows's global height and ascent
	h := 0;
	a := 0;
	n : int;
	for(cl := row.cells; cl != nil; cl = tl cl) {
		c := hd cl;
		al := cellvalign(c);
		if(al == Abaseline) {
			n = c.ascent;
			if(n > a) {
				h += (n - a);
				a = n;
			}
			n = c.height - c.ascent;
			if(n > h-a)
				h = a + n;
		}
		else {
			n = c.height;
			if(n > h)
				h = n;
		}
	}
	row.height = h;
	row.ascent = a;
}

cell_geom(c: ref Tablecell)
{
	width := 0;
	o := Point(0,0);
	for(l := c.lines; l != nil; l = l.next) {
		line_geom(l, o);
		o.y += l.height;
		if(l.width > width)
			width = l.width;
	}
	c.width = width;
	c.height = o.y;
	if(c.lines != nil)
		c.ascent = c.lines.ascent;
	else
		c.ascent = 0;

	al := cellhalign(c);
	if(al == Acenter || al == Aright) {
		for(l := c.lines; l != nil; l = l.next) {
			xdelta := c.width - l.width;
			if(al == Acenter)
				xdelta /= 2;
			l.pos.x += xdelta;
		}
	}
}

caption_geom()
{
	if(tab.capcell != nil) {
		o := Point(0,TABVPAD);
		width := 0;
		for(l := tab.capcell.lines; l != nil; l = l.next) {
			line_geom(l, o);
			o.y += l.height;
			if(l.width > width)
				width = l.width;
		}
		tab.capcell.width = width;
		tab.capcell.height = o.y + 4*TABVPAD;
	}
}

line_geom(l: ref Line, o: Point)
{
	# find line's global height and ascent
	h := 0;
	a := 0;
	for(it := l.items; it != nil; it = it.next) {
		fnt := fontrefs[it.fontnum];
		n := fnt.ascent;
		if(n > a) {
			h += (n - a);
			a = n;
		}
		n = fnt.height - fnt.ascent;
		if(n > h-a)
			h = a + n;
	}
	l.height = h;
	l.ascent = a;
	# set positions
	l.pos = o;
	for(it = l.items; it != nil; it = it.next) {
		fnt := fontrefs[it.fontnum];
		it.width = fnt.width(it.s);
		it.pos.x = o.x;
		o.x += it.width;
		it.pos.y = a - fnt.ascent;
	}
	l.width = o.x;
}

cellhalign(c: ref Tablecell) : int
{
	a := c.align.halign;
	if(a == Anone)
		a = tab.cols[c.col].align.halign;
	return a;
}

cellvalign(c: ref Tablecell) : int
{
	a := c.align.valign;
	if(a == Anone)
		a = tab.rows[c.row].align.valign;
	return a;
}

# table debugging
printtable()
{
	if(tab == nil) {
		sys->print("no table\n");
		return;
	}
	sys->print("Table %d rows, %d cols width %d height %d\n",
			tab.nrow, tab.ncol, tab.width, tab.height);
	if(tab.capcell != nil)
		sys->print("  caption: "); printlexes(tab.capcell.content, "    ");
	sys->print("  cols:\n"); printcols(tab.cols);
	sys->print("  rows:\n"); printrows(tab.rows);
}

align2string(al: int) : string
{
	s := "";
	case al {
		Anone => s = "none";
		Aleft => s = "left";
		Acenter => s = "center";
		Aright => s = "right";
		Ajustify => s = "justify";
		Atop => s = "top";
		Amiddle => s = "middle";
		Abottom => s = "bottom";
		Abaseline => s = "baseline";
	}
	return s;
}

printcols(cols: array of ref Tablecol)
{
	n := len cols;
	for(i := 0 ; i < n; i++) {
		c := cols[i];
		sys->print(" width %d align = %s,%s pos (%d,%d) rule %d\n", c.width,
			align2string(c.align.halign), align2string(c.align.valign), c.pos.x, c.pos.y, c.rule);
	}
}

printrows(rows: array of ref Tablerow)
{
	n := len rows;
	for(i := 0; i < n; i++) {
		tr := rows[i];
		sys->print("      row height %d ascent %d align=%s,%s pos (%d,%d) rule %d\n", tr.height, tr.ascent,
			align2string(tr.align.halign), align2string(tr.align.valign), tr.pos.x, tr.pos.y, tr.rule);
		for(cl := tr.cells; cl != nil; cl = tl cl) {
			c := hd cl;
			sys->print("        cell %d width %d height %d ascent %d align=%s,%s\n",
				c.cellid, c.width, c.height, c.ascent,
				align2string(c.align.halign), align2string(c.align.valign));
			sys->print("             pos (%d,%d) rowspan=%d colspan=%d nowrap=%d\n",
				c.pos.x, c.pos.y, c.rowspan, c.colspan, c.nowrap);
			printlexes(c.content, "        ");
			printlines(c.lines);
		}
	}
}

printlexes(lexes: array of ref Lex, indent: string)
{
	for(i := 0; i < len lexes; i++)
		sys->print("%s%s\n", indent, html->lex2string(lexes[i]));
}

printlines(l: ref Line)
{
	if(l == nil)
		return;
	sys->print("lines: \n");
	while(l != nil) {
		sys->print("          Line: pos (%d,%d), height %d ascent %d\n", l.pos.x, l.pos.y, l.height, l.ascent);
		printitems(l.items);
		l = l.next;
	}
}

printitems(i: ref Item)
{
	while(i != nil) {
		sys->print("            '%s' id %d fontnum %d w %d, pos (%d,%d)\n", i.s, i.itemid, i.fontnum,
			i.width, i.pos.x, i.pos.y);
		i = i.next;
	}
}

printgrid(g: array of array of ref Tablegcell)
{
	nr := len g;
	nc := len g[0];
	for(r := 0; r < nr; r++) {
		for(c := 0; c < nc; c++) {
			x := g[r][c];
			cell := x.cell;
			suf := " ";
			if(x.drawnhere == 0)
				suf = "*";
			if(cell == nil)
				sys->print("     %s", suf);
			else
				sys->print("%5d%s", cell.cellid, suf);
		}
		sys->print("\n");
	}
}

# Return (table in correct format, error string)
cook(fmt: int, args: string) : (ref Celem, string)
{
	(spec, err) := getspec(args);
	if(err != "")
		return (nil, err);
	if(fmt == FLatex || fmt == FLatexProc || fmt == FLatexBook)
		return cooklatex(spec);
	else if(fmt == FHtml)
		return cookhtml(spec);
	return (nil, err_ret("unknown format"));
}

# Return (table as latex, error string)
# BUG: cells spanning multiple rows not handled correctly
# (all their contents go in the first row of span, though hrules properly broken)
cooklatex(spec: array of ref Lex) : (ref Celem, string)
{
	s : string;
	ci, ri: int;
	err := parsetab(spec);
	if(err != "")
		return (nil, err_ret(err));

	setgrid();

	ans := ref Celem(SGML, "", nil, nil, nil, nil);
	cur : ref Celem = nil;
	if(tab.capcell != nil)
		cur = add(ans, cur, specialce("\\begin{table}\n"));
	cur = add(ans, cur, specialce("\\begin{center}\n\\begin{tabular}{" + lcolspec() + "}\n"));
	if(tab.border) {
		if(tab.border == 1)
			s = "\\hline\n";
		else
			s = "\\hline\\hline\n";
		cur = add(ans, cur, specialce(s));
	}
	for(ri = 0; ri < tab.nrow; ri++) {
		row := tab.rows[ri];
		ci = 0;
		anyrowspan := 0;
		for(cl := row.cells; cl != nil; cl = tl cl) {
			c := hd cl;
			while(ci < c.col) {
				cur = add(ans, cur, specialce("&"));
				ci++;
			}
			mcol := 0;
			if(c.colspan > 1) {
				cur = add(ans, cur, specialce("\\multicolumn{" + string c.colspan + "}{" +
						lnthcolspec(ci, ci+c.colspan-1, c.align.halign) + "}{"));
				mcol = 1;
			}
			else if(c.align.halign != Anone) {
				cur = add(ans, cur, specialce("\\multicolumn{1}{" +
						lnthcolspec(ci, ci, c.align.halign) + "}{"));
				mcol = 1;
			}
			if(c.rowspan > 1)
				anyrowspan = 1;
			cur = addlconvlines(ans, cur, c);
			if(mcol) {
				cur = add(ans, cur, specialce("}"));
				ci += c.colspan-1;
			}
		}
		while(ci++ < tab.ncol-1)
			cur = add(ans, cur, specialce("&"));
		if(ri < tab.nrow-1 || row.rule > 0 || tab.border > 0)
			cur = add(ans, cur, specialce("\\\\\n"));
		if(row.rule) {
			if(anyrowspan) {
				startci := 0;
				for(ci = 0; ci < tab.ncol; ci++) {
					c := tab.grid[ri][ci].cell;
					if(c.row+c.rowspan-1 > ri) {
						# rule would cross a spanning cell at this row
						if(ci > startci)
							cur = add(ans, cur, specialce("\\cline{" +
								string (startci+1) + "-" + string ci + "}"));
						startci = ci+1;
					}
				}
				if(ci > startci)
					cur = add(ans, cur, specialce("\\cline{" +
						string (startci+1) + "-" + string ci + "}"));
			}
			else
				cur = add(ans, cur, specialce("\\hline\n"));
		}
	}
	if(tab.border) {
		if(tab.border == 1)
			s = "\\hline\n";
		else
			s = "\\hline\\hline\n";
		cur = add(ans, cur, specialce(s));
	}
	cur = add(ans, cur, specialce("\\end{tabular}\n\\end{center}"));
	if(tab.capcell != nil) {
		cur = add(ans, cur, specialce("\\caption{"));
		cur = addlconvlines(ans, cur, tab.capcell);
		cur = add(ans, cur, specialce("}\n\\end{table}\n"));
	}

	if(ans != nil)
		ans = ans.contents;
	return (ans, "");
}

lcolspec() : string
{
	ans := "";
	for(ci := 0; ci < tab.ncol; ci++)
		ans += lnthcolspec(ci, ci, Anone);
	return ans;
}

lnthcolspec(ci, cie, al: int) : string
{
	ans := "";
	if(ci == 0) {
		if(tab.border == 1)
			ans = "|";
		else if(tab.border > 1)
			ans = "||";
	}
	col := tab.cols[ci];
	if(al == Anone)
		al = col.align.halign;
	case al {
	Acenter =>
		ans += "c";
	Aright =>
		ans += "r";
	* =>
		ans += "l";
	}
	if(ci == cie) {
		if(col.rule == 1)
			ans += "|";
		else if(col.rule > 1)
			ans += "||";
	}
	if(cie == tab.ncol - 1) {
		if(tab.border == 1)
			ans += "|";
		else if(tab.border > 1)
			ans += "||";
	}
	return ans;
}

addlconvlines(par, tail: ref Celem, c: ref Tablecell) : ref Celem
{
	line := c.lines;
	if(line == nil)
		return tail;
	multiline := 0;
	if(line.next != nil) {
		multiline = 1;
		val := "";
		case cellvalign(c) {
		Abaseline or Atop => val = "[t]";
		Abottom => val = "[b]";
		}
		hal := "l";
		case cellhalign(c) {
		Aright => hal = "r";
		Acenter => hal = "c";
		}
		# The @{}'s in the colspec eliminate extra space before and after result
		tail = add(par, tail, specialce("\\begin{tabular}" + val + "{@{}" + hal + "@{}}\n"));
	}
	while(line != nil) {
		for(it := line.items; it != nil; it = it.next) {
			fnum := it.fontnum;
			f := fnum / NSIZE;
			sz := fnum % NSIZE;
			grouped := 0;
			if((f != DefFont || sz != DefSize) && (it.prev!=nil || it.next!=nil)) {
				tail = add(par, tail, specialce("{"));
				grouped = 1;
			}
			if(f != DefFont) {
				fcmd := "";
				case f {
				Roman => fcmd = "\\rmfamily ";
				Italic => fcmd = "\\itshape ";
				Bold => fcmd = "\\bfseries ";
				Type => fcmd = "\\ttfamily ";
				}
				tail = add(par, tail, specialce(fcmd));
			}
			if(sz != DefSize) {
				szcmd := "";
				case sz {
				Size6 => szcmd = "\\footnotesize ";
				Size8 => szcmd = "\\small ";
				Size10 => szcmd = "\\normalsize ";
				Size12 => szcmd = "\\large ";
				Size16 => szcmd = "\\Large ";
				}
				tail = add(par, tail, specialce(szcmd));
			}
			tail = add(par, tail, textce(it.s));
			if(grouped)
				tail = add(par, tail, specialce("}"));
		}
		ln := line.next;
		if(multiline && ln != nil)
			tail = add(par, tail, specialce("\\\\\n"));
		line = line.next;
	}
	if(multiline)
		tail = add(par, tail, specialce("\\end{tabular}\n"));
	return tail;
}

# Return (table as html, error string)
cookhtml(spec: array of ref Lex) : (ref Celem, string)
{
	n := len spec;
	ans := ref Celem(SGML, "", nil, nil, nil, nil);
	cur : ref Celem = nil;
	for(i := 0; i < n; i++) {
		tok := spec[i];
		if(tok.tag == Data)
			cur = add(ans, cur, textce(tok.text));
		else {
			s := html->lex2string(spec[i]);
			cur = add(ans, cur, specialce(s));
		}
	}
	if(ans != nil)
		ans = ans.contents;
	return (ans, "");
}

textce(s: string) : ref Celem
{
	return ref Celem(Text, s, nil, nil, nil, nil);
}

specialce(s: string) : ref Celem
{
	return ref Celem(Special, s, nil, nil, nil, nil);
}

add(par, tail: ref Celem, e: ref Celem) : ref Celem
{
	if(tail == nil) {
		par.contents = e;
		e.parent = par;
	}
	else
		tail.next = e;
	e.prev = tail;
	return e;
}