#
# Text drawing for owptext.b
# Draws a lot more than needed, but it's more simple to debug this way.

# A frame is created by a call to Frame.new()
# Nothing can be done to it before calling init() to fill it with text.
# ss, se, mark, and showsel may be adjusted between new() and init()
# In general, init() is called to reposition or to refill the frame.
# sel() is used to adjust ss and se (selection). 
# The frame keeps blks as given to init, and keeps offsets into them.
# Frame.ins/.del are used after calling ins/del on blks to update the frame idea of offsets
# and to update the frame.
# The image, Frame.i, may be given as nil to init(), and may be set to nil at any time between
# calls to prevent the image from drawing.
# A new image (rectangle) may be set for the frame by calling Frame.resize().
# redraw() forces a complete redraw of the frame.
# scroll() scrolls up/down nlines.
# and pt2pos/pos2pt convert between points and positions in blks.
# Other functions are auxiliary and meant for the implementation.

# We could do something about tabs. Like for example: do not wrap long lines,
# and group blocks of text so that a single tab manages to tab all the text properly.
# Also, we do more work than needed. Might draw a lot less.

# This is not as highly coupled to the rest of o/live as it may seem due to init().
# The only module actually needed is Tblks. We use the rest to access the window image
# and colors, mostly.

# A frame is a list of Tbox, mostly. fmt() is the main routine in charge of text formatting.
# The text from Tblks drawn is cached in the boxes, but for debug checks only.

implement Tframe;
include "mods.m";
mods, win, tree: import dat;
NCOL, HIGH, BACK, TEXT: import gui;
prefix: import str;
include "tblks.m";
	tblks:	Tblks;
	fixpos,  fixposins, fixposdel, dtxt, strstr, Maxline, Blks, strchr, Str: import tblks;
include "tframe.m";

debug := 0;

init(d: Livedat, b: Tblks, dbg: int)
{
	dat = d;
	initmods();
	debug = dbg;
	tblks = b;
}

Frame.panic(fr: self ref Frame, s: string)
{
	fr.dump();
	panic(s);
}

charwidth(f : ref Font, c : int) : int
{
	s : string = "z";
	s[0] = c;
	return f.width(s);
}

nullframe: Frame;
Frame.new(r: Rect, i: ref Image, f: ref Font, cols: array of ref Image, beof: int): ref Frame
{
	if (debug)
		fprint(stderr, "new frame [%d %d %d %d]\n", r.min.x, r.min.y, r.max.x, r.max.y);
	fr := ref nullframe;
	fr.cols = array[NCOL] of ref Image;
	fr.cols[0:] = cols[0:NCOL];
	fr.font = f;
	fr.tabsz = 4;
	fr.showsel = 1;
	fr.showbeof = beof;
	fr.resize(r, i);
	return fr;
}

Frame.resize(fr: self ref Frame, r: Rect, i: ref Image)
{
	if (debug)
		if (i != nil)
			fprint(stderr, "resize frame [%d %d %d %d] img\n", r.min.x, r.min.y, r.max.x, r.max.y);
		else
			fprint(stderr, "resize frame [%d %d %d %d] noimg\n", r.min.x, r.min.y, r.max.x, r.max.y);
	fr.r = r;
	if (fr.showbeof){
		fr.r.min.y += 1;
		fr.r.max.y -= 1;
	}
	fr.i = i;
	fr.sz.x = fr.r.dx()/fr.font.width("M");
	fr.sz.y = fr.r.dy()/fr.font.height;
	fr.boxes = array[0] of ref Tbox;
	fr.nboxes = fr.nr = 0;
	fr.tabwid = fr.tabsz * fr.font.width("O");
	fr.spwid = fr.font.width(" ");
	x := fr.r.dx() / 3;
	if (x > Beofwid)
		x = Beofwid;
	fr.sbeof = fr.r.min.x + (fr.r.dx() - x) / 2;
	fr.ebeof = fr.sbeof + x;
	fr.mktick();
	dpy := win.display;
	fr.lni = dpy.newimage(Rect((0,0), (fr.r.dx(), fr.font.height)), win.image.chans, 0, Draw->White);
	fr.lni.draw(fr.lni.r, fr.cols[BACK], nil, (0,0));

	if (fr.blks != nil)				# nil when called by Frame.new()
		fr.init(fr.blks, fr.pos);
}

# This is being using to change to position and not just blks.
# BUG: throws it all away. Could reuse many of the boxes/images it has
# when new content intersects old one.
Frame.init(fr: self ref Frame, blks: ref Blks, pos: int)
{
	if (debug)
		fprint(stderr, "frame init pos %d\n", pos);
	fr.blks = blks;
	l := blks.blen();
	fr.pos = fixpos(pos, l);
	fr.ss = fixpos(fr.ss, l);
	fr.se = fixpos(fr.se, l);
	fr.mark = fixpos(fr.mark, l);
	fr.boxes = array[0] of ref Tbox;
	fr.nboxes = fr.nr = 0;
	fr.fill();
	fr.chk();
}

Frame.mktick(fr : self ref Frame)
{
	dpy := win.display;
	t := fr.tick = dpy.newimage(Rect((0, 0), (Tickwid, fr.font.height)), win.image.chans, 0, Draw->White);
	t.draw(t.r, fr.cols[BACK], nil, (0, 0));
	t.draw(Rect((Tickwid/2, 0), (Tickwid/2+1, fr.font.height)), fr.cols[TEXT], nil, (0, 0));
	t.draw(Rect((Tickwid/2, 0), (Tickwid, Tickwid)), fr.cols[TEXT], nil, (0,0));
	t.draw(Rect((Tickwid/2, fr.font.height-Tickwid), (Tickwid, fr.font.height)), fr.cols[TEXT], nil, (0,0));
}

getboxes(blks: ref Blks, pos: int, l: int, f: ref Font, maxwid: int): (array of ref Tbox, int)
{
	boxes := array[16] of ref Tbox;
	nboxes := 0;
	b: ref Tbox;
	b = nil;
	wid := 0;
	nr := 0;
	for (i := pos; i < pos + l && wid < maxwid; i++){
		c := blks.getc(i);
		if (c == -1)
			break;
		nr++;
		if (nboxes == len boxes){
			bb := array[len boxes+16] of ref Tbox;
			bb[0:] = boxes;
			boxes = bb;
		}
		case c {
		'\t' =>
			b = ref Tbox('\t', i, 1, (0,0), 0, 1, "\t");
			boxes[nboxes++] = b;
		'\n' =>
			b = ref Tbox('\n', i, 1, (0,0), 0, 1, "\n");
			boxes[nboxes++] = b;
		* =>
			cwid := charwidth(f, c);
			if (b == nil || b.sep){
				b = ref Tbox(0, i, 1, (0,0), cwid, 1, "");
				b.txt[0] = c;
				boxes[nboxes++] = b;
			} else {
				b.txt[b.nr] = c;
				b.nr++;
				b.wid += cwid;
			}
			wid += cwid;
		}
	}
	return (boxes[0:nboxes], nr);
}

# pos is not before fr.pos.
# returns line, field, rune number in box for pos (perhaps one past the last valid ones).
Frame.seek(fr: self ref Frame, pos: int): (int, int)
{
	for(i := 0; i < fr.nboxes; i++){
		b := fr.boxes[i];
		if (pos < b.pos + b.nr){
			ri := pos - b.pos;
			if (b.sep && ri > 0)
				fr.panic("seek bug");
			return (i, ri);
		}
	}
	return (i, 0);
}

Frame.findnl(fr: self ref Frame, bi: int): int
{
	for (i := bi; i < fr.nboxes; i++)
		if (fr.boxes[i].sep == '\n')
			return i;
	return -1;
}

Frame.pt2pos(fr: self ref Frame, pt: Point): int
{
	if (pt.x < fr.r.min.x)
		pt.x = fr.r.min.x;
	if (pt.x > fr.r.max.x)
		pt.x = fr.r.max.x;
	if (pt.y < fr.r.min.y)
		return 0;
	if (pt.y > fr.r.max.y)
		return fr.pos+fr.nr;
	for (i := 0; i < fr.nboxes; i++){
		b := fr.boxes[i];
		r := Rect(b.pt, (b.pt.x+b.wid, b.pt.y+fr.font.height));
		if (pt.in(r)){
			if (b.sep)
				return b.pos;
			else {
				for (i = 0; i < b.nr; i++){
					wid := charwidth(fr.font, fr.blks.getc(b.pos+i));
					r.max.x = r.min.x + wid;
					if (pt.in(r))
						return b.pos+i;
					r.min.x = r.max.x;
				}
				return b.pos+b.nr -1;	# aprox. last rune in box
			}
		}
	}
	return fr.pos+fr.nr;	# aprox. by eof
}

Frame.pos2pt(fr: self ref Frame, pos: int): Point
{
	if (pos < fr.pos)
		pos = fr.pos;
	if (pos > fr.pos + fr.nr)
		pos = fr.pos + fr.nr;
	pt := Point(fr.r.min);
	for (i := 0; i < fr.nboxes; i++){
		b := fr.boxes[i];
		if (pos < b.pos + b.nr){
			pt = b.pt;
			if (b.sep)
				return pt;
			for (i = 0; b.pos + i < pos; i++)
				pt.x += charwidth(fr.font, fr.blks.getc(b.pos+i));
			return pt;
		}
	}
	if (i == fr.nboxes){	# pos was >= fr.pos + fr.nr . place at end.
		if (fr.nboxes == 0)
			return fr.r.min;
		b := fr.boxes[fr.nboxes-1];
		if (b.pt.x + b.wid < fr.r.max.x)				# at end of last line.
			pt = Point(b.pt.x+b.wid, b.pt.y);
		else if (b.pt.y + fr.font.height < fr.r.max.y)	# would be at next line
			pt = Point(fr.r.min.x, b.pt.y + fr.font.height);
		else
			pt = Point(b.pt.x+b.wid, b.pt.y);		 # does not fit. step back.
	}
	return pt;
}

# adjusts frame points. does nothing else.
Frame.move(fr: self ref Frame, at: Point)
{
	if (debug)
		fprint(stderr, "frame move [%d %d]\n", at.x, at.y);
	dx := at.x - fr.r.min.x;
	dy := at.y - fr.r.min.y;
	delta := Point(dx, dy);
	fr.r = fr.r.addpt(delta);
	for (i := 0; i < fr.nboxes; i++){
		fr.boxes[i].pt = fr.boxes[i].pt.add(delta);
		fr.boxes[i].dirty = 1;
	}
}

# length in runes of boxes
blen(boxes: array of ref Tbox): int
{
	l := 0;
	for (i := 0; i < len boxes; i++)
		if (boxes[i].sep)
			l++;
		else
			l += boxes[i].nr;
	return l;
}

# see note in Frame.ins
# renumber is true when chars are new and do not come from box split or whatever.
Frame.addboxes(fr: self ref Frame, bi: int, boxes: array of ref Tbox, renumber: int)
{
	nlen := len boxes + fr.nboxes;
	if (nlen > len fr.boxes){
		nboxes := array[nlen] of ref Tbox;
		if (bi > 0)
			nboxes[0:] = fr.boxes[0:bi];
		if (bi < fr.nboxes)
			nboxes[bi + len boxes:] = fr.boxes[bi:fr.nboxes];
		nboxes[bi:] = boxes;
		fr.boxes = nboxes;
	} else {
		for (i := fr.nboxes - 1; i >= bi; i--)
			fr.boxes[i + len boxes] = fr.boxes[i];
		fr.boxes[bi:] = boxes;
	}
	fr.nboxes += len boxes;
	if (renumber){
		nr := blen(boxes);
		fr.nr += nr;
		for (i := bi + len boxes; i < fr.nboxes; i++)
			fr.boxes[i].pos += nr;
	}
}

# see note in Frame.ins
# renumber is true when chars are new and do not come from box coalescing or whatever.
Frame.delboxes(fr: self ref Frame, bi: int, nb: int, renumber: int)
{
	nr := blen(fr.boxes[bi:bi+nb]);
	for (i := bi; i+nb< fr.nboxes; i++)
		fr.boxes[i] = fr.boxes[i+nb];
	if (i < len fr.boxes)
		fr.boxes[i] = nil;	# poison
	fr.nboxes -= nb;
	if (renumber){
		fr.nr -= nr;
		for (i = bi; i < fr.nboxes; i++)
			fr.boxes[i].pos -= nr;
	}
}

# splits boxes[bi] leaving rune at ri in the second box.
# widths are NOT computed (because during ins/del in frame postions
# would be wrong.
Frame.splitbox(fr: self ref Frame, bi: int, ri: int)
{
	b := fr.boxes[bi];
	if (debug>1)
		fprint(stderr, "\t splitbox %d %d {%s}\n", bi, ri, b.text());
	if (ri == 0 || b.sep || ri > b.nr || b.nr != len b.txt)
		fr.panic("split bug");
	nb := ref Tbox(0, b.pos + ri, b.nr - ri, (0, 0), 0, 0, b.txt[ri:]);
	nb.wid = b.wid = 0;
	b.nr = ri;
	b.txt = b.txt[0:ri];
	b.dirty = nb.dirty = 1;
	fr.addboxes(bi+1, array[] of {nb}, 0);
}

Frame.fixselins(fr: self ref Frame, pos: int, nr: int)
{
	if (pos >= fr.ss && pos <= fr.se){
		if (fr.ss == fr.se)
			fr.ss = fr.se = pos + nr;
		else if (pos+nr > fr.se)
			fr.se = pos+nr;
		else
			fr.se += nr;
	} else if (pos < fr.ss){
		fr.ss += nr;
		fr.se += nr;
	}
}

# If text was inserted before/after the frame. we adjust positions and do nothing. Otherwise,
# some text has been inserted in fr.blks, which makes all the offsets void from
# the point of insertion. We build new boxes for all the new text, and insert them in place.
# To avoid adding too many boxes once the frame is full, we add only as many as 
# needed to fill an entire frame, considering that the tab and newline width is 0. 
# That is conservative, but it's simple and at least we know that offsets are right.
# At that point we can reformat the text boxes in the frame.
# Returns true if further insertion is futile (eof or frame full).
# Also, adjust the selection to so it moves when inserting, but is otherwise
# kept ok despite insertions before/after the current selection.
Frame.ins(fr: self ref Frame, pos: int, nr: int): int
{
	if (debug)
		fprint(stderr, "frame ins %d %d\n", pos, nr);
	fr.mark = fixposins(fr.mark, pos, nr);
	fr.fixselins(pos, nr);
	if (pos > fr.pos + fr.nr || nr == 0)
		return 1;
	if (pos < fr.pos){
		fr.pos += nr;
		for (i := 0; i < len fr.boxes; i++)
			fr.boxes[i].pos += nr;
		return 0;
	}
	r :=ins(fr, pos, nr);
	fr.sel(fr.ss, fr.se);
	return r;
}

# This is the actual insert, but does not fix up ss, se, mark, nor pos.
# Used by both Frame.ins and Frame.fill
ins(fr: ref Frame, pos: int, nr: int): int
{
	if (debug)
		fprint(stderr, "frame _ins %d %d\n", pos, nr);
	(bi, ri) := fr.seek(pos);
	maxwid := fr.r.dx() * (fr.r.dy()/fr.font.height);
	if (bi > 0)
		maxwid -= fr.boxes[bi-1].pt.y / fr.font.height;
	(boxes, nbr) := getboxes(fr.blks, pos, nr, fr.font, maxwid);
	if (nbr == 0)
		return 1;
	nboxes := len boxes;
	if (ri > 0){
		fr.splitbox(bi, ri);
		nboxes++;
		fr.sizebox(bi);
		fr.sizebox(bi+1);
		fr.addboxes(bi+1, boxes, 1);
	} else
		fr.addboxes(bi, boxes, 1);
	fr.chk();

	if (bi > 0)
		bi--;	# the first box might recombine with the first new one.
	full := fr.fmt(bi);
	if (nbr < nr)
		full = 1;
	if (debug > 1)
		fr.dump();
	return full;
}

Frame.fill(fr: self ref Frame)
{
	# insertion at end extends the frame, does not update offsets.
	for(pos := fr.pos + fr.nr; ins(fr, pos, 256) == 0; pos += 256)
		;
}

Frame.fixseldel(fr: self ref Frame, pos: int, nr: int)
{
	# compute intersection of selection and deleted text,
	# and number of runes removed from selection.
	ds := pos;
	de := pos + nr;
	ns := fr.se - fr.ss;
	if (de <= fr.ss)			# empty isect;
		nr = nr;
	else if (ds >= fr.se)		# empty isect
		nr = 0;
	else {
		if (ds < fr.ss){		# isect ==  [max(ds, fr.ss), min(de, fr.se)]
			ds = fr.ss;
			nr = ds - fr.ss;
		}  else
			nr = 0;
		if (de > fr.se)
			de = fr.se;
		ns -= (de - ds);
	}
	# adjust
	fr.ss -= nr;
	fr.se = fr.ss + ns;
	if (fr.ss > fr.blks.blen())			# pure paranoia
		fr.ss = fr.se = fr.blks.blen();
}

# We proceed like we did for ins. Adust offsets if does not affect frame,
# or remove involved boxes and then reformat. However, this time we
# refill the frame after formatting it, because there might be more room for text.
Frame.del(fr: self ref Frame, pos: int, nr: int)
{
	if (debug)
		fprint(stderr, "frame del %d %d\n", pos, nr);
	fr.fixseldel(pos, nr);
	fr.mark = fixposdel(fr.mark, pos, nr);
	if (pos >= fr.pos + fr.nr || nr == 0)
		return;
	if (pos + nr< fr.pos){
		fr.pos -= nr;
		for (i := 0; i < len fr.boxes; i++)
			fr.boxes[i].pos -= nr;
		return;
	}
	(bs, rs) := fr.seek(pos);
	if (rs > 0){
		fr.splitbox(bs, rs); 
		bs++;
	}
	(be, re) := fr.seek(pos+nr);
	if (re > 0){
		fr.splitbox(be, re);
		be++;			# and include the first part
		re = 0;
	}
	fr.delboxes(bs, be-bs, 1);
	fr.chk();

	# bs-1 is now right before deletion. bs is right after deletion.
	# must redraw/resize them.
	if (bs > 0 && fr.nboxes > 0){
		fr.boxes[bs-1].dirty = 1;
		fr.sizebox(bs-1);
	}
	if (bs<fr.nboxes){
		fr.boxes[bs].dirty = 1;
		fr.sizebox(bs);
	}
	fr.fmt(bs);
	fr.fill();
	if (debug > 1)
		fr.dump();
	sel(fr, fr.ss, fr.se);
}

selrange(fr: ref Frame, s, e: int): (int, int)
{
	(bs, nil) := fr.seek(s);
	(be, nil) := fr.seek(e);
	if (be < fr.nboxes)
		be++;
	if (bs == be && bs == fr.nboxes && bs > 0)
		bs--;	# last box draws eot tick
	return (bs, be);
}

sel(fr: ref Frame, ss: int, se: int)
{
	os := fr.ss;
	oe := fr.se;
	fr.ss = ss;
	fr.se = se;
	if (fr.i == nil)
		return;
	bs := be := ns := ne := -1;
	if (fr.ss < os &&  fr.se == oe) 			# extend back
		(bs, be) = selrange(fr, fr.ss, os);
	else if (fr.ss == os && fr.se > oe)		# extend fwd
		(bs, be) = selrange(fr, oe, fr.se);
	else {
		(bs, be) = selrange(fr, os, oe);		# clear old
		(ns, ne) = selrange(fr, fr.ss, fr.se);	# and draw new.
	}
	if (debug)
		fprint(stderr, "frame sel %d %d ob(%d:%d) nb(%d:%d)\n", ss, se, bs, be, ns, ne);
	fr.draw(bs, be, 1);
	if (ns >= 0)
		for (i := ns; i < ne; i++)
			if (i < bs || i >= be)
				fr.drawbox(i);
}

# change selection to ss se
Frame.sel(fr: self ref Frame, ss: int, se: int)
{
	ss = fixpos(ss, fr.blks.blen());
	se = fixpos(se, fr.blks.blen());
	if (fr.ss != ss || fr.se != se)
		sel(fr, ss, se);
}

# Sets positions for boxes[b0:be], sizing sep boxes and
# splitting/combining text boxes as needed to format the text.
# should the frame fill, remaining boxes are removed and returns true.
Frame.fmt(fr: self ref Frame, bi: int): int
{
	if (bi >= fr.nboxes)
		return 0;
	if (debug)
		fprint(stderr, "frame fmt b %d {%s}...\n", bi, fr.boxes[bi].text());
	bs := bi;
	for(; bi < fr.nboxes; bi++){
		b := fr.boxes[bi];
		fr.placebox(bi);
		if (b.pt.y+fr.font.height > fr.r.max.y){	# frame full, truncate
			fr.delboxes(bi, fr.nboxes - bi, 1);
			fr.draw(bs, bi, 0);
			return 1;
		}
		if (b.sep)
			fr.sizebox(bi);
		else {
			if (b.pt.x + b.wid > fr.r.max.x){
				if (debug>1) fprint(stderr, "\t wrap %s\n", b.text());
				nbi := fr.wrapbox(bi);
				if (fr.boxes[nbi].pt.y+fr.font.height > fr.r.max.y){
					fr.delboxes(nbi, fr.nboxes-nbi, 1);
					fr.draw(bs, bi, 0);
					return 1;
				}
			} else if (bi+1 < fr.nboxes && !fr.boxes[bi+1].sep){
				# try to combine at least two of them.
				if (fr.combinebox(bi))
					if (debug>1) fprint(stderr, "\t combine %s\n", b.text());
				if (fr.boxes[bi+1].nr == 0)
					fr.delboxes(bi+1, 1, 0);
			}
		}
	}

	# Adjust y coord for the rest of boxes. But don't do so if
	# the first does not change placement: no lines added/removed.
	if (bi < fr.nboxes){
		pt := fr.boxes[bi].pt;
		fr.placebox(bi);
		if (pt.eq(fr.boxes[bi].pt)){
			fr.draw(bs, fr.nboxes, 0);
			return 1;
		}
	}
	for(; bi < fr.nboxes; bi++){
		fr.placebox(bi);
		if (fr.boxes[bi].pt.y+fr.font.height > fr.r.max.y){
			fr.delboxes(bi, fr.nboxes-bi, 1);
			fr.draw(bs, bi, 0);
			return 1;
		}
	}
	fr.draw(bs, fr.nboxes, 0);
	return 0;
}

# determine point for box. It might go off-limits, but the pt
# is set ok according to the previous boxes.
Frame.placebox(fr: self ref Frame,  bi: int)
{
	b := fr.boxes[bi];
	opt := b.pt;
	if (bi > 0){
		lb := fr.boxes[bi-1];
		if (lb.sep != '\n' && lb.pt.x + lb.wid < fr.r.max.x)
			b.pt = Point(lb.pt.x+lb.wid, lb.pt.y);
		else
			b.pt = Point(fr.r.min.x, lb.pt.y+fr.font.height);
	} else
		b.pt = fr.r.min;
	if (!opt.eq(b.pt))
		b.dirty = 1;
}

# drain as many runes as feasingle from bi+1 into bi.
Frame.combinebox(fr: self ref Frame, bi: int): int
{
	b := fr.boxes[bi];
	nb := fr.boxes[bi+1];
	# Try to do at once
	if (b.pt.x + b.wid + nb.wid <= fr.r.max.x){
		b.nr += nb.nr;
		b.wid += nb.wid;
		b.txt += nb.txt;
		nb.nr = 0;
		nb.wid = 0;
		nb.txt = "";
		b.dirty = 1;
		return 1;
	}
	x := b.pt.x + b.wid;
	wid := 0;
	for(i := 0; i < nb.nr; i++){
		cw := charwidth(fr.font, fr.blks.getc(nb.pos+i));
		if (x + wid + cw > fr.r.max.x)
			break;
		wid += cw;
	}
	if (i > 0){
		b.nr += i;
		b.txt += nb.txt[0:i];
		b.wid += wid;
		b.dirty = 1;
		nb.pos += i;
		nb.nr -= i;
		nb.txt = nb.txt[i:];
		nb.wid -= wid;
		nb.dirty = 1;
		return 1;
	}
	return 0;
}

# Wraps box bi (which has to) either complete or a suffix.
# returns the index for the wrapped box (itself or suffix).
Frame.wrapbox(fr: self ref Frame, bi: int): int
{
	b := fr.boxes[bi];
	wid := 0;
	for (i := 0; i < b.nr; i++){
		cw := charwidth(fr.font, fr.blks.getc(b.pos+i));
		if (b.pt.x + wid + cw > fr.r.max.x)
			break;
		wid += cw;
	}
	if (i == b.nr)
		fr.panic("wrap at the end of a box?");
	pt := Point(fr.r.min.x, b.pt.y + fr.font.height);
	if (i == 0){
		b.pt = pt;
		b.dirty = 1;
		return bi;
	}
	nb := ref Tbox(0, b.pos + i, b.nr - i, pt, b.wid - wid, 1, b.txt[i:b.nr]);
	b.wid = wid;
	b.nr = i;
	b.dirty = 1;
	b.txt = b.txt[0:i];
	b.dirty = 1;
	nb.dirty = 1;
	fr.addboxes(bi+1, array[] of {nb}, 0);
	return bi+1;
}

# adjust sizes for sep boxes, which are dynamic.
# recompute width for text boxes.
Frame.sizebox(fr: self ref Frame, bi: int)
{
	b := fr.boxes[bi];
	owid := b.wid;
	case b.sep {
	'\t' =>
		b.wid = fr.tabwid - (b.pt.x%fr.tabwid);
		if (b.wid < fr.spwid)
			b.wid = fr.spwid;
		if (b.pt.x < fr.r.max.x && b.pt.x + b.wid > fr.r.max.x)
			b.wid = fr.r.max.x - b.pt.x;
	'\n' =>
		b.wid = fr.r.max.x - b.pt.x;
	0 =>
		b.wid = 0;
		for (i := 0; i < b.nr; i++){
			c := fr.blks.getc(b.pos+i);
			b.wid += charwidth(fr.font, c);
		}
	}
	if (b.wid != owid)
		b.dirty = 1;
}

Frame.boxtext(fr: self ref Frame, bi: int): string
{
	b := fr.boxes[bi];
	s := "";
	for (j:= 0; j < b.nr; j++)
		s[j] = fr.blks.getc(b.pos+j);
	return s;
}

Frame.chk(fr: self ref Frame)
{
	nr := blen(fr.boxes[0:fr.nboxes]);
	if (nr != fr.nr)
		fr.panic("nr check");
	for (i := 0; i < fr.nboxes; i++){
		b := fr.boxes[i];
		s := fr.boxtext(i);
		if (s != b.txt)
			fr.panic(sprint("box %d check: pos %d nr %d txt [%s] blks [%s]\n", 
						i, b.pos, b.nr, b.txt, s));
	}
	if (fr.ss < 0 || fr.se < 0 || fr.mark < 0)
		fr.panic(sprint("bad sel/mark %d %d %d\n", fr.ss, fr.se, fr.mark));
	l := fr.blks.blen();
	if (fr.ss > l || fr.se > l || fr.mark > l)
		fprint(stderr, "warning: sel out of range: %d %d %d\n", fr.ss, fr.se, fr.mark);
}

Frame.drawtick(fr: self ref Frame, i: ref Image, pt: Point)
{
	if (pt.x > fr.r.min.x)	# looks better
		pt.x--;
	r := Rect(pt, (pt.x+Tickwid, pt.y+fr.font.height));
	i.draw(r, fr.tick, nil, (0, 0));
}

drawmark(fr: ref Frame, y: int, mark: int)
{
	if (mark){
		rr := Rect((fr.r.min.x, y), (fr.sbeof, y+1));
		fr.i.draw(rr, fr.cols[BACK], nil, (0,0));
		rr = Rect((fr.sbeof, y), (fr.ebeof, y+1));
		fr.i.draw(rr, fr.cols[TEXT], nil, (0,0));
		rr = Rect((fr.ebeof, y), (fr.r.max.x, y+1));
		fr.i.draw(rr, fr.cols[BACK], nil, (0,0));
	} else {
		rr := Rect((fr.r.min.x, y), (fr.r.max.x, y+1));
		fr.i.draw(rr, fr.cols[BACK], nil, (0,0));
	}
}


Frame.draw(fr: self ref Frame, bi: int, be: int, force: int)
{
	if (fr.i == nil)
		return;
	if (debug)
		fprint(stderr, "frame draw bi %d be %d fz %d\n", bi, be, force);
	if (fr.nboxes == 0){
		if (fr.showbeof){
			drawmark(fr, fr.r.min.y-1, 1);
			drawmark(fr, fr.r.min.y+fr.font.height, 1);
			if (fr.r.min.y+fr.font.height != fr.r.max.y)
				drawmark(fr, fr.r.max.y, 0);
		}
		fr.i.draw(fr.r, fr.cols[BACK], nil, (0,0));
		if (fr.showsel)
			fr.drawtick(fr.i, fr.r.min);
	} else
		for (i := bi; i < be; i++)
			if (force || fr.boxes[i].dirty)
				fr.drawbox(i);
}

Frame.redraw(fr: self ref Frame)
{
	fr.draw(0, fr.nboxes, 1);
}

# The primary drawing function.
# Draws the box mentioned, drawing the selection within the box if it's affected.
# Also, last box in line clears the rest of the line and last in frame clears rest of f.r.
# drawing the tick past it when it's at end of text in frame.

Frame.drawbox(fr: self ref Frame, bi: int)
{
	b := fr.boxes[bi];
	if (debug>1)
		fprint(stderr, "frame drawbox %s\n", b.text());
	tickpt := Point(-1, -1);
	s := b.pos;
	e := b.pos + b.nr;
	pt := Point(0,0);
	r := Rect((0, 0), (b.wid, fr.font.height));
	fr.lni.draw(r, fr.cols[BACK], nil, (0, 0));
	# draw selection or determine tick position if box is affected.
	if (fr.ss < s && fr.se >= e || fr.ss >= s && fr.ss < e || fr.se >= s && fr.se < e){
		if (fr.ss != fr.se){
			ss := fr.ss;
			if (ss < s)
				ss = s;
			spt := fr.pos2pt(ss);
			ept := Point(spt.x+b.wid, 0);
			if (fr.se < e)
				ept = fr.pos2pt(fr.se);
			ept.y = 0;
			if (debug>1)
				fprint(stderr, "\tsel: pos %d %d [%d %d] [%d %d]\n", fr.ss, fr.se, spt.x, spt.y, ept.x, ept.y);
			fr.lni.draw(Rect((spt.x-b.pt.x, 0), (ept.x-b.pt.x, fr.font.height)), fr.cols[HIGH], nil, (0,0));
		} else {
			tickpt = fr.pos2pt(fr.ss);
			if (debug>1)
				fprint(stderr, "\ttick: pos %d pt [%d %d]\n", fr.ss, tickpt.x, tickpt.y);
			tickpt.y = 0;
			tickpt.x -= b.pt.x;
		}
	}
	if (!b.sep)
		fr.lni.text(pt, fr.cols[TEXT], (0,0), fr.font, fr.boxtext(bi));
	if (tickpt.x != -1 && fr.showsel)
		fr.drawtick(fr.lni, tickpt);
	fr.i.draw((b.pt, (b.pt.x+b.wid, b.pt.y+fr.font.height)), fr.lni, nil, (0,0));
	b.dirty = 0;

	# clear rest of line if last box on line (plain boxes do not consume all the line)
	if (bi == fr.nboxes-1 || fr.boxes[bi+1].pt.y != b.pt.y )
	if (b.pt.x + b.wid < fr.r.max.x){
		col := fr.cols[BACK];
		if (b.pos+b.nr > fr.ss && b.pos+b.nr < fr.se)
			col = fr.cols[HIGH];
		r = Rect((b.pt.x+b.wid, b.pt.y), (fr.r.max.x, b.pt.y+fr.font.height));
		fr.i.draw(r, col, nil, (0,0));
	}

	# clear rest of rect if last box on frame and empty space below.
	if (bi == fr.nboxes-1 && b.pt.y + fr.font.height < fr.r.max.y){
		r= Rect((fr.r.min.x, b.pt.y+fr.font.height), fr.r.max);
		if (fr.showbeof)
			r.min.y++; # do not clear the eof mark line (flicker)
		fr.i.draw(r, fr.cols[BACK], nil, (0,0));
	}

	# draw tick if past the last box.
	if (bi == fr.nboxes-1 && fr.showsel && fr.ss == fr.se && fr.ss == fr.pos + fr.nr)
		fr.drawtick(fr.i, fr.pos2pt(fr.ss));

	# draw bof/eof if appropriate
	if (fr.showbeof && bi == 0)
		drawmark(fr, fr.r.min.y-1, fr.pos == 0);
	if (fr.showbeof && bi == fr.nboxes-1){
		y := b.pt.y + fr.font.height;
		drawmark(fr, y, fr.pos+fr.nr >= fr.blks.blen());
		if (y != fr.r.max.y)
			drawmark(fr, fr.r.max.y, 0); # clear reserved space.
	}
}

# Scrolls down (negative nl) or up (possitive nl) by moving the frame up or down.
# Scroll up/down stops when at the first line/only last line is shown.
# A scroll might move more than requested, because we guess how many
# chars to move (cf. line wrap). 
Frame.scroll(fr: self ref Frame, nl: int)
{
	if (debug)
		fprint(stderr, "frame scroll %d\n", nl);
	s := fr.blks.pack();
	l := fr.blks.blen();
	if (nl == 0 || nl > 0 && fr.pos + fr.nr >= l || nl < 0 && fr.pos == 0)
		return;
	npos := fr.pos;
	if (nl > 0){	# move down (scroll up)
		do {
			p := s.find(npos, '\n', Maxline);
			if (p < 0)
				break;
			npos = p;
			if (s.s[p] == '\n' && p < l)	# position just after the \n
				npos++;
		} while (--nl > 0);
	} else {	# move up (scroll down)
		do {
			p := s.findr(npos, '\n', Maxline);
			if (p < 0){
				npos = 0;
				break;
			}
			npos = p;
			if (s.s[p] == '\n' && p > 0)	# position right before the \n
				npos--;
		} while (++nl < 1);			# <1 for the \n right before the frame
		if (npos > 0 && npos+2 < l)	# skip after the \n just found,
			npos += 2;			# but not when at the start of text.
	}
	if (npos == fr.pos)
		return;
	# Easier but too slow.
	fr.init(fr.blks, npos);
}

Tbox.text(b: self ref Tbox): string
{
	s := "";
	if (b.dirty)
		s += "d ";
	case b.sep {
	'\t' =>
		 s += sprint("%d %d:%d [\\t ]", b.pos, b.pt.x, b.wid);
	'\n' =>
		s += sprint("%d %d:%d [\\n]", b.pos, b.pt.x, b.wid);
	* =>
		s += sprint("%d %d:%d [%s]", b.pos, b.pt.x, b.wid, b.txt);
	}
	return s;
}

Frame.dump(fr: self ref Frame)
{
	s := sprint("frame: %d boxes (arry %d) pos %d nr %d sel %d %d\n",
		fr.nboxes, len fr.boxes, fr.pos, fr.nr, fr.ss, fr.se);
	i := fr.i;
	if (fr.i != nil)
		s += sprint(" img [%d %d %d %d]", i.r.min.x, i.r.min.y, i.r.max.x, i.r.max.y);
	r := fr.r;
	s += sprint(" r [%d %d %d %d] sz [%d %d] rsz [%d %d] :\n", r.min.x, r.min.y, r.max.x, r.max.y,
			fr.sz.x, fr.sz.y, fr.r.dx(), fr.r.dy());
	for (bi := 0; bi < fr.nboxes; bi++){
		b := fr.boxes[bi];
		s += sprint("\t%d: %s\n", bi, b.text());
	}
	fprint(stderr, "%s\n\n", s);
}