20060303a

1 files changed, 4828 insertions, 0 deletions

diff --git a/appl/charon/layout.b b/appl/charon/layout.b
new file mode 100644
index 00000000..6db8f619
--- /dev/null
+++ b/appl/charon/layout.b
@@ -0,0 +1,4828 @@
+implement Layout;
+
+include "common.m";
+include "keyboard.m";
+
+sys: Sys;
+CU: CharonUtils;
+	ByteSource, MaskedImage, CImage, ImageCache, max, min,
+	White, Black, Grey, DarkGrey, LightGrey, Blue, Navy, Red, Green, DarkRed: import CU;
+
+D: Draw;
+	Point, Rect, Font, Image, Display: import D;
+S: String;
+T: StringIntTab;
+U: Url;
+	Parsedurl: import U;
+I: Img;
+	ImageSource: import I;
+J: Script;
+E: Events;
+	Event: import E;
+G: Gui;
+	Popup: import G;
+B: Build;
+
+# B : Build, declared in layout.m so main program can use it
+	Item, ItemSource,
+	IFbrk, IFbrksp, IFnobrk, IFcleft, IFcright, IFwrap, IFhang,
+	IFrjust, IFcjust, IFsmap, IFindentshift, IFindentmask,
+	IFhangmask,
+	Voffbias,
+	ISPnull, ISPvline, ISPhspace, ISPgeneral,
+	Align, Dimen, Formfield, Option, Form,
+	Table, Tablecol, Tablerow, Tablecell,
+	Anchor, DestAnchor, Map, Area, Kidinfo, Docinfo,
+	Anone, Aleft, Acenter, Aright, Ajustify, Achar, Atop, Amiddle,
+	Abottom, Abaseline,
+	Dnone, Dpixels, Dpercent, Drelative,
+	Ftext, Fpassword, Fcheckbox, Fradio, Fsubmit, Fhidden, Fimage,
+	Freset, Ffile, Fbutton, Fselect, Ftextarea,
+	Background,
+	FntR, FntI, FntB, FntT, NumStyle,
+	Tiny, Small, Normal, Large, Verylarge, NumSize, NumFnt, DefFnt,
+	ULnone, ULunder, ULmid,
+	FRnoresize, FRnoscroll, FRhscroll, FRvscroll,
+	FRhscrollauto, FRvscrollauto
+    : import B;
+
+# font stuff
+Fontinfo : adt {
+	name:	string;
+	f:	ref Font;
+	spw:	int;			# width of a space in this font
+};
+
+fonts := array[NumFnt] of {
+	FntR*NumSize+Tiny => Fontinfo("/fonts/charon/plain.tiny.font", nil, 0),
+	FntR*NumSize+Small => ("/fonts/charon/plain.small.font", nil, 0),
+	FntR*NumSize+Normal => ("/fonts/charon/plain.normal.font", nil, 0),
+	FntR*NumSize+Large => ("/fonts/charon/plain.large.font", nil, 0),
+	FntR*NumSize+Verylarge => ("/fonts/charon/plain.vlarge.font", nil, 0),
+	
+	FntI*NumSize+Tiny => ("/fonts/charon/italic.tiny.font", nil, 0),
+	FntI*NumSize+Small => ("/fonts/charon/italic.small.font", nil, 0),
+	FntI*NumSize+Normal => ("/fonts/charon/italic.normal.font", nil, 0),
+	FntI*NumSize+Large => ("/fonts/charon/italic.large.font", nil, 0),
+	FntI*NumSize+Verylarge => ("/fonts/charon/italic.vlarge.font", nil, 0),
+	
+	FntB*NumSize+Tiny => ("/fonts/charon/bold.tiny.font", nil, 0),
+	FntB*NumSize+Small => ("/fonts/charon/bold.small.font", nil, 0),
+	FntB*NumSize+Normal => ("/fonts/charon/bold.normal.font", nil, 0),
+	FntB*NumSize+Large => ("/fonts/charon/bold.large.font", nil, 0),
+	FntB*NumSize+Verylarge => ("/fonts/charon/bold.vlarge.font", nil, 0),
+	
+	FntT*NumSize+Tiny => ("/fonts/charon/cw.tiny.font", nil, 0),
+	FntT*NumSize+Small => ("/fonts/charon/cw.small.font", nil, 0),
+	FntT*NumSize+Normal => ("/fonts/charon/cw.normal.font", nil, 0),
+	FntT*NumSize+Large => ("/fonts/charon/cw.large.font", nil, 0),
+	FntT*NumSize+Verylarge => ("/fonts/charon/cw.vlarge.font", nil, 0)
+};
+
+# Seems better to use a slightly smaller font in Controls, to match other browsers
+CtlFnt: con (FntR*NumSize+Small);
+
+# color stuff.  have hash table mapping RGB values to D->Image for that color
+Colornode : adt {
+	rgb:	int;
+	im:	ref Image;
+	next:	ref Colornode;
+};
+
+# Source of info for page (html, image, etc.)
+Source: adt {
+	bs:	ref ByteSource;
+	redirects:	int;
+	pick {
+		Srequired or
+		Shtml =>
+			itsrc: ref ItemSource;
+		Simage =>
+			ci: ref CImage;
+			itl: list of ref Item;
+			imsrc: ref ImageSource;
+	}
+};
+
+Sources: adt {
+	main: ref Source;
+	reqd: ref Source;
+	srcs: list of ref Source;
+
+	new: fn(m : ref Source) : ref Sources;
+	add: fn(srcs: self ref Sources, s: ref Source, required: int);
+	done: fn(srcs: self ref Sources, s: ref Source);
+	waitsrc: fn(srcs : self ref Sources) : ref Source;
+};
+
+NCOLHASH : con 19;	# 19 checked for standard colors: only 1 collision
+colorhashtab := array[NCOLHASH] of ref Colornode;
+
+# No line break should happen between adjacent characters if
+# they are 'wordchars' : set in this array, or outside the array range.
+# We include certain punctuation characters that are not traditionally
+# regarded as 'word' characters.
+wordchar := array[16rA0] of {
+	'!' => byte 1, 
+	'0'=>byte 1, '1'=>byte 1, '2'=>byte 1, '3'=>byte 1, '4'=>byte 1,
+	'5'=>byte 1, '6'=>byte 1, '7'=>byte 1, '8'=>byte 1, '9'=>byte 1,
+	':'=>byte 1, ';' => byte 1,
+	'?' => byte 1,
+	'A'=>byte 1, 'B'=>byte 1, 'C'=>byte 1, 'D'=>byte 1, 'E'=>byte 1, 'F'=>byte 1,
+	'G'=>byte 1, 'H'=>byte 1, 'I'=>byte 1, 'J'=>byte 1, 'K'=>byte 1, 'L'=>byte 1,
+	'M'=>byte 1, 'N'=>byte 1, 'O'=>byte 1, 'P'=>byte 1, 'Q'=>byte 1, 'R'=>byte 1,
+	'S'=>byte 1, 'T'=>byte 1, 'U'=>byte 1, 'V'=>byte 1, 'W'=>byte 1, 'X'=>byte 1,
+	'Y'=>byte 1, 'Z'=>byte 1,
+	'a'=>byte 1, 'b'=>byte 1, 'c'=>byte 1, 'd'=>byte 1, 'e'=>byte 1, 'f'=>byte 1,
+	'g'=>byte 1, 'h'=>byte 1, 'i'=>byte 1, 'j'=>byte 1, 'k'=>byte 1, 'l'=>byte 1,
+	'm'=>byte 1, 'n'=>byte 1, 'o'=>byte 1, 'p'=>byte 1, 'q'=>byte 1, 'r'=>byte 1,
+	's'=>byte 1, 't'=>byte 1, 'u'=>byte 1, 'v'=>byte 1, 'w'=>byte 1, 'x'=>byte 1,
+	'y'=>byte 1, 'z'=>byte 1,
+	'_'=>byte 1,
+	'\''=>byte 1, '"'=>byte 1, '.'=>byte 1, ','=>byte 1, '('=>byte 1, ')'=>byte 1,
+	* => byte 0
+};
+
+TABPIX: con 30;		# number of pixels in a tab
+CAPSEP: con 5;			# number of pixels separating tab from caption
+SCRBREADTH: con 14;	# scrollbar breadth (normal)
+SCRFBREADTH: con 14;	# scrollbar breadth (inside child frame or select control)
+FRMARGIN: con 0;		# default margin around frames
+RULESP: con 7;			# extra space before and after rules
+POPUPLINES: con 12;	# number of lines in popup select list
+MINSCR: con 6;			# min size in pixels of scrollbar drag widget
+SCRDELTASF: con 10000;	# fixed-point scale factor for scrollbar per-pixel step
+
+# all of the following include room for relief
+CBOXWID: con 14;		# check box width
+CBOXHT: con 12;		# check box height
+ENTVMARGIN : con 4;	# vertical margin inside entry box
+ENTHMARGIN : con 6;	# horizontal margin inside entry box
+SELMARGIN : con 4;		# margin inside select control
+BUTMARGIN: con 4;		# margin inside button control
+PBOXWID: con 10;		# progress box width
+PBOXHT: con 16;		# progress box height
+PBOXBD: con 2;		# progress box border width
+
+TABLEMAXTARGET: con 2000;	# targetwidth to get max width of table cell
+TABLEFLOATTARGET: con 1;	# targetwidth for floating tables
+
+SELBG: con 16r00FFFF;	# aqua
+
+ARPAUSE : con 500;			# autorepeat initial delay (ms)
+ARTICK : con 100;			# autorepeat tick delay (ms)
+
+display: ref D->Display;
+
+dbg := 0;
+dbgtab := 0;
+dbgev := 0;
+linespace := 0;
+lineascent := 0;
+charspace := 0;
+spspace := 0;
+ctllinespace := 0;
+ctllineascent := 0;
+ctlcharspace := 0;
+ctlspspace := 0;
+frameid := 0;
+zp := Point(0,0);
+
+init(cu: CharonUtils)
+{
+	CU = cu;
+	sys = load Sys Sys->PATH;
+	D = load Draw Draw->PATH;
+	S = load String String->PATH;
+	T = load StringIntTab StringIntTab->PATH;
+	U = load Url Url->PATH;
+	if (U != nil)
+		U->init();
+	E = cu->E;
+	G = cu->G;
+	I = cu->I;
+	J = cu->J;
+	B = cu->B;
+	display = G->display;
+
+	# make sure default and control fonts are loaded
+	getfont(DefFnt);
+	fnt := fonts[DefFnt].f;
+	linespace = fnt.height;
+	lineascent = fnt.ascent;
+	charspace = fnt.width("a");	# a kind of average char width
+	spspace = fonts[DefFnt].spw;
+	getfont(CtlFnt);
+	fnt = fonts[CtlFnt].f;
+	ctllinespace = fnt.height;
+	ctllineascent = fnt.ascent;
+	ctlcharspace = fnt.width("a");
+	ctlspspace = fonts[CtlFnt].spw;
+}
+
+stringwidth(s: string): int
+{
+	return fonts[DefFnt].f.width(s)/charspace;
+}
+
+# Use bsmain to fill frame f.
+# Return buffer containing source when done.
+layout(f: ref Frame, bsmain: ref ByteSource, linkclick: int) : array of byte
+{
+	dbg = int (CU->config).dbg['l'];
+	dbgtab = int (CU->config).dbg['t'];
+	dbgev = int (CU->config).dbg['e'];
+	if(dbgev)
+		CU->event("LAYOUT", 0);
+	sources : ref Sources;
+	hdr := bsmain.hdr;
+	auth := "";
+	url : ref Parsedurl;
+	if (bsmain.req != nil) {
+		auth = bsmain.req.auth;
+		url = bsmain.req.url;
+	}
+#	auth := bsmain.req.auth;
+	ans : array of byte = nil;
+	di := Docinfo.new();
+	if(linkclick && f.doc != nil)
+		di.referrer = f.doc.src;
+	f.reset();
+	f.doc = di;
+	di.frameid = f.id;
+	di.src = hdr.actual;
+	di.base = hdr.base;
+	di.refresh = hdr.refresh;
+	if (hdr.chset != nil)
+		di.chset = hdr.chset;
+	di.lastModified = hdr.lastModified;
+	if(J != nil)
+		J->havenewdoc(f);
+	oclipr := f.cim.clipr;
+	f.cim.clipr = f.cr;
+	if(f.framebd != 0) {
+		f.cr = f.r.inset(2);
+		drawborder(f.cim, f.cr, 2, DarkGrey);
+	}
+	fillbg(f, f.cr);
+	G->flush(f.cr);
+	f.cim.clipr = oclipr;
+	if(f.flags&FRvscroll)
+		createvscroll(f);
+	if(f.flags&FRhscroll)
+		createhscroll(f);
+	l := Lay.new(f.cr.dx(), Aleft, f.marginw, di.background);
+	f.layout = l;
+	anyanim := 0;
+	if(hdr.mtype == CU->TextHtml || hdr.mtype == CU->TextPlain) {
+		itsrc := ItemSource.new(bsmain, f, hdr.mtype);
+		sources = Sources.new(ref Source.Shtml(bsmain, 0, itsrc));
+	}
+	else {
+		# for now, must be supported image type
+		if(!I->supported(hdr.mtype)) {
+			sys->print("Need to implement something: source isn't supported image type\n");
+			return nil;
+		}
+		imsrc := I->ImageSource.new(bsmain, 0, 0);
+		ci := CImage.new(url, nil, 0, 0);
+		simage := ref Source.Simage(bsmain, 0, ci, nil, imsrc);
+		sources = Sources.new(simage);
+		it := ref Item.Iimage(nil, 0, 0, 0, 0, 0, nil, len di.images, ci, 0, 0, "", nil, nil, -1, Abottom, byte 0, byte 0, byte 0);
+		di.images = it :: nil;
+		appenditems(f, l, it);
+		simage.itl = it :: nil;
+	}
+	while ((src := sources.waitsrc()) != nil) {
+		if(dbgev)
+			CU->event("LAYOUT GETSOMETHING", 0);
+		bs := src.bs;
+		freeit := 0;
+		if(bs.err != "") {
+			if(dbg)
+				sys->print("error getting %s: %s\n", bs.req.url.tostring(), bs.err);
+			pick s := src {
+			Srequired =>
+				s.itsrc.reqddata = array [0] of byte;
+				sources.done(src);
+				CU->freebs(bs);
+				src.bs = nil;
+				continue;
+			}
+			freeit = 1;
+		}
+		else {
+			if(bs.hdr != nil && !bs.seenhdr) {
+				(use, error, challenge, newurl) := CU->hdraction(bs, 0, src.redirects);
+				if(challenge != nil) {
+					sys->print("Need to implement authorization credential dialog\n");
+					error = "Need authorization";
+					use = 0;
+				}
+				if(error != "" && dbg)
+					sys->print("subordinate error: %s\n", error);
+				if(newurl != nil) {
+					s := ref *src;
+					freeit = 1;
+					pick ps := src {
+					Shtml or Srequired =>
+						sys->print("unexpected redirect of subord\n");
+					Simage =>
+						newci := CImage.new(newurl, nil, ps.ci.width, ps.ci.height);
+						for(itl := ps.itl; itl != nil ; itl = tl itl) {
+							pick imi := hd itl {
+							Iimage =>
+								imi.ci = newci;
+							}
+						}
+						news := ref Source.Simage(nil, 0, newci, ps.itl, nil);
+						sources.add(news, 0);
+						startimreq(news, auth);
+					}
+				}
+				if(!use)
+					freeit = 1;
+			}
+			if(!freeit) {
+				pick s := src {
+				Srequired or
+				Shtml =>
+					if (tagof src == tagof Source.Srequired) {
+						s.itsrc.reqddata = bs.data;
+						sources.done(src);
+						CU->freebs(bs);
+						src.bs = nil;
+						continue;
+#						src = sources.main;
+#						CU->assert(src != nil);
+					}
+					itl := s.itsrc.getitems();
+					if(di.kidinfo != nil) {
+						if(s.itsrc.kidstk == nil) {
+							layframeset(f, di.kidinfo);
+							G->flush(f.r);
+							freeit = 1;
+						}
+					}
+					else {
+						l.background = di.background;
+						anyanim |= addsubords(sources, di, auth);
+						if(itl != nil) {
+							appenditems(f, l, itl);
+							fixframegeom(f);
+							if(dbgev)
+								CU->event("LAYOUT_DRAWALL", 0);
+							f.dirty(f.totalr);
+							drawall(f);
+						}
+					}
+					if (s.itsrc.reqdurl != nil) {
+						news := ref Source.Srequired(nil, 0, s.itsrc);
+						sources.add(news, 1);
+						rbs := CU->startreq(ref CU->ReqInfo(s.itsrc.reqdurl, CU->HGet, nil, "", ""));
+						news.bs = rbs;
+					} else {
+						if (bs.eof && bs.lim == bs.edata && s.itsrc.toks == nil)
+							freeit = 1;
+					}
+				Simage =>
+					(ret, mim) := s.imsrc.getmim();
+					# mark it done even if error
+					s.ci.complete = ret;
+					if(ret == I->Mimerror) {
+						bs.err = s.imsrc.err;
+						freeit = 1;
+					}
+					else if(ret != I->Mimnone) {
+						if(s.ci.mims == nil) {
+							s.ci.mims = array[1] of { mim };
+							s.ci.width = s.imsrc.width;
+							s.ci.height = s.imsrc.height;
+							if(ret == I->Mimdone && (CU->config).imagelvl <= CU->ImgNoAnim)
+								freeit = 1;
+						}
+						else {
+							n := len s.ci.mims;
+							if(mim != s.ci.mims[n-1]) {
+								newmims := array[n + 1] of ref MaskedImage;
+								newmims[0:] = s.ci.mims;
+								newmims[n] = mim;
+								s.ci.mims = newmims;
+								anyanim = 1;
+							}
+						}
+						if(s.ci.mims[0] == mim)
+							haveimage(f, s.ci, s.itl);
+						if(bs.eof && bs.lim == bs.edata)
+							(CU->imcache).add(s.ci);
+					}
+					if(!freeit && bs.eof && bs.lim == bs.edata)
+						freeit = 1;
+				}
+			}
+		}
+		if(freeit) {
+			if(bs == bsmain)
+				ans = bs.data[0:bs.edata];
+			CU->freebs(bs);
+			src.bs = nil;
+			sources.done(src);
+		}
+	}
+	if(anyanim && (CU->config).imagelvl > CU->ImgNoAnim)
+		spawn animproc(f);
+	if(dbgev)
+		CU->event("LAYOUT_END", 0);
+	return ans;
+}
+
+# return value is 1 if found any existing images needed animation
+addsubords(sources: ref Sources, di: ref Docinfo, auth: string) : int
+{
+	anyanim := 0;
+	if((CU->config).imagelvl == CU->ImgNone)
+		return anyanim;
+	newsims: list of ref Source.Simage = nil;
+	for(il := di.images; il != nil; il = tl il) {
+		it := hd il;
+		pick i := it {
+		Iimage =>
+			if(i.ci.mims == nil) {
+				cachedci := (CU->imcache).look(i.ci);
+				if(cachedci != nil) {
+					i.ci = cachedci;
+					if(i.imwidth == 0)
+						i.imwidth = i.ci.width;
+					if(i.imheight == 0)
+						i.imheight = i.ci.height;
+					anyanim |= (len cachedci.mims > 1);
+				}
+				else {
+				    sloop:
+					for(sl := sources.srcs; sl != nil; sl = tl sl) {
+						pick s := hd sl {
+						Simage =>
+							if(s.ci.match(i.ci)) {
+								s.itl = it :: s.itl;
+								# want all items on list to share same ci;
+								# want most-specific dimension specs
+								iciw := i.ci.width;
+								icih := i.ci.height;
+								i.ci = s.ci;
+								if(s.ci.width == 0 && s.ci.height == 0) {
+									s.ci.width = iciw;
+									s.ci.height = icih;
+								}
+								break sloop;
+							}
+						}
+					}
+					if(sl == nil) {
+						# didn't find existing Source for this image
+						s := ref Source.Simage(nil, 0, i.ci, it:: nil, nil);
+						newsims = s :: newsims;
+						sources.add(s, 0);
+					}
+				}
+			}
+		}
+	}
+	# Start requests for new newsources.
+	# di.images are in last-in-document-first order,
+	# so newsources is in first-in-document-first order (good order to load in).
+	for(sl := newsims; sl != nil; sl = tl sl)
+		startimreq(hd sl, auth);
+	return anyanim;
+}
+
+startimreq(s: ref Source.Simage, auth: string)
+{
+	if(dbgev)
+		CU->event(sys->sprint("LAYOUT STARTREQ %s", s.ci.src.tostring()), 0);
+	bs := CU->startreq(ref CU->ReqInfo(s.ci.src, CU->HGet, nil, auth, ""));
+	s.bs = bs;
+	s.imsrc = I->ImageSource.new(bs, s.ci.width, s.ci.height);
+}
+
+createvscroll(f: ref Frame)
+{
+	breadth := SCRBREADTH;
+	if(f.parent != nil)
+		breadth = SCRFBREADTH;
+	length := f.cr.dy();
+	if(f.flags&FRhscroll)
+		length -= breadth;
+	f.vscr = Control.newscroll(f, 1, length, breadth);
+	f.vscr.r = f.vscr.r.addpt(Point(f.cr.max.x-breadth, f.cr.min.y));
+	f.cr.max.x -= breadth;
+	if(f.cr.dx() <= 2*f.marginw)
+		CU->raisex("EXInternal: frame too small for layout");
+	f.vscr.draw(1);
+}
+
+createhscroll(f: ref Frame)
+{
+	breadth := SCRBREADTH;
+	if(f.parent != nil)
+		breadth = SCRFBREADTH;
+	length := f.cr.dx();
+	x := f.cr.min.x;
+	f.hscr = Control.newscroll(f, 0, length, breadth);
+	f.hscr.r = f.hscr.r.addpt(Point(x,f.cr.max.y-breadth));
+	f.cr.max.y -= breadth;
+	if(f.cr.dy() <= 2*f.marginh)
+		CU->raisex("EXInternal: frame too small for layout");
+	f.hscr.draw(1);
+}
+
+# Call after a change to f.layout or f.viewr.min to fix totalr and viewr
+# (We are to leave viewr.min unchanged, if possible, as
+# user might be scrolling).
+fixframegeom(f: ref Frame)
+{
+	l := f.layout;
+	if(dbg)
+		sys->print("fixframegeom, layout width=%d, height=%d\n", l.width, l.height);
+	crwidth := f.cr.dx();
+	crheight := f.cr.dy();
+	layw := max(l.width, crwidth);
+	layh := max(l.height, crheight);
+	f.totalr.max = Point(layw, layh);
+	crchanged := 0;
+	n := l.height+l.margin-crheight;
+	if(n > 0 && f.vscr == nil && (f.flags&FRvscrollauto)) {
+		createvscroll(f);
+		crchanged = 1;
+		crwidth = f.cr.dx();
+	}
+	if(f.viewr.min.y > n)
+		f.viewr.min.y = max(0, n);
+	n = l.width+l.margin-crwidth;
+	if(!crchanged && n > 0 && f.hscr == nil && (f.flags&FRhscrollauto)) {
+		createhscroll(f);
+		crchanged = 1;
+		crheight = f.cr.dy();
+	}
+	if(crchanged) {
+		relayout(f, l, crwidth, l.just);
+		fixframegeom(f);
+		return;
+	}
+	if(f.viewr.min.x > n)
+		f.viewr.min.x = max(0, n);
+	f.viewr.max.x = min(f.viewr.min.x+crwidth, layw);
+	f.viewr.max.y = min(f.viewr.min.y+crheight, layh);
+	if(f.vscr != nil)
+		f.vscr.scrollset(f.viewr.min.y, f.viewr.max.y, f.totalr.max.y, 0, 1);
+	if(f.hscr != nil)
+		f.hscr.scrollset(f.viewr.min.x, f.viewr.max.x, f.totalr.max.x, f.viewr.dx()/5, 1);
+}
+
+# The items its within f are Iimage items,
+# and its image, ci, now has at least a ci.mims[0], which may be partially
+# or fully filled.
+haveimage(f: ref Frame, ci: ref CImage, itl: list of ref Item)
+{
+	if(dbgev)
+		CU->event("HAVEIMAGE", 0);
+	if(dbg)
+		sys->print("\nHAVEIMAGE src=%s w=%d h=%d\n", ci.src.tostring(), ci.width, ci.height);
+	# make all base images repl'd - makes handling backgrounds much easier
+	im := ci.mims[0].im;
+	im.repl = 1;
+	im.clipr = Rect((-16rFFFFFFF, -16r3FFFFFFF), (16r3FFFFFFF, 16r3FFFFFFF));
+	dorelayout := 0;
+	for( ; itl != nil; itl = tl itl) {
+		it := hd itl;
+		pick i := it {
+		Iimage =>
+			if (!(it.state & B->IFbkg)) {
+				# If i.imwidth and i.imheight are not both 0, the HTML specified the dimens.
+				# If one of them is 0, the other is to be scaled by the same factor;
+				# we have to relay the line in that case too.
+				if(i.imwidth == 0 || i.imheight == 0) {
+					i.imwidth = ci.width;
+					i.imheight = ci.height;
+					setimagedims(i);
+					loc := f.find(zp, it);
+					# sometimes the image was added to doc image list, but
+					# never made it to layout (e.g., because html bug prevented
+					# a table from being added).
+					# also, script-created images won't have items
+					if(loc != nil) {
+						f.layout.flags |= Lchanged;
+						markchanges(loc);
+						dorelayout = 1;
+						# Floats are assumed to be premeasured, so if there
+						# are any floats in the loc list, remeasure them
+						for(k := loc.n-1; k > 0; k--) {
+							if(loc.le[k].kind == LEitem) {
+								locit := loc.le[k].item;
+								pick fit := locit {
+								Ifloat =>
+									pick xi := fit.item {
+									Iimage =>
+										fit.height = fit.item.height;
+									Itable =>
+										checktabsize(f, xi, TABLEFLOATTARGET);
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			if(dbg > 1) {
+				sys->print("\nhaveimage item: ");
+				it.print();
+			}
+		}
+	}
+	if(dorelayout) {
+		relayout(f, f.layout, f.layout.targetwidth, f.layout.just);
+		fixframegeom(f);
+	}
+	f.dirty(f.totalr);
+	drawall(f);
+	if(dbgev)
+		CU->event("HAVEIMAGE_END", 0);
+}
+# For first layout of subelements, such as table cells.
+# After this, content items will be dispersed throughout resulting lay.
+# Return index into f.sublays.
+# (This roundabout way of storing sublayouts avoids pointers to Lay
+# in Build, so that all of the layout-related stuff can be in Layout
+# where it belongs.)
+sublayout(f: ref Frame, targetwidth: int, just: byte, bg: Background, content: ref Item) : int
+{
+	if(dbg)
+		sys->print("sublayout, targetwidth=%d\n", targetwidth);
+	l := Lay.new(targetwidth, just, 0, bg);
+	if(f.sublayid >= len f.sublays) {
+		newsublays := array[len f.sublays + 30] of ref Lay;
+		newsublays[0:] = f.sublays;
+		f.sublays = newsublays;
+	}
+	id := f.sublayid;
+	f.sublays[id] = l;
+	f.sublayid++;
+	appenditems(f, l, content);
+	l.flags &= ~Lchanged;
+	if(dbg)
+		sys->print("after sublayout, width=%d\n", l.width);
+	return id;
+}
+
+# Relayout of lay, given a new target width or if something changed inside
+# or if the global justification for the layout changed.
+# Floats are hard: for now, just relay everything with floats temporarily
+# moved way down, if there are any floats.
+relayout(f: ref Frame, lay: ref Lay, targetwidth: int, just: byte)
+{
+	if(dbg)
+		sys->print("relayout, targetwidth=%d, old target=%d, changed=%d\n",
+			targetwidth, lay.targetwidth, (lay.flags&Lchanged) != byte 0);
+	changeall := (lay.targetwidth != targetwidth || lay.just != just);
+	if(!changeall && !int(lay.flags&Lchanged))
+		return;
+	if(lay.floats != nil) {
+		# move the current y positions of floats to a big value,
+		# so they don't contribute to floatw until after they've
+		# been encountered in current fixgeom
+		for(flist := lay.floats; flist != nil; flist = tl flist) {
+			ff := hd flist;
+			ff.y = 16r6fffffff;
+		}
+		changeall = 1;
+	}
+	lay.targetwidth = targetwidth;
+	lay.just = just;
+	lay.height = 0;
+	lay.width = 0;
+	if(changeall)
+		changelines(lay.start.next, lay.end);
+	fixgeom(f, lay, lay.start.next);
+	lay.flags &= ~Lchanged;
+	if(dbg)
+		sys->print("after relayout, width=%d\n", lay.width);
+}
+
+# Measure and append the items to the end of layout lay,
+# and fix the geometry.
+appenditems(f: ref Frame, lay: ref Lay, items: ref Item)
+{
+	measure(f, items);
+	if(dbg)
+		items.printlist("appenditems, after measure");
+	it := items;
+	if(it == nil)
+		return;
+	lprev := lay.end.prev;
+	l : ref Line;
+	lit := lastitem(lprev.items);
+	if(lit == nil || (it.state&IFbrk)) {
+		# start a new line after existing last line
+		l = Line.new();
+		appendline(lprev, l);
+		l.items = it;
+	}
+	else {
+		# start appending items to existing last line
+		l = lprev;
+		lit.next = it;
+	}
+	l.flags |= Lchanged;
+	while(it != nil) {
+		nexti := it.next;
+		if(nexti == nil || (nexti.state&IFbrk)) {
+			it.next = nil;
+			fixgeom(f, lay, l);
+			if(nexti == nil)
+				break;
+			# now there may be multiple lines containing the
+			# items from l, but the one after the last is lay.end
+			l = Line.new();
+			appendline(lay.end.prev, l);
+			l.flags |= Lchanged;
+			it = nexti;
+			l.items = it;
+		}
+		else
+			it = nexti;
+	}
+}
+
+# Fix up the geometry of line l and successors.
+# Assume geometry of previous line is correct.
+fixgeom(f: ref Frame, lay: ref Lay, l: ref Line)
+{
+	while(l != nil) {
+		fixlinegeom(f, lay, l);
+		mergetext(l);
+		l = l.next;
+	}
+	lay.height = max(lay.height, lay.end.pos.y);
+}
+
+mergetext(l: ref Line)
+{
+	lastit : ref Item;
+	for (it := l.items; it != nil; it = it.next) {
+		pick i := it {
+		Itext =>
+			if (lastit == nil)
+				break; #pick
+			pick pi := lastit {
+			Itext =>
+				# ignore item state flags as fixlinegeom() 
+				# will have taken account of them.
+				if (pi.anchorid == i.anchorid &&
+				pi.fnt == i.fnt && pi.fg == i.fg && pi.voff == i.voff && pi.ul == i.ul) {
+					# compatible - merge
+					pi.s += i.s;
+					pi.width += i.width;
+					pi.next = i.next;
+					continue;
+				}
+			}
+		}
+		lastit = it;
+	}
+}
+
+# Fix geom for one line.
+# This may change the overall lay.width, if there is no way
+# to fit the line into the target width. 
+fixlinegeom(f: ref Frame, lay: ref Lay, l: ref Line)
+{
+	lprev := l.prev;
+	y := lprev.pos.y + lprev.height;
+	it := l.items;
+	state := it.state;
+	if(dbg > 1) {
+		sys->print("\nfixlinegeom start, y=prev.y+prev.height=%d+%d=%d, changed=%d\n",
+				l.prev.pos.y, lprev.height, y, int (l.flags&Lchanged));
+		if(dbg > 2)
+			it.printlist("items");
+		else {
+			sys->print("first item: ");
+			it.print();
+		}
+	}
+	if(state&IFbrk) {
+		y = pastbrk(lay, y, state);
+		if(dbg > 1 && y != lprev.pos.y + lprev.height)
+			sys->print("after pastbrk, line y is now %d\n", y);
+	}
+	l.pos.y = y;
+	lineh := max(l.height, linespace);
+	lfloatw := floatw(y, y+lineh, lay.floats, Aleft);
+	rfloatw := floatw(y, y+lineh, lay.floats, Aright);
+	if((l.flags&Lchanged) == byte 0) {
+		# possibly adjust lay.width
+		n := (lay.width-rfloatw)-(l.pos.x-lay.margin+l.width);
+		if(n < 0)
+			lay.width += -n;
+		return;
+	}
+	hang := (state&IFhangmask)*TABPIX/10;
+	linehang := hang;
+	hangtogo := hang;
+	indent := ((state&IFindentmask)>>IFindentshift)*TABPIX;
+	just := (state&(IFcjust|IFrjust));
+	if(just == 0 && lay.just != Aleft) {
+		if(lay.just == byte Acenter)
+			just = IFcjust;
+		else if(lay.just == Aright)
+			just = IFrjust;
+	}
+	right := lay.targetwidth - lay.margin;
+	lwid := right - (lfloatw+rfloatw+indent+lay.margin);
+	if(lwid < 0) {
+		if (right - lwid > lay.width)
+			lay.width = right - lwid;
+		right += -lwid;
+		lwid = 0;
+	}
+	lwid += hang;
+	if(dbg > 1) {
+		sys->print("fixlinegeom, now y=%d, lfloatw=%d, rfloatw=%d, indent=%d, hang=%d, lwid=%d\n",
+				y, lfloatw, rfloatw, indent, hang, lwid);
+	}
+	w := 0;
+	lineh = 0;
+	linea := 0;
+	lastit: ref Item = nil;
+	nextfloats: list of ref Item.Ifloat = nil;
+	anystuff := 0;
+	eol := 0;
+	while(it != nil && !eol) {
+		if(dbg > 2) {
+			sys->print("fixlinegeom loop head, w=%d, loop item:\n", w);
+			it.print();
+		}
+		state = it.state;
+		wrapping := int (state&IFwrap);
+		if(anystuff && (state&IFbrk))
+			break;
+		checkw := 1;
+		if(hang && !(state&IFhangmask)) {
+			lwid -= hang;
+			hang = 0;
+			if(hangtogo > 0) {
+				# insert a null spacer item
+				spaceit := Item.newspacer(ISPgeneral, 0);
+				spaceit.width = hangtogo;
+				if(lastit != nil) {
+					spaceit.state = lastit.state & ~(IFbrk|IFbrksp|IFnobrk|IFcleft|IFcright);
+					lastit.next = spaceit;
+				}
+				else
+					lastit = spaceit;
+				spaceit.next = it;
+			}
+		}
+		pick i := it {
+		Ifloat =>
+			if(anystuff) {
+				# float will go after this line
+				nextfloats = i :: nextfloats;
+			}
+			else {
+				# add float beside current line, adjust widths
+				fixfloatxy(lay, y, i);
+				# TODO: only do following if y and/or height changed
+				changelines(l.next, lay.end);
+				newlfloatw := floatw(y, y+lineh, lay.floats, Aleft);
+				newrfloatw := floatw(y, y+lineh, lay.floats, Aright);
+				lwid -= (newlfloatw-lfloatw) + (newrfloatw-rfloatw);
+				if (lwid < 0) {
+					right += -lwid;
+					lwid = 0;
+				}
+				lfloatw = newlfloatw;
+				rfloatw = newrfloatw;
+			}
+			checkw = 0;
+		Itable =>
+			# When just doing layout for cell dimensions, don't
+			# want a "100%" spec to make the table really wide
+			kindspec := 0;
+			if(lay.targetwidth == TABLEMAXTARGET && i.table.width.kind() == Dpercent) {
+				kindspec = i.table.width.kindspec;
+				i.table.width = Dimen.make(Dnone, 0);
+			}
+			checktabsize(f, i, lwid-w);
+			if(kindspec != 0)
+				i.table.width.kindspec = kindspec;
+		Irule =>
+			avail := lwid-w;
+			# When just doing layout for cell dimensions, don't
+			# want a "100%" spec to make the rule really wide
+			if(lay.targetwidth == TABLEMAXTARGET)
+				avail = min(10, avail);
+			i.width = widthfromspec(i.wspec, avail);
+		Iformfield =>
+			checkffsize(f, i, i.formfield);
+		}
+		if(checkw) {
+			iw := it.width;
+			if(wrapping && w + iw > lwid) {
+				# it doesn't fit; see if it can be broken
+				takeit: int;
+				noneok := (anystuff || lfloatw != 0 || rfloatw != 0) && !(state&IFnobrk);
+				(takeit, iw) = trybreak(it, lwid-w, iw, noneok);
+				eol = 1;
+				if(!takeit) {
+					if(lastit == nil) {
+						# Nothing added because one of the float widths
+						# is nonzero, and not enough room for anything else.
+						# Move y down until there's more room and try again.
+						CU->assert(lfloatw != 0 || rfloatw != 0);
+						oldy := y;
+						y = pastbrk(lay, y, IFcleft|IFcright);
+						if(dbg > 1)
+							sys->print("moved y past %d, now y=%d\n", oldy, y);
+						CU->assert(y > oldy);	# else infinite recurse
+						# Do the move down by artificially increasing the
+						# height of the previous line
+						lprev.height += y-oldy;
+						fixlinegeom(f, lay, l);
+						return;
+					} else
+						break;
+				}
+			}
+			w += iw;
+			if(hang)
+				hangtogo -= w;
+			(lineh, linea) = lgeom(lineh, linea, it);
+			if(!anystuff) {
+				anystuff = 1;
+				# don't count an ordinary space as 'stuff' if wrapping
+				pick t := it {
+				Itext =>
+					if(wrapping && t.s == " ")
+						anystuff = 0;
+				}
+			}
+		}
+		lastit = it;
+		it = it.next;
+		if(it == nil && !eol) {
+			# perhaps next lines items can now fit on this line
+			nextl := l.next;
+			nit := nextl.items;
+			if(nextl != lay.end && !(nit.state&IFbrk)) {
+				lastit.next = nit;
+				# remove nextl
+				l.next = nextl.next;
+				l.next.prev = l;
+				it = nit;
+			}
+		}
+	}
+	# line is complete, next line will start with it (or it is nil)
+	rest := it;
+	if(lastit == nil)
+		CU->raisex("EXInternal: no items on line");
+	lastit.next = nil;
+
+	l.width = w;
+	x := lfloatw + lay.margin + indent - linehang;
+	# shift line if it begins with a space or a rule
+	pick pi := l.items {
+	Itext =>
+		if(pi.s != nil && pi.s[0] == ' ')
+			x -= fonts[pi.fnt].spw;
+	Irule =>
+		# note: build ensures that rules appear on lines
+		# by themselves
+		if(pi.align == Acenter)
+			just = IFcjust;
+		else if(pi.align == Aright)
+			just = IFrjust;
+	Ifloat =>
+		if(pi.next != nil) {
+			pick qi := pi.next {
+			Itext =>
+				if(qi.s != nil && qi.s[0] == ' ')
+					x -= fonts[qi.fnt].spw;
+			}
+		}
+	}
+	xright := x+w;
+	if (xright + rfloatw > lay.width)
+		lay.width = xright+rfloatw;
+	n := lay.targetwidth-(lay.margin+rfloatw+xright);
+	if(n > 0 && just) {
+		if(just&IFcjust)
+			x += n/2;
+		else
+			x += n;
+	}
+	if(dbg > 1) {
+		sys->print("line geometry fixed, (x,y)=(%d,%d), w=%d, h=%d, a=%d, lfloatw=%d, rfloatw=%d, lay.width=%d\n",
+			x, l.pos.y, w, lineh, linea, lfloatw, rfloatw, lay.width);
+		if(dbg > 2)
+			l.items.printlist("final line items");
+	}
+	l.pos.x = x;
+	l.height = lineh;
+	l.ascent = linea;
+	l.flags &= ~Lchanged;
+
+	if(nextfloats != nil)
+		fixfloatsafter(lay, l, nextfloats);
+
+	if(rest != nil) {
+		nextl := l.next;
+		if(nextl == lay.end || (nextl.items.state&IFbrk)) {
+			nextl = Line.new();
+			appendline(l, nextl);
+		}
+		li := lastitem(rest);
+		li.next = nextl.items;
+		nextl.items = rest;
+		nextl.flags |= Lchanged;
+	}
+}
+
+# Return y coord after y due to a break.
+pastbrk(lay: ref Lay, y, state: int) : int
+{
+	nextralines := 0;
+	if(state&IFbrksp)
+		nextralines = 1;
+	ynext := y;
+	if(state&IFcleft)
+		ynext = floatclry(lay.floats, Aleft, ynext);
+	if(state&IFcright)
+		ynext = max(ynext, floatclry(lay.floats, Aright, ynext));
+	ynext += nextralines*linespace;
+	return ynext;
+}
+
+# Add line l after lprev (and before lprev's current successor)
+appendline(lprev, l: ref Line)
+{
+	l.next = lprev.next;
+	l.prev = lprev;
+	l.next.prev = l;
+	lprev.next = l;
+}
+
+# Mark lines l up to but not including lend as changed
+changelines(l, lend: ref Line)
+{
+	for( ; l != lend; l = l.next)
+		l.flags |= Lchanged;
+}
+
+# Return a ref Font for font number num = (style*NumSize + size)
+getfont(num: int) : ref Font
+{
+	f := fonts[num].f;
+	if(f == nil) {
+		f = Font.open(display, fonts[num].name);
+		if(f == nil) {
+			if(num == DefFnt)
+				CU->raisex(sys->sprint("exLayout: can't open default font %s: %r", fonts[num].name));
+			else {
+				if(int (CU->config).dbg['w'])
+					sys->print("warning: substituting default for font %s\n",
+						fonts[num].name);
+				f = fonts[DefFnt].f;
+			}
+		}
+		fonts[num].f = f;
+		fonts[num].spw = f.width(" ");
+	}
+	return f;
+}
+
+# Set the width, height and ascent fields of all items, getting any necessary fonts.
+# Some widths and heights depend on the available width on the line, and may be
+# wrong until checked during fixlinegeom.
+# Don't do tables here at all (except floating tables).
+# Configure Controls for form fields.
+measure(fr: ref Frame, items: ref Item)
+{
+	for(it := items; it != nil; it = it.next) {
+		pick t := it {
+		Itext =>
+			f := getfont(t.fnt);
+			it.width = f.width(t.s);
+			a := f.ascent;
+			h := f.height;
+			if(t.voff != byte Voffbias) {
+				a -= (int t.voff) - Voffbias;
+				if(a > h)
+					h = a;
+			}
+			it.height = h;
+			it.ascent = a;
+		Irule =>
+			it.height =  t.size + 2*RULESP;
+			it.ascent = t.size + RULESP;
+		Iimage =>
+			setimagedims(t);
+		Iformfield =>
+			c := Control.newff(fr, t.formfield);
+			if(c != nil) {
+				t.formfield.ctlid = fr.addcontrol(c);
+				it.width = c.r.dx();
+				it.height = c.r.dy();
+				it.ascent = it.height;
+				pick pc := c {
+				Centry =>
+					it.ascent = lineascent + ENTVMARGIN;
+				Cselect =>
+					it.ascent = lineascent + SELMARGIN;
+				Cbutton =>
+					if(pc.dorelief)
+						it.ascent -= BUTMARGIN;
+				}
+			}
+		Ifloat =>
+			# Leave w at zero, so it doesn't contribute to line width in normal way
+			# (Can find its width in t.item.width).
+			pick i := t.item {
+			Iimage =>
+				setimagedims(i);
+				it.height = t.item.height;
+			Itable =>
+				checktabsize(fr, i, TABLEFLOATTARGET);
+			* =>
+				CU->assert(0);
+			}
+			it.ascent = it.height;
+		Ispacer =>
+			case t.spkind {
+			ISPvline =>
+				f := getfont(t.fnt);
+				it.height = f.height;
+				it.ascent = f.ascent;
+			ISPhspace =>
+				getfont(t.fnt);
+				it.width = fonts[t.fnt].spw;
+			}
+		}
+	}
+}
+
+# Set the dimensions of an image item
+setimagedims(i: ref Item.Iimage)
+{
+	i.width = i.imwidth + 2*(int i.hspace + int i.border);
+	i.height = i.imheight + 2*(int i.vspace + int i.border);
+	i.ascent = i.height - (int i.vspace + int i.border);
+	if((CU->config).imagelvl == CU->ImgNone && i.altrep != "") {
+		f := fonts[DefFnt].f;
+		i.width = max(i.width, f.width(i.altrep));
+		i.height = max(i.height, f.height);
+		i.ascent = f.ascent;
+	}
+}
+
+# Line geometry function:
+# Given current line height (H) and ascent (distance from top to baseline) (A),
+# and an item, see if that item changes height and ascent.
+# Return (H', A'), the updated line height and ascent.
+lgeom(H, A: int, it: ref Item) : (int, int)
+{
+	h := it.height;
+	a := it.ascent;
+	atype := Abaseline;
+	pick i := it {
+	Iimage =>
+		atype = i.align;
+	Itable =>
+		atype = Atop;
+	Ifloat =>
+		return (H, A);
+	}
+	d := h-a;
+	Hnew := H;
+	Anew := A;
+	case int atype {
+	int Abaseline or int Abottom =>
+		if(a > A) {
+			Anew = a;
+			Hnew += (Anew - A);
+		}
+		if(d > Hnew - Anew)
+			Hnew = Anew + d;
+	int Atop =>
+		# OK to ignore what comes after in the line
+		if(h > H)
+			Hnew = h;
+	int Amiddle or int Acenter =>
+		# supposed to align middle with baseline
+		hhalf := h/2;
+		if(hhalf > A)
+			Anew = hhalf;
+		if(hhalf > H-Anew)
+			Hnew = Anew + hhalf;
+	}
+	return (Hnew, Anew);
+}
+
+# Try breaking item bit to make it fit in availw.
+# If that is possible, change bit to be the part that fits
+# and insert the rest between bit and bit.next.
+# iw is the current width of bit.
+# If noneok is 0, break off the minimum size word
+# even if it exceeds availw.
+# Return (1 if supposed to take bit, iw' = new width of bit)
+trybreak(bit: ref Item, availw, iw, noneok: int) : (int, int)
+{
+	if(iw <= 0)
+		return (1, iw);
+	if(availw < 0) {
+		if(noneok)
+			return (0, iw);
+		else
+			availw = 0;
+	}
+	pick t := bit {
+	Itext =>
+		if(len t.s < 2)
+			return (!noneok, iw);
+		(s1, w1, s2, w2) := breakstring(t.s, iw, fonts[t.fnt].f, availw, noneok);
+		if(w1 == 0)
+			return (0, iw);
+		itn := Item.newtext(s2, t.fnt, t.fg, int t.voff, t.ul);
+		itn.width = w2;
+		itn.height = t.height;
+		itn.ascent = t.ascent;
+		itn.anchorid = t.anchorid;
+		itn.state = t.state & ~(IFbrk|IFbrksp|IFnobrk|IFcleft|IFcright);
+		itn.next = t.next;
+		t.next = itn;
+		t.s = s1;
+		t.width = w1;
+		return (1, w1);
+	}
+	return (!noneok, iw);
+}
+
+# s has width sw when drawn in fnt.
+# Break s into s1 and s2 so that s1 fits in availw.
+# If noneok is true, it is ok for s1 to be nil, otherwise might
+# have to return an s1 that overflows availw somewhat.
+# Return (s1, w1, s2, w2) where w1 and w2 are widths of s1 and s2.
+# Assume caller has already checked that sw > availw.
+breakstring(s: string, sw: int, fnt: ref Font, availw, noneok: int) : (string, int, string, int)
+{
+	slen := len s;
+	if(slen < 2) {
+		if(noneok)
+			return (nil, 0, s, sw);
+		else
+			return (s, sw, nil, 0);
+	}
+
+	# Use linear interpolation to guess break point.
+	# We know avail < iw by conditions of trybreak call.
+	i := slen*availw / sw - 1;
+	if(i < 0)
+		i = 0;
+	i = breakpoint(s, i, -1);
+	(ss, ww) := tryw(fnt, s, i);
+	if(ww > availw) {
+		while(ww > availw) {
+			i = breakpoint(s, i-1, -1);
+			if(i <= 0)
+				break;
+			(ss, ww) = tryw(fnt, s, i);
+		}
+	}
+	else {
+		oldi := i;
+		oldss := ss;
+		oldww := ww;
+		while(ww < availw) {
+			oldi = i;
+			oldss = ss;
+			oldww = ww;
+			i = breakpoint(s, i+1, 1);
+			if(i >= slen)
+				break;
+			(ss, ww) = tryw(fnt, s, i);
+		}
+		i = oldi;
+		ss = oldss;
+		ww = oldww;
+	}
+	if(i <= 0 || i >= slen) {
+		if(noneok)
+			return (nil, 0, s, sw);
+		i = breakpoint(s, 1, 1);
+		(ss,ww) = tryw(fnt, s, i);
+	}
+	return (ss, ww, s[i:slen], sw-ww);
+}
+
+# If can break between s[i-1] and s[i], return i.
+# Else move i in direction incr until this is true.
+# (Might end up returning 0 or len s).
+breakpoint(s: string, i, incr: int) : int
+{
+	slen := len s;
+	ans := 0;
+	while(i > 0 && i < slen) {
+		ci := s[i];
+		di := s[i-1];
+		
+		# ASCII rules
+		if ((ci < 16rA0 && !int wordchar[ci]) || (di < 16rA0 && !int wordchar[di])) {
+			ans = i;
+			break;
+		}
+
+		# Treat all ideographs as breakable.
+		# The following range includes unassigned unicode code points.
+		# All assigned code points in the range are class ID (ideograph) as defined
+		# by the Unicode consortium's LineBreak data.
+		# There are many other class ID code points outside of this range.
+		# For details on how to do unicode line breaking properly see:
+		# Unicode Standard Annex #14 (http://www.unicode.org/unicode/reports/tr14/)
+
+		if ((ci >= 16r30E && ci <= 16r9FA5) || (di >= 16r30E && di <= 16r9FA5)) {
+			ans = i;
+			break;
+		}
+
+		# consider all other characters as unbreakable
+		i += incr;
+	}
+	if(i == slen)
+		ans = slen;
+	return ans;
+}
+
+# Return (s[0:i], width of that slice in font fnt)
+tryw(fnt: ref Font, s: string, i: int) : (string, int)
+{
+	if(i == 0)
+		return ("", 0);
+	ss := s[0:i];
+	return (ss, fnt.width(ss));
+}
+
+# Return max width of a float that overlaps [ymin, ymax) on given side.
+# Floats are in reverse order of addition, so each float's y is <= that of
+# preceding floats in list.  Floats from both sides are intermixed.
+floatw(ymin, ymax: int, flist: list of ref Item.Ifloat, side: byte) : int
+{
+	ans := 0;
+	for( ; flist != nil; flist = tl flist) {
+		fl := hd flist;
+		if(fl.side != side)
+			continue;
+		fymin := fl.y;
+		fymax := fymin + fl.item.height;
+		if((fymin <= ymin && ymin < fymax) ||
+		   (ymin <= fymin && fymin < ymax)) {
+			w := fl.x;
+			if(side == Aleft)
+				w += fl.item.width;
+			if(ans < w)
+				ans = w;
+		}
+	}
+	return ans;
+}
+
+# Float f is to be at vertical position >= y.
+# Fix its (x,y) pos and add it to lay.floats, if not already there.
+fixfloatxy(lay: ref Lay, y: int, f: ref Item.Ifloat)
+{
+	height := f.item.height;
+	width := f.item.width;
+	f.y = y;
+	flist := lay.floats;
+	if(f.infloats != byte 0) {
+		# only take previous floats into account for width
+		while(flist != nil) {
+			x := hd flist;
+			flist = tl flist;
+			if(x == f)
+				break;
+		}
+	}
+	f.x = floatw(y, y+height, flist, f.side);
+	endx := f.x + width + lay.margin;
+	if (endx > lay.width)
+		lay.width = endx;
+	if (f.side == Aright)
+		f.x += width;
+	endy := f.y + height + lay.margin;
+	if (endy > lay.height)
+		lay.height = endy;
+	if(f.infloats == byte 0) {
+		lay.floats = f :: lay.floats;
+		f.infloats = byte 1;
+	}
+}
+
+# Floats in flist are to go after line l.
+fixfloatsafter(lay: ref Lay, l: ref Line, flist: list of ref Item.Ifloat)
+{
+	change := 0;
+	y := l.pos.y + l.height;
+	for(itl := Item.revlist(flist); itl != nil; itl = tl itl) {
+		pick fl := hd itl {
+		Ifloat =>
+			oldy := fl.y;
+			fixfloatxy(lay, y, fl);
+			if(fl.y != oldy)
+				change = 1;
+			y += fl.item.height;
+		}
+	}
+#	if(change)
+# TODO only change if y and/or height changed
+		changelines(l.next, lay.end);
+}
+
+# If there's a float on given side that starts on or before y and
+# ends after y, return ending y of that float, else return original y.
+# Assume float list is bottom up.
+floatclry(flist: list of ref Item.Ifloat, side: byte, y: int) : int
+{
+	ymax := y;
+	for( ; flist != nil; flist = tl flist) {
+		fl := hd flist;
+		if(fl.side == side) {
+			if(fl.y <= y) {
+				flymax := fl.y + fl.item.height;
+				if (fl.item.height == 0)
+					# assume it will have some height later
+					flymax++;
+				if(flymax > ymax)
+					ymax = flymax;
+			}
+		}
+	}
+	return ymax;
+}
+
+# Do preliminaries to laying out table tab in target width linewidth,
+# setting total height and width.
+sizetable(f: ref Frame, tab: ref Table, availwidth: int)
+{
+	if(dbgtab)
+		sys->print("sizetable %d, availwidth=%d, nrow=%d, ncol=%d, changed=%x, tab.availw=%d\n",
+			tab.tableid, availwidth, tab.nrow, tab.ncol, int (tab.flags&Lchanged), tab.availw);
+	if(tab.ncol == 0 || tab.nrow == 0)
+		return;
+	if(tab.availw == availwidth && (tab.flags&Lchanged) == byte 0)
+		return;
+	(hsp, vsp, pad, bd, cbd, hsep, vsep) := tableparams(tab);
+	totw := widthfromspec(tab.width, availwidth);
+	# reduce totw by spacing, padding, and rule widths
+	# to leave amount left for contents
+	totw -= (tab.ncol-1)*hsep+ 2*(hsp+bd+pad+cbd);
+	if(totw <= 0)
+		totw = 1;
+	if(dbgtab)
+		sys->print("\nsizetable %d, totw=%d, hsp=%d, vsp=%d, pad=%d, bd=%d, cbd=%d, hsep=%d, vsep=%d\n",
+			tab.tableid, totw, hsp, vsp, pad, bd, cbd, hsep, vsep);
+	for(cl := tab.cells; cl != nil; cl = tl cl) {
+		c := hd cl;
+		clay : ref Lay = nil;
+		if(c.layid >= 0)
+			clay = f.sublays[c.layid];
+		if(clay == nil || (clay.flags&Lchanged) != byte 0) {
+			c.minw = -1;
+			tw := TABLEMAXTARGET;
+			if(c.wspec.kind() != Dnone)
+				tw = widthfromspec(c.wspec, totw);
+
+			# When finding max widths, want to lay out using Aleft alignment,
+			# because we don't yet know final width for proper justification.
+			# If the max widths are accepted, we'll redo those needing other justification.
+			if(clay == nil) {
+				if(dbg)
+					sys->print("Initial layout for cell %d.%d\n", tab.tableid, c.cellid);
+				c.layid = sublayout(f, tw, Aleft, c.background, c.content);
+				clay = f.sublays[c.layid];
+				c.content = nil;
+			}
+			else {
+				if(dbg)
+					sys->print("Relayout (for max) for cell %d.%d\n", tab.tableid, c.cellid);
+				relayout(f, clay, tw, Aleft);
+			}
+			clay.flags |= Lchanged;	# for min test, below
+			c.maxw = clay.width;
+			if(dbgtab)
+				sys->print("sizetable %d for cell %d max layout done, targw=%d, c.maxw=%d\n",
+						tab.tableid, c.cellid, tw, c.maxw);
+			if(c.wspec.kind() == Dpixels) {
+				# Other browsers don't make the following adjustment for
+				# percentage and relative widths
+				if(c.maxw <= tw)
+					c.maxw = tw;
+				if(dbgtab)
+					sys->print("after spec adjustment, c.maxw=%d\n", c.maxw);
+			}
+		}
+	}
+
+	# calc max column widths
+	colmaxw := array[tab.ncol] of { * => 0};
+	maxw := widthcalc(tab, colmaxw, hsep, 1);
+
+	if(dbgtab)
+		sys->print("sizetable %d maxw=%d, totw=%d\n", tab.tableid, maxw, totw);
+	ci: int;
+	if(maxw <= totw) {
+		# trial layouts are fine,
+		# but if table width was specified, add more space
+		d := 0;
+		adjust := (totw > maxw && tab.width.kind() != Dnone);
+		for(ci = 0; ci < tab.ncol; ci++) {
+			if (adjust) {
+				delta := (totw-maxw);
+				d = delta / (tab.ncol - ci);
+				if (d <= 0) {
+					d = delta;
+					adjust = 0;
+				}
+				maxw += d;
+			}
+			tab.cols[ci].width = colmaxw[ci] + d;
+		}
+	}
+	else {
+		# calc min column widths and  apportion out
+		# differences
+		if(dbgtab)
+			sys->print("sizetable %d, availwidth %d, need min widths too\n", tab.tableid, availwidth);
+		for(cl = tab.cells; cl != nil; cl = tl cl) {
+			c := hd cl;
+			clay := f.sublays[c.layid];
+			if(c.minw == -1 || (clay.flags&Lchanged) != byte 0) {
+				if(dbg)
+					sys->print("Relayout (for min) for cell %d.%d\n", tab.tableid, c.cellid);
+				relayout(f, clay, 1, Aleft);
+				c.minw = clay.width;
+				if(dbgtab)
+					sys->print("sizetable %d for cell %d min layout done, c.min=%d\n",
+						tab.tableid, c.cellid, clay.width);
+			}
+		}
+		colminw := array[tab.ncol] of { * => 0};
+		minw := widthcalc(tab, colminw, hsep, 0);
+		w := totw - minw;
+		d := maxw - minw;
+		if(dbgtab)
+			sys->print("sizetable %d minw=%d, w=%d, d=%d\n", tab.tableid, minw, w, d);
+		for(ci = 0; ci < tab.ncol; ci++) {
+			wd : int;
+			if(w < 0 || d < 0)
+				wd = colminw[ci];
+			else
+				wd = colminw[ci] + (colmaxw[ci] - colminw[ci])*w/d;
+			if(dbgtab)
+				sys->print("sizetable %d col[%d].width = %d\n", tab.tableid, ci, wd);
+			tab.cols[ci].width = wd;
+		}
+
+		if(dbgtab)
+			sys->print("sizetable %d, availwidth %d, doing final layouts\n", tab.tableid, availwidth);
+	}
+
+	# now have col widths; set actual cell dimensions
+	# and relayout (note: relayout will do no work if the target width
+	# and just haven't changed from last layout)
+	for(cl = tab.cells; cl != nil; cl = tl cl) {
+		c := hd cl;
+		clay := f.sublays[c.layid];
+		wd := cellwidth(tab, c, hsep);
+		if(dbgtab)
+			sys->print("sizetable %d for cell %d, clay.width=%d, cellwidth=%d\n",
+					tab.tableid, c.cellid, clay.width, wd);
+		if(dbg)
+			sys->print("Relayout (final) for cell %d.%d\n", tab.tableid, c.cellid);
+		relayout(f, clay, wd, c.align.halign);
+		if(dbgtab)
+			sys->print("sizetable %d for cell %d, final width %d, got width %d, height %d\n",
+					tab.tableid, c.cellid, wd, clay.width, clay.height);
+	}
+
+	# set row heights and ascents
+	# first pass: ignore cells with rowspan > 1
+	for(ri := 0; ri < tab.nrow; ri++) {
+		row := tab.rows[ri];
+		h := 0;
+		a := 0;
+		n : int;
+		for(rcl := row.cells; rcl != nil; rcl = tl rcl) {
+			c := hd rcl;
+			if(c.rowspan > 1 || c.layid < 0)
+				continue;
+			al := c.align.valign;
+			if(al == Anone)
+				al = tab.rows[c.row].align.valign;
+			clay := f.sublays[c.layid];
+			if(al == Abaseline) {
+				n = c.ascent;
+				if(n > a) {
+					h += (n - a);
+					a = n;
+				}
+				n = clay.height - c.ascent;
+				if(n > h-a)
+					h = a + n;
+			}
+			else {
+				n = clay.height;
+				if(n > h)
+					h = n;
+			}
+		}
+		row.height = h;
+		row.ascent = a;
+	}
+	# second pass: take care of rowspan > 1
+	# (this algorithm isn't quite right -- it might add more space
+	# than is needed in the presence of multiple overlapping rowspans)
+	for(cl = tab.cells; cl != nil; cl = tl cl) {
+		c := hd cl;
+		if(c.rowspan > 1) {
+			spanht := 0;
+			for(i := 0; i < c.rowspan && c.row+i < tab.nrow; i++)
+				spanht += tab.rows[c.row+i].height;
+			if(c.layid < 0)
+				continue;
+			clay := f.sublays[c.layid];
+			ht := clay.height - (c.rowspan-1)*vsep;
+			if(ht > spanht) {
+				# add extra space to last spanned row
+				i = c.row+c.rowspan-1;
+				if(i >= tab.nrow)
+					i = tab.nrow - 1;
+				tab.rows[i].height += ht - spanht;
+				if(dbgtab)
+					sys->print("sizetable %d, row %d height %d\n", tab.tableid, i, tab.rows[i].height);
+			}
+		}
+	}
+	# get total width, heights, and col x / row y positions
+	totw = bd + hsp + cbd + pad;
+	for(ci = 0; ci < tab.ncol; ci++) {
+		tab.cols[ci].pos.x = totw;
+		if(dbgtab)
+			sys->print("sizetable %d, col %d at x=%d\n", tab.tableid, ci, totw);
+		totw += tab.cols[ci].width + hsep;
+	}
+	totw = totw - (cbd+pad) + bd;
+	toth := bd + vsp + cbd + pad;
+	# first time: move tab.caption items into layout
+	if(tab.caption != nil) {
+		# lay caption with Aleft; drawing will center it over the table width
+		tab.caption_lay = sublayout(f, availwidth, Aleft, f.layout.background, tab.caption);
+		caplay := f.sublays[tab.caption_lay];
+		tab.caph = caplay.height + CAPSEP;
+		tab.caption = nil;
+	}
+	else if(tab.caption_lay >= 0) {
+		caplay := f.sublays[tab.caption_lay];
+		if(tab.availw != availwidth || (caplay.flags&Lchanged) != byte 0) {
+			relayout(f, caplay, availwidth, Aleft);
+			tab.caph = caplay.height + CAPSEP;
+		}
+	}
+	if(tab.caption_place == Atop)
+		toth += tab.caph;
+	for(ri = 0; ri < tab.nrow; ri++) {
+		tab.rows[ri].pos.y = toth;
+		if(dbgtab)
+			sys->print("sizetable %d, row %d at y=%d\n", tab.tableid, ri, toth);
+		toth += tab.rows[ri].height + vsep;
+	}
+	toth = toth - (cbd+pad) + bd;
+	if(tab.caption_place == Abottom)
+		toth += tab.caph;
+	tab.totw = totw;
+	tab.toth = toth;
+	tab.availw = availwidth;
+	tab.flags &= ~Lchanged;
+	if(dbgtab)
+		sys->print("\ndone sizetable %d, availwidth %d, totw=%d, toth=%d\n\n",
+			tab.tableid, availwidth, totw, toth);
+}
+
+# Calculate various table spacing parameters
+tableparams(tab: ref Table) : (int, int, int, int, int, int, int)
+{
+	bd := tab.border;
+	hsp := tab.cellspacing;
+	vsp := hsp;
+	pad := tab.cellpadding;
+	if(bd != 0)
+		cbd := 1;
+	else
+		cbd = 0;
+	hsep := 2*(cbd+pad)+hsp;
+	vsep := 2*(cbd+pad)+vsp;
+	return (hsp, vsp, pad, bd, cbd, hsep, vsep);
+}
+
+# return cell width, taking multicol spanning into account
+cellwidth(tab: ref Table, c: ref Tablecell, hsep: int) : int
+{
+	if(c.colspan == 1)
+		return tab.cols[c.col].width;
+	wd := (c.colspan-1)*hsep;
+	for(i := 0; i < c.colspan && c.col + i < tab.ncol; i++)
+		wd += tab.cols[c.col + i].width;
+	return wd;
+}
+
+# return cell height, taking multirow spanning into account
+cellheight(tab: ref Table, c: ref Tablecell, vsep: int) : int
+{
+	if(c.rowspan == 1)
+		return tab.rows[c.row].height;
+	ht := (c.rowspan-1)*vsep;
+	for(i := 0; i < c.rowspan && c.row + i < tab.nrow; i++)
+		ht += tab.rows[c.row + i].height;
+	return ht;
+}
+
+# Calculate the column widths w as the max of the cells
+# maxw or minw (as domax is 1 or 0).
+# Return the total of all w.
+# (hseps were accounted for by the adjustment that got
+# totw from availwidth).
+# hsep is amount of free space available between columns
+# where there is multicolumn spanning.
+# This is a two-pass algorithm.  The first pass ignores
+# cells that span multiple columns.  The second pass
+# sees if those multispanners need still more space, and
+# if so, apportions the space out.
+widthcalc(tab: ref Table, w: array of int, hsep, domax: int) : int
+{
+	anyspan := 0;
+	totw := 0;
+	for(pass := 1; pass <= 2; pass++) {
+		if(pass==2 && !anyspan)
+			break;
+		totw = 0;
+		for(ci := 0; ci < tab.ncol; ci++) {
+			for(ri := 0; ri < tab.nrow; ri++) {
+				c := tab.grid[ri][ci];
+				if(c == nil)
+					continue;
+				if(domax)
+					cwd := c.maxw;
+				else
+					cwd = c.minw;
+				if(pass == 1) {
+					if(c.colspan > 1) {
+						anyspan = 1;
+						continue;
+					}
+					if(cwd > w[ci])
+						w[ci] = cwd;
+				}
+				else {
+					if(c.colspan == 1 || !(ci==c.col && ri==c.row))
+						continue;
+					curw := 0;
+					iend := ci+c.colspan;
+					if(iend > tab.ncol)
+						iend = tab.ncol;
+					for(i:=ci; i < iend; i++)
+						curw += w[i];
+				
+					# padding between spanned cols is free
+					cwd -= hsep*(c.colspan-1);
+					diff := cwd-curw;
+					if(diff <= 0)
+						continue;
+					# doesn't fit: apportion diff among cols
+					# in proportion to their current w
+					for(i = ci; i < iend; i++) {
+						if(curw == 0)
+							w[i] = diff/c.colspan;
+						else
+							w[i] += diff*w[i]/curw;
+					}
+				}
+			}
+			totw += w[ci];
+		}
+	}
+	return totw;
+}
+
+layframeset(f: ref Frame, ki: ref Kidinfo)
+{
+	fwid := f.cr.dx();
+	fht := f.cr.dy();
+	if(dbg)
+		sys->print("layframeset, configuring frame %d wide by %d high\n", fwid, fht);
+	(nrow, rowh) := frdimens(ki.rows, fht);
+	(ncol, colw) := frdimens(ki.cols, fwid);
+	l := ki.kidinfos;
+	y := f.cr.min.y;
+	for(i := 0; i < nrow; i++) {
+		x := f.cr.min.x;
+		for(j := 0; j < ncol; j++) {
+			if(l == nil)
+				return;
+			r := Rect(Point(x,y), Point(x+colw[j],y+rowh[i]));
+			if(dbg)
+				sys->print("kid gets rect (%d,%d)(%d,%d)\n", r.min.x, r.min.y, r.max.x, r.max.y);
+			kidki := hd l;
+			l = tl l;
+			kidf := Frame.newkid(f, kidki, r);
+			if(!kidki.isframeset)
+				f.kids = kidf :: f.kids;
+			if(kidf.framebd != 0) {
+				kidf.cr = kidf.r.inset(2);
+				drawborder(kidf.cim, kidf.cr, 2, DarkGrey);
+			}
+			if(kidki.isframeset) {
+				layframeset(kidf, kidki);
+				for(al := kidf.kids; al != nil; al = tl al)
+					f.kids = (hd al) :: f.kids;
+			}
+			x += colw[j];
+		}
+		y += rowh[i];
+	}
+}
+
+# Use the dimension specs in dims to allocate total space t.
+# Return (number of dimens, array of allocated space)
+frdimens(dims: array of B->Dimen, t: int): (int, array of int)
+{
+	n := len dims;
+	if(n == 1)
+		return (1, array[] of {t});
+	totpix := 0;
+	totpcnt := 0;
+	totrel := 0;
+	for(i := 0; i < n; i++) {
+		v := dims[i].spec();
+		kind := dims[i].kind();
+		if(v < 0) {
+			v = 0;
+			dims[i] = Dimen.make(kind, v);
+		}
+		case kind {
+			B->Dpixels => totpix += v;
+			B->Dpercent => totpcnt += v;
+			B->Drelative => totrel += v;
+			B->Dnone => totrel++;
+		}
+	}
+	spix := 1.0;
+	spcnt := 1.0;
+	min_relu := 0;
+	if(totrel > 0)
+		min_relu = 30;	# allow for scrollbar (14) and a bit
+	relu := real min_relu;
+	tt := totpix + (t*totpcnt/100) + totrel*min_relu;
+	# want
+	#  t ==  totpix*spix + (totpcnt/100)*spcnt*t + totrel*relu
+	if(tt < t) {
+		# need to expand one of spix, spcnt, relu
+		if(totrel == 0) {
+			if(totpcnt != 0)
+				# spix==1.0, relu==0, solve for spcnt
+				spcnt = real ((t-totpix) * 100)/ real (t*totpcnt);
+			else
+				# relu==0, totpcnt==0, solve for spix
+				spix = real t/ real totpix;
+		}
+		else
+			# spix=1.0, spcnt=1.0, solve for relu
+			relu += real (t-tt)/ real totrel;
+	}
+	else {
+		# need to contract one or more of spix, spcnt, and have relu==min_relu
+		totpixrel := totpix+totrel*min_relu;
+		if(totpixrel < t) {
+			# spix==1.0, solve for spcnt
+			spcnt = real ((t-totpixrel) * 100)/ real (t*totpcnt);
+		}
+		else {
+			# let spix==spcnt, solve
+			trest := t - totrel*min_relu;
+			if(trest > 0) {
+				spcnt = real trest/real (totpix+(t*totpcnt/100));
+			}
+			else {
+				spcnt = real t / real tt;
+				relu = 0.0;
+			}
+			spix = spcnt;
+		}
+	}
+	x := array[n] of int;
+	tt = 0;
+	for(i = 0; i < n-1; i++) {
+		vr := real dims[i].spec();
+		case dims[i].kind() {
+			B->Dpixels => vr = vr * spix;
+			B->Dpercent => vr = vr * real t * spcnt / 100.0;
+			B->Drelative => vr = vr * relu;
+			B->Dnone => vr = relu;
+		}
+		x[i] = int vr;
+		tt += x[i];
+	}
+	x[n-1] = t - tt;
+	return (n, x);
+}
+
+# Return last item of list of items, or nil if no items
+lastitem(it: ref Item) : ref Item
+{
+	ans : ref Item = it;
+	for( ; it != nil; it = it.next)
+		ans = it;
+	return ans;
+}
+
+# Lay out table if availw changed or tab changed
+checktabsize(f: ref Frame, t: ref Item.Itable, availw: int)
+{
+	tab := t.table;
+	if (dbgtab)
+		sys->print("checktabsize %d, availw %d, tab.availw %d, changed %d\n", tab.tableid, availw, tab.availw, (tab.flags&Lchanged)>byte 0);
+	if(availw != tab.availw || int (tab.flags&Lchanged)) {
+		sizetable(f, tab, availw);
+		t.width = tab.totw + 2*tab.border;
+		t.height = tab.toth + 2*tab.border;
+		t.ascent = t.height;
+	}
+}
+
+widthfromspec(wspec: Dimen, availw: int) : int
+{
+	w := availw;
+	spec := wspec.spec();
+	case wspec.kind() {
+		Dpixels => w = spec;
+		Dpercent => w = spec*w/100;
+	}
+	return w;
+}
+
+# An image may have arrived for an image input field
+checkffsize(f: ref Frame, i: ref Item, ff: ref Formfield)
+{
+	if(ff.ftype == Fimage && ff.image != nil) {
+		pick imi := ff.image {
+		Iimage =>
+			if(imi.ci.mims != nil && ff.ctlid >= 0) {
+				pick b := f.controls[ff.ctlid] {
+				Cbutton =>
+					if(b.pic == nil) {
+						b.pic = imi.ci.mims[0].im;
+						b.picmask = imi.ci.mims[0].mask;
+						w := b.pic.r.dx();
+						h := b.pic.r.dy();
+						b.r.max.x = b.r.min.x + w;
+						b.r.max.y = b.r.min.y + h;
+						i.width = w;
+						i.height = h;
+						i.ascent = h;
+					}
+				}
+			}
+		}
+	}
+	else if(ff.ftype == Fselect) {
+		opts := ff.options;
+		if(ff.ctlid >=0) {
+			pick c := f.controls[ff.ctlid] {
+			Cselect =>
+				if(len opts != len c.options) {
+					nc := Control.newff(f, ff);
+					f.controls[ff.ctlid] = nc;
+					i.width = nc.r.dx();
+					i.height = nc.r.dy();
+					i.ascent = lineascent + SELMARGIN;
+				}
+			}
+		}
+	}
+}
+
+drawall(f: ref Frame)
+{
+	oclipr := f.cim.clipr;
+	origin := f.lptosp(zp);
+	clipr := f.dirtyr.addpt(origin);
+	f.cim.clipr = clipr;
+	fillbg(f, clipr);
+	if(dbg > 1)
+		sys->print("drawall, cr=(%d,%d,%d,%d), viewr=(%d,%d,%d,%d), origin=(%d,%d)\n",
+			f.cr.min.x, f.cr.min.y, f.cr.max.x, f.cr.max.y,
+			f.viewr.min.x, f.viewr.min.y, f.viewr.max.x, f.viewr.max.y,
+			origin.x, origin.y);
+	if(f.layout != nil)
+		drawlay(f, f.layout, origin);
+	f.cim.clipr = oclipr;
+	G->flush(f.cr);
+	f.isdirty = 0;
+}
+
+drawlay(f: ref Frame, lay: ref Lay, origin: Point)
+{
+	for(l := lay.start.next; l != lay.end; l = l.next)
+		drawline(f, origin, l, lay);
+}
+
+# Draw line l in frame f, assuming that content's (0,0)
+# aligns with layorigin in f.cim.
+drawline(f : ref Frame, layorigin : Point, l: ref Line, lay: ref Lay)
+{
+	im := f.cim;
+	o := layorigin.add(l.pos);
+	x := o.x;
+	y := o.y;
+	lr := Rect(zp, Point(l.width, l.height)).addpt(o);
+	isdirty := f.isdirty && lr.Xrect(f.dirtyr.addpt(f.lptosp(zp)));
+	inview := lr.Xrect(f.cr) && isdirty;
+
+	# note: drawimg must always be called to update
+	# draw point of animated images
+	for(it := l.items; it != nil; it = it.next) {
+		pick i := it {
+		Itext =>
+			if (!inview || i.s == nil)
+				break;
+			fnt := fonts[i.fnt];
+			width := i.width;
+			yy := y+l.ascent - fnt.f.ascent + (int i.voff) - Voffbias;
+			if (f.prctxt != nil) {
+				if (yy < f.cr.min.y)
+					continue;
+				endy := yy + fnt.f.height;
+				if (endy > f.cr.max.y) {
+					# do not draw
+					if (yy < f.prctxt.endy)
+						f.prctxt.endy = yy;
+					continue;
+				}
+			}
+			fgi := colorimage(i.fg);
+			im.text(Point(x, yy), fgi, zp, fnt.f, i.s);
+			if(i.ul != ULnone) {
+				if(i.ul == ULmid)
+					yy += 2*i.ascent/3;
+				else
+					yy += i.height - 1;
+				# don't underline leading space
+				# have already adjusted x pos in fixlinegeom()
+				ulx := x;
+				ulw := width;
+				if (i.s[0] == ' ') {
+					ulx += fnt.spw;
+					ulw -= fnt.spw;
+				}
+				if (i.s[len i.s - 1] == ' ')
+					ulw -= fnt.spw;
+				if (ulw < 1)
+					continue;
+				im.drawop(Rect(Point(ulx,yy),Point(ulx+ulw,yy+1)), fgi, nil, zp, Draw->S);
+			}
+		Irule =>
+			if (!inview)
+				break;
+			yy := y + RULESP;
+			im.draw(Rect(Point(x,yy),Point(x+i.width,yy+i.size)),
+					display.black, nil, zp);
+		Iimage =>
+			yy := y;
+			if(i.align == Abottom)
+				# bottom aligns with baseline
+				yy += l.ascent - i.imheight;
+			else if(i.align == Amiddle)
+				yy += l.ascent - (i.imheight/2);
+			drawimg(f, Point(x,yy), i);
+		Iformfield =>
+			ff := i.formfield;
+			if(ff.ctlid >= 0 && ff.ctlid < len f.controls) {
+				ctl := f.controls[ff.ctlid];
+				dims := ctl.r.max.sub(ctl.r.min);
+				# align as text
+				yy := y + l.ascent - i.ascent;
+				p := Point(x,yy);
+				ctl.r = Rect(p, p.add(dims));
+				if (!inview)
+					break;
+				if (f.prctxt != nil) {
+					if (yy < f.cr.min.y)
+						continue;
+					if (ctl.r.max.y > f.cr.max.y) {
+						# do not draw
+						if (yy < f.prctxt.endy)
+							f.prctxt.endy = yy;
+						continue;
+					}
+				}
+				ctl.draw(0);
+			}
+		Itable =>
+			# don't check inview - table can contain images
+			drawtable(f, lay, Point(x,y), i.table);
+			t := i.table;
+		Ifloat =>
+			xx := layorigin.x + lay.margin;
+			if(i.side == Aright) {
+				xx -= i.x;
+#				# for main layout of frame, floats hug
+#				# right edge of frame, not layout
+#				# (other browsers do that)
+#				if(f.layout == lay)
+					xx += lay.targetwidth;
+#				else
+#					xx += lay.width;
+			}
+			else
+				xx += i.x;
+			pick fi := i.item {
+			Iimage =>
+				drawimg(f, Point(xx, layorigin.y + i.y + (int fi.border + int fi.vspace)), fi);
+			Itable =>
+				drawtable(f, lay, Point(xx, layorigin.y + i.y), fi.table);
+			}
+		}
+		x += it.width;
+	}
+}
+
+drawimg(f: ref Frame, iorigin: Point, i: ref Item.Iimage)
+{
+	ci := i.ci;
+	im := f.cim;
+	iorigin.x += int i.hspace + int i.border;
+	# y coord is already adjusted for border and vspace
+	if(ci.mims != nil) {
+		r := Rect(iorigin, iorigin.add(Point(i.imwidth,i.imheight)));
+		inview := r.Xrect(f.cr);
+		if(i.ctlid >= 0) {
+			# animated
+			c := f.controls[i.ctlid];
+			dims := c.r.max.sub(c.r.min);
+			c.r = Rect(iorigin, iorigin.add(dims));
+			if (inview) {
+				pick ac := c {
+				Canimimage =>
+					ac.redraw = 1;
+					ac.bg = f.layout.background;
+				}
+				c.draw(0);
+			}
+		}
+		else if (inview) {
+			mim := ci.mims[0];
+			iorigin = iorigin.add(mim.origin);
+			im.draw(r, mim.im, mim.mask, zp);
+		}
+		if(inview && i.border != byte 0) {
+			if(i.anchorid != 0)
+				bdcol := f.doc.link;
+			else
+				bdcol = Black;
+			drawborder(im, r, int i.border, bdcol);
+		}
+	}
+	else if((CU->config).imagelvl == CU->ImgNone && i.altrep != "") {
+		fnt := fonts[DefFnt].f;
+		yy := iorigin.y+(i.imheight-fnt.height)/2;
+		xx := iorigin.x + (i.width-fnt.width(i.altrep))/2;
+		if(i.anchorid != 0)
+			col := f.doc.link;
+		else
+			col = DarkGrey;
+		fgi := colorimage(col);
+		im.text(Point(xx, yy), fgi, zp, fnt, i.altrep);
+	}
+}
+
+drawtable(f : ref Frame, parentlay: ref Lay, torigin: Point, tab: ref Table)
+{
+	if (dbgtab)
+		sys->print("drawtable %d\n", tab.tableid);
+	if(tab.ncol == 0 || tab.nrow == 0)
+		return;
+	im := f.cim;
+	(hsp, vsp, pad, bd, cbd, hsep, vsep) := tableparams(tab);
+	x := torigin.x;
+	y := torigin.y;
+	capy := y;
+	boxy := y;
+	if(tab.caption_place == Abottom)
+		capy = y+tab.toth-tab.caph+vsp;
+	else
+		boxy = y+tab.caph;
+	if (tab.background.color != -1 && tab.background.color != parentlay.background.color) {
+#	if(tab.background.image != parentlay.background.image ||
+#	   tab.background.color != parentlay.background.color) {
+		bgi := colorimage(tab.background.color);
+		im.draw(((x,boxy),(x+tab.totw,boxy+tab.toth-tab.caph)),
+			bgi, nil, zp);
+	}
+	if(bd != 0)
+		drawborder(im, ((x+bd,boxy+bd),(x+tab.totw-bd,boxy+tab.toth-tab.caph-bd)),
+			1, Black);
+	for(cl := tab.cells; cl != nil; cl = tl cl) {
+		c := hd cl;
+		if (c.layid == -1 || c.layid >= len f.sublays) {
+			# for some reason (usually scrolling)
+			# we are drawing this cell before it has been layed out
+			continue;
+		}
+		clay := f.sublays[c.layid];
+		if(clay == nil)
+			continue;
+		cx := x + tab.cols[c.col].pos.x;
+		cy := y + tab.rows[c.row].pos.y;
+		wd := cellwidth(tab, c, hsep);
+		ht := cellheight(tab, c, vsep);
+		if(c.background.image != nil && c.background.image.ci != nil && c.background.image.ci.mims != nil) {
+			cellr := Rect((cx-pad,cy-pad),(cx+wd+pad,cy+ht+pad));
+			ci := c.background.image.ci;
+			bgi := ci.mims[0].im;
+			bgmask := ci.mims[0].mask;
+			im.draw(cellr, bgi, bgmask, bgi.r.min);
+		} else if(c.background.color != -1 && c.background.color != tab.background.color) {
+			bgi := colorimage(c.background.color);
+			im.draw(((cx-pad,cy-pad),(cx+wd+pad,cy+ht+pad)),
+				bgi, nil, zp);
+		}
+		if(bd != 0)
+			drawborder(im, ((cx-pad+1,cy-pad+1),(cx+wd+pad-1,cy+ht+pad-1)),
+				1, Black);
+		if(c.align.valign != Atop && c.align.valign != Abaseline) {
+			n := ht - clay.height;
+			if(c.align.valign == Amiddle)
+				cy += n/2;
+			else if(c.align.valign == Abottom)
+				cy += n;
+		}
+		if(dbgtab)
+			sys->print("drawtable %d cell %d at (%d,%d)\n",
+				tab.tableid, c.cellid, cx, cy);
+		drawlay(f, clay, Point(cx,cy));
+	}
+	if(tab.caption_lay >= 0) {
+		caplay := f.sublays[tab.caption_lay];
+		capx := x;
+		if(caplay.width < tab.totw)
+			capx += (tab.totw-caplay.width) / 2;
+		drawlay(f, caplay, Point(capx,capy));
+	}
+}
+
+# Draw border of width n just outside r, using src color
+drawborder(im: ref Image, r: Rect, n, color: int)
+{
+	x := r.min.x-n;
+	y := r.min.y - n;
+	xr := r.max.x+n;
+	ybi := r.max.y;
+	src := colorimage(color);
+	im.draw((Point(x,y),Point(xr,y+n)), src, nil, zp);				# top
+	im.draw((Point(x,ybi),Point(xr,ybi+n)), src, nil, zp);			# bottom
+	im.draw((Point(x,y+n),Point(x+n,ybi)), src, nil, zp);			# left
+	im.draw((Point(xr-n,y+n),Point(xr,ybi)), src, nil, zp);			# right
+}
+
+# Draw relief border just outside r, width 2 border,
+# colors white/lightgrey/darkgrey/black
+# to give raised relief (if raised != 0) or sunken.
+drawrelief(im: ref Image, r: Rect, raised: int)
+{
+	# ((x,y),(xr,yb)) == r
+	x := r.min.x;
+	x1 := x-1;
+	x2 := x-2;
+	xr := r.max.x;
+	xr1 := xr+1;
+	xr2 := xr+2;
+	y := r.min.y;
+	y1 := y-1;
+	y2 := y-2;
+	yb := r.max.y;
+	yb1 := yb+1;
+	yb2 := yb+2;
+
+	# colors for top/left outside, top/left inside, bottom/right outside, bottom/right inside
+	tlo, tli, bro, bri: ref Image;
+	if(raised) {
+		tlo = colorimage(Grey);
+		tli = colorimage(White);
+		bro = colorimage(Black);
+		bri = colorimage(DarkGrey);
+	}
+	else {
+		tlo = colorimage(DarkGrey);
+		tli = colorimage(Black);
+		bro = colorimage(White);
+		bri = colorimage(Grey);
+	}
+
+	im.draw((Point(x2,y2), Point(xr1,y1)), tlo, nil, zp);		# top outside
+	im.draw((Point(x1,y1), Point(xr,y)), tli, nil, zp);			# top inside
+	im.draw((Point(x2,y1), Point(x1,yb1)), tlo, nil, zp);		# left outside
+	im.draw((Point(x1,y), Point(x,yb)), tli, nil, zp);			# left inside
+	im.draw((Point(xr,y1),Point(xr1,yb)), bri, nil, zp);		# right inside
+	im.draw((Point(xr1,y),Point(xr2,yb1)), bro, nil, zp);		# right outside
+	im.draw((Point(x1,yb),Point(xr1,yb1)), bri, nil, zp);		# bottom inside
+	im.draw((Point(x,yb1),Point(xr2,yb2)), bro, nil, zp);		# bottom outside
+}
+
+# Fill r with color
+drawfill(im: ref Image, r: Rect, color: int)
+{
+	im.draw(r, colorimage(color), nil, zp);
+}
+
+# Draw string in default font at p
+drawstring(im: ref Image, p: Point, s: string)
+{
+	im.text(p, colorimage(Black), zp, fonts[DefFnt].f, s);
+}
+
+# Return (width, height) of string in default font
+measurestring(s: string) : Point
+{
+	f := fonts[DefFnt].f;
+	return (f.width(s), f.height);
+}
+
+# Mark as "changed" everything with change flags on the loc path
+markchanges(loc: ref Loc)
+{
+	lastf : ref Frame = nil;
+	for(i := 0; i < loc.n; i++) {
+		case loc.le[i].kind {
+		LEframe =>
+			lastf = loc.le[i].frame;
+			lastf.layout.flags |= Lchanged;
+		LEline =>
+			loc.le[i].line.flags |= Lchanged;
+		LEitem =>
+			pick it := loc.le[i].item {
+			Itable =>
+				it.table.flags |= Lchanged;
+			Ifloat =>
+				# whole layout will be redone if layout changes
+				# and there are any floats
+				;
+			}
+		LEtablecell =>
+			if(lastf == nil)
+				CU->raisex("EXInternal: markchanges no lastf");
+			c := loc.le[i].tcell;
+			clay := lastf.sublays[c.layid];
+			if(clay != nil)
+				clay.flags |= Lchanged;
+		}
+	}
+}
+
+# one-item cache for colorimage
+prevrgb := -1;
+prevrgbimage : ref Image = nil;
+
+colorimage(rgb: int) : ref Image
+{
+	if(rgb == prevrgb)
+		return prevrgbimage;
+	prevrgb = rgb;
+	if(rgb == Black)
+		prevrgbimage = display.black;
+	else if(rgb == White)
+		prevrgbimage = display.white;
+	else {
+		hv := rgb % NCOLHASH;
+		if (hv < 0)
+			hv = -hv;
+		xhd := colorhashtab[hv];
+		x := xhd;
+		while(x != nil && x.rgb  != rgb)
+			x = x.next;
+		if(x == nil) {
+#			pix := I->closest_rgbpix((rgb>>16)&255, (rgb>>8)&255, rgb&255);
+#			im := display.color(pix);
+			im := display.rgb((rgb>>16)&255, (rgb>>8)&255, rgb&255);
+			if(im == nil)
+				CU->raisex(sys->sprint("exLayout: can't allocate color #%8.8ux: %r", rgb));
+			x = ref Colornode(rgb, im, xhd);
+			colorhashtab[hv] = x;
+		}
+		prevrgbimage = x.im;
+	}
+	return prevrgbimage;
+}
+
+# Use f.background.image (if not nil) or f.background.color to fill r (in cim coord system)
+# with background color.
+fillbg(f: ref Frame, r: Rect)
+{
+	bgi: ref Image;
+	ii := f.doc.background.image;
+	if (ii != nil && ii.ci != nil && ii.ci.mims != nil)
+		bgi = ii.ci.mims[0].im;
+	if(bgi == nil)
+		bgi = colorimage(f.doc.background.color);
+	f.cim.drawop(r, bgi, nil, f.viewr.min, Draw->S);
+}
+
+TRIup, TRIdown, TRIleft, TRIright: con iota;
+# Assume r is a square
+drawtriangle(im: ref Image, r: Rect, kind, style: int)
+{
+	drawfill(im, r, Grey);
+	b := r.max.x - r.min.x;
+	if(b < 4)
+		return;
+	b2 := b/2;
+	bm2 := b-ReliefBd;
+	p := array[3] of Point;
+	col012, col20 : ref Image;
+	d := colorimage(DarkGrey);
+	l := colorimage(White);
+	case kind {
+	TRIup =>
+		p[0] = Point(b2, ReliefBd);
+		p[1] = Point(bm2,bm2);
+		p[2] = Point(ReliefBd,bm2);
+		col012 = d;
+		col20 = l;
+	TRIdown =>
+		p[0] = Point(b2,bm2);
+		p[1] = Point(ReliefBd,ReliefBd);
+		p[2] = Point(bm2,ReliefBd);
+		col012 = l;
+		col20 = d;
+	TRIleft =>
+		p[0] = Point(bm2, ReliefBd);
+		p[1] = Point(bm2, bm2);
+		p[2] = Point(ReliefBd,b2);
+		col012 = d;
+		col20 = l;
+	TRIright =>
+		p[0] = Point(ReliefBd,bm2);
+		p[1] = Point(ReliefBd,ReliefBd);
+		p[2] = Point(bm2,b2);
+		col012 = l;
+		col20 = d;
+	}
+	if(style == ReliefSunk) {
+		t := col012;
+		col012 = col20;
+		col20 = t;
+	}
+	for(i := 0; i < 3; i++)
+		p[i] = p[i].add(r.min);
+	im.fillpoly(p, ~0, colorimage(Grey), zp);
+	im.line(p[0], p[1], 0, 0, ReliefBd/2, col012, zp);
+	im.line(p[1], p[2], 0, 0, ReliefBd/2, col012, zp);
+	im.line(p[2], p[0], 0, 0, ReliefBd/2, col20, zp);
+}
+
+abs(a: int) : int
+{
+	if(a < 0)
+		return -a;
+	return a;
+}
+
+Frame.new() : ref Frame
+{
+	f := ref Frame;
+	f.parent = nil;
+	f.cim = nil;
+	f.r = Rect(zp, zp);
+	f.animpid = 0;
+	f.reset();
+	return f;
+}
+
+Frame.newkid(parent: ref Frame, ki: ref Kidinfo, r: Rect) : ref Frame
+{
+	f := ref Frame;
+	f.parent = parent;
+	f.cim = parent.cim;
+	f.r = r;
+	f.animpid = 0;
+	f.reset();
+	f.src = ki.src;
+	f.name = ki.name;
+	f.marginw = ki.marginw;
+	f.marginh = ki.marginh;
+	f.framebd = ki.framebd;
+	f.flags = ki.flags;
+	return f;
+}
+
+# Note: f.parent, f.cim and f.r should not be reset
+# And if f.parent is true, don't reset params set in frameset.
+Frame.reset(f: self ref Frame)
+{
+	f.id = ++frameid;
+	f.doc = nil;
+	if(f.parent == nil) {
+		f.src = nil;
+		f.name = "";
+		f.marginw = FRMARGIN;
+		f.marginh = FRMARGIN;
+		f.framebd = 0;
+		f.flags = FRvscrollauto | FRhscrollauto;
+	}
+	f.layout = nil;
+	f.sublays = nil;
+	f.sublayid = 0;
+	f.controls = nil;
+	f.controlid = 0;
+	f.cr = f.r;
+	f.isdirty = 1;
+	f.dirtyr = f.cr;
+	f.viewr = Rect(zp, zp);
+	f.totalr = f.viewr;
+	f.vscr = nil;
+	f.hscr = nil;
+	hadkids := (f.kids != nil);
+	f.kids = nil;
+	if(f.animpid != 0)
+		CU->kill(f.animpid, 0);
+	if(J != nil && hadkids)
+		J->frametreechanged(f);
+	f.animpid = 0;
+}
+
+Frame.dirty(f: self ref Frame, r: Draw->Rect)
+{
+	if (f.isdirty)
+		f.dirtyr= f.dirtyr.combine(r);
+	else {
+		f.dirtyr = r;
+		f.isdirty = 1;
+	}
+}
+
+Frame.addcontrol(f: self ref Frame, c: ref Control) : int
+{
+	if(len f.controls <= f.controlid) {
+		newcontrols := array[len f.controls + 30] of ref Control;
+		newcontrols[0:] = f.controls;
+		f.controls = newcontrols;
+	}
+	f.controls[f.controlid] = c;
+	ans := f.controlid++;
+	return ans;
+}
+
+Frame.xscroll(f: self ref Frame, kind, val: int)
+{
+	newx := f.viewr.min.x;
+	case kind {
+	CAscrollpage =>
+		newx += val*(f.cr.dx()*8/10);
+	CAscrollline =>
+		newx += val*f.cr.dx()/10;
+	CAscrolldelta =>
+		newx += val;
+	CAscrollabs =>
+		newx = val;
+	}
+	f.scrollabs(Point(newx, f.viewr.min.y));
+}
+
+# Don't actually scroll by "page" and "line",
+# But rather, 80% and 10%, which give more
+# context in the first case, and more motion
+# in the second.
+Frame.yscroll(f: self ref Frame, kind, val: int)
+{
+	newy := f.viewr.min.y;
+	case kind {
+	CAscrollpage =>
+		newy += val*(f.cr.dy()*8/10);
+	CAscrollline =>
+		newy += val*f.cr.dy()/20;
+	CAscrolldelta =>
+		newy += val;
+	CAscrollabs =>
+		newy = val;
+	}
+	f.scrollabs(Point(f.viewr.min.x, newy));
+}
+
+Frame.scrollrel(f : self ref Frame, p : Point)
+{
+	(x, y) := p;
+	x += f.viewr.min.x;
+	y += f.viewr.min.y;
+	f.scrollabs(f.viewr.min.add(p));
+}
+
+Frame.scrollabs(f : self ref Frame, p : Point)
+{
+	(x, y) := p;
+	lay := f.layout;
+	margin := 0;
+	if (lay != nil)
+		margin = lay.margin;
+	x = max(0, min(x, f.totalr.max.x));
+	y = max(0, min(y, f.totalr.max.y + margin - f.cr.dy()));
+	(oldx, oldy) := f.viewr.min;
+	if (oldx != x || oldy != y) {
+		f.viewr.min = (x, y);
+		fixframegeom(f);
+		# blit scroll
+		dx := f.viewr.min.x - oldx;
+		dy := f.viewr.min.y - oldy;
+		origin := f.lptosp(zp);
+		destr := f.viewr.addpt(origin);
+		srcpt := destr.min.add((dx, dy));
+		oclipr := f.cim.clipr;
+		f.cim.clipr = f.cr;
+		f.cim.drawop(destr, f.cim, nil, srcpt, Draw->S);
+		if (dx > 0)
+			f.dirty(Rect((f.viewr.max.x - dx, f.viewr.min.y), f.viewr.max));
+		else if (dx < 0)
+			f.dirty(Rect(f.viewr.min, (f.viewr.min.x - dx, f.viewr.max.y)));
+
+		if (dy > 0)
+			f.dirty(Rect((f.viewr.min.x, f.viewr.max.y-dy), f.viewr.max));
+		else if (dy < 0)
+			f.dirty(Rect(f.viewr.min, (f.viewr.max.x, f.viewr.min.y-dy)));
+#f.cim.draw(destr, display.white, nil, zp);
+		drawall(f);
+		f.cim.clipr = oclipr;
+	}
+}
+
+# Convert layout coords (where (0,0) is top left of layout)
+# to screen coords (i.e., coord system of mouse, f.cr, etc.)
+Frame.sptolp(f: self ref Frame, sp: Point) : Point
+{
+	return f.viewr.min.add(sp.sub(f.cr.min));
+}
+
+# Reverse translation of sptolp
+Frame.lptosp(f: self ref Frame, lp: Point) : Point
+{
+	return lp.add(f.cr.min.sub(f.viewr.min));
+}
+
+# Return Loc of Item or Scrollbar containing p (p in screen coords)
+# or item it, if that is not nil.
+Frame.find(f: self ref Frame, p: Point, it: ref Item) : ref Loc
+{
+	return framefind(Loc.new(), f, p, it);
+}
+
+# Find it (if non-nil) or place where p is (known to be inside f's layout).
+framefind(loc: ref Loc, f: ref Frame, p: Point, it: ref Item) : ref Loc
+{
+	loc.add(LEframe, f.r.min);
+	loc.le[loc.n-1].frame = f;
+	if(it == nil) {
+		if(f.vscr != nil && p.in(f.vscr.r)) {
+			loc.add(LEcontrol, f.vscr.r.min);
+			loc.le[loc.n-1].control = f.vscr;
+			loc.pos = p.sub(f.vscr.r.min);
+			return loc;
+		}
+		if(f.hscr != nil && p.in(f.hscr.r)) {
+			loc.add(LEcontrol, f.hscr.r.min);
+			loc.le[loc.n-1].control = f.hscr;
+			loc.pos = p.sub(f.hscr.r.min);
+			return loc;
+		}
+	}
+	if(it != nil || p.in(f.cr)) {
+		lay := f.layout;
+		if(f.kids != nil) {
+			for(fl := f.kids; fl != nil; fl = tl fl) {
+				kf := hd fl;
+				try := framefind(loc, kf, p, it);
+				if(try != nil)
+					return try;
+			}
+		}
+		else if(lay != nil)
+			return layfind(loc, f, lay, f.lptosp(zp), p, it);
+	}
+	return nil;
+}
+
+# Find it (if non-nil) or place where p is (known to be inside f's layout).
+# p (in screen coords), lay offset by origin also in screen coords
+layfind(loc: ref Loc, f: ref Frame, lay: ref Lay, origin, p: Point, it: ref Item) : ref Loc
+{
+	for(flist := lay.floats; flist != nil; flist = tl flist) {
+		fl := hd flist;
+		fymin := fl.y+origin.y;
+		fymax := fymin + fl.item.height;
+		inside := 0;
+		xx : int;
+		if(it != nil || (fymin <= p.y && p.y < fymax)) {
+			xx = origin.x + lay.margin;
+			if(fl.side == Aright) {
+				xx -= fl.x;
+				xx += lay.targetwidth;
+#				if(lay == f.layout)
+#					xx = origin.x + (f.cr.dx() - lay.margin) - fl.x;
+##					xx += f.cr.dx() - fl.x;
+#				else
+#					xx += lay.width - fl.x;
+			}
+			else
+				xx += fl.x;
+			if(p.x >= xx && p.x < xx+fl.item.width)
+					inside = 1;
+		}
+		fp := Point(xx,fymin);
+		match := 0;
+		if(it != nil) {
+			pick fi := fl.item {
+			Itable =>
+				loc.add(LEitem, fp);
+				loc.le[loc.n-1].item = fl;
+				loc.pos = p.sub(fp);
+				lloc := tablefind(loc, f, fi, fp, p, it);
+				if(lloc != nil)
+					return lloc;
+			Iimage =>
+				match = (it == fl || it == fl.item);
+			}
+		}
+		if(match || inside) {
+			loc.add(LEitem, fp);
+			loc.le[loc.n-1].item = fl;
+			loc.pos = p.sub(fp);
+			if(it == fl.item) {
+				loc.add(LEitem, fp);
+				loc.le[loc.n-1].item = fl.item;
+			}
+			if(inside) {
+				pick fi := fl.item {
+				Itable =>
+					loc = tablefind(loc, f, fi, fp, p, it);
+				}
+			}
+			return loc;
+		}
+	}
+	for(l :=lay.start; l != nil; l = l.next) {
+		o := origin.add(l.pos);
+		if(it != nil || (o.y <= p.y && p.y < o.y+l.height)) {
+			lloc := linefind(loc, f, l, o, p, it);
+			if(lloc != nil)
+				return lloc;
+			if(it == nil && o.y + l.height >= p.y)
+				break;
+		}
+	}
+	return nil;
+}
+
+# p (in screen coords), line at o, also in screen coords
+linefind(loc: ref Loc, f: ref Frame, l: ref Line, o, p: Point, it: ref Item) : ref Loc
+{
+	loc.add(LEline, o);
+	loc.le[loc.n-1].line = l;
+	x := o.x;
+	y := o.y;
+	inside := 0;
+	for(i := l.items; i != nil; i = i.next) {
+		if(it != nil || (x <= p.x && p.x < x+i.width)) {
+			yy := y;
+			h := 0;
+			pick pi := i {
+			Itext =>
+				fnt := fonts[pi.fnt].f;
+				yy += l.ascent - fnt.ascent + (int pi.voff) - Voffbias;
+				h = fnt.height;
+			Irule =>
+				h = pi.size;
+			Iimage =>
+				yy = y;
+				if(pi.align == Abottom)
+					yy += l.ascent - pi.imheight;
+				else if(pi.align == Amiddle)
+					yy += l.ascent - (pi.imheight/2);
+				h = pi.imheight;
+			Iformfield =>
+				h = pi.height;
+				yy += l.ascent - pi.ascent;
+				if(it != nil) {
+					if(it == pi.formfield.image) {
+						loc.add(LEitem, Point(x,yy));
+						loc.le[loc.n-1].item = i;
+						loc.add(LEitem, Point(x,yy));
+						loc.le[loc.n-1].item = it;
+						loc.pos = zp;	# doesn't matter, its an 'it' test
+						return loc;
+					}
+				}
+				else if(yy < p.y && p.y < yy+h && pi.formfield.ctlid >= 0) {
+					loc.add(LEcontrol, Point(x,yy));
+					loc.le[loc.n-1].control = f.controls[pi.formfield.ctlid];
+					loc.pos = p.sub(Point(x,yy));
+					return loc;
+				}
+			Itable =>
+				lloc := tablefind(loc, f, pi, Point(x,y), p, it);
+				if(lloc != nil)
+					return lloc;
+				# else leave h==0 so p test will fail
+
+			# floats were handled separately. nulls can be picked by 'it' test
+			# leave h==0, so p test will fail
+			}
+			if(it == i || (it == nil && yy <= p.y && p.y < yy+h)) {
+				loc.add(LEitem, Point(x,yy));
+				loc.le[loc.n-1].item = i;
+				loc.pos = p.sub(Point(x,yy));
+				return loc;
+			}
+			if(it == nil)
+				return nil;
+		}
+		x += i.width;
+		if(it == nil && x >= p.x)
+			break;
+	}
+	loc.n--;
+	return nil;
+}
+
+tablefind(loc: ref Loc, f: ref Frame, ti: ref Item.Itable, torigin: Point, p: Point, it: ref Item) : ref Loc
+{
+	loc.add(LEitem, torigin);
+	loc.le[loc.n-1].item = ti;
+	t := ti.table;
+	(hsp, vsp, pad, bd, cbd, hsep, vsep) := tableparams(t);
+	if(t.caption_lay >= 0) {
+		caplay := f.sublays[t.caption_lay];
+		capy := torigin.y;
+		if(t.caption_place == Abottom)
+			capy += t.toth-t.caph+vsp;
+		lloc := layfind(loc, f, caplay, Point(torigin.x,capy), p, it);
+		if(lloc != nil)
+			return lloc;
+	}
+	for(cl := t.cells; cl != nil; cl = tl cl) {
+		c := hd cl;
+		if(c.layid == -1 || c.layid >= len f.sublays)
+			continue;
+		clay := f.sublays[c.layid];
+		if(clay == nil)
+			continue;
+		cx := torigin.x + t.cols[c.col].pos.x;
+		cy := torigin.y + t.rows[c.row].pos.y;
+		wd := cellwidth(t, c, hsep);
+		ht := cellheight(t, c, vsep);
+		if(it == nil && !p.in(Rect(Point(cx,cy),Point(cx+wd,cy+ht))))
+			continue;
+		if(c.align.valign != Atop && c.align.valign != Abaseline) {
+			n := ht - clay.height;
+			if(c.align.valign == Amiddle)
+				cy += n/2;
+			else if(c.align.valign == Abottom)
+				cy += n;
+		}
+		loc.add(LEtablecell, Point(cx,cy));
+		loc.le[loc.n-1].tcell = c;
+		lloc := layfind(loc, f, clay, Point(cx,cy), p, it);
+		if(lloc != nil)
+			return lloc;
+		loc.n--;
+		if(it == nil)
+			return nil;
+	}
+	loc.n--;
+	return nil;
+}
+
+# (called from jscript)
+# 'it' is an Iimage item in frame f whose image is to be switched
+# to come from the src URL.
+#
+# For now, assume this is called only after the entire build process
+# has finished.  Also, only handle the case where the image has
+# been preloaded and is in the cache now.  This isn't right (BUG), but will
+# cover most of the cases of extant image swapping, and besides,
+# image swapping is mostly cosmetic anyway.
+# 
+# For now, pay no attention to scaling issues or animation issues.
+Frame.swapimage(f: self ref Frame, im: ref Item.Iimage, src: string)
+{
+	u := U->parse(src);
+	if(u.scheme == "")
+		return;
+	u = U->mkabs(u, f.doc.base);
+	# width=height=0 finds u if in cache
+	newci := CImage.new(u, nil, 0, 0);
+	cachedci := (CU->imcache).look(newci);
+	if(cachedci == nil || cachedci.mims == nil)
+		return;
+	im.ci = cachedci;
+
+	# we're assuming image will have same dimensions
+	# as one that is replaced, so no relayout is needed;
+	# otherwise need to call haveimage() instead of drawall()
+	# Netscape scales replacement image to size of replaced image
+
+	f.dirty(f.totalr);
+	drawall(f);
+}
+
+Frame.focus(f : self ref Frame, focus, raisex : int)
+{
+	di := f.doc;
+	if (di == nil || (CU->config).doscripts == 0)
+		return;
+	if (di.evmask && raisex) {
+		kind := E->SEonfocus;
+		if (!focus)
+			kind = E->SEonblur;
+		if(di.evmask & kind)
+			se := ref E->ScriptEvent(kind, f.id, -1, -1, -1, -1, -1, -1, 0, nil, nil, 0);
+	}
+}
+
+Control.newff(f: ref Frame, ff: ref B->Formfield) : ref Control
+{
+	ans : ref Control = nil;
+	case ff.ftype {
+	Ftext or Fpassword or Ftextarea =>
+		nh := ff.size;
+		nv := 1;
+		linewrap := 0;
+		if(ff.ftype == Ftextarea) {
+			nh = ff.cols;
+			nv = ff.rows;
+			linewrap = 1;
+		}
+		ans = Control.newentry(f, nh, nv, linewrap);
+		if(ff.ftype == Fpassword)
+			ans.flags |= CFsecure;
+		ans.entryset(ff.value);
+	Fcheckbox or Fradio =>
+		ans = Control.newcheckbox(f, ff.ftype==Fradio);
+		if((ff.flags&B->FFchecked) != byte 0)
+			ans.flags |= CFactive;
+	Fsubmit or Fimage or Freset or Fbutton =>
+		if(ff.image == nil)
+			ans = Control.newbutton(f, nil, nil, ff.value, nil, 0, 1);
+		else {
+			pick i := ff.image {
+			Iimage =>
+				pic, picmask : ref Image;
+				if(i.ci.mims != nil) {
+					pic = i.ci.mims[0].im;
+					picmask = i.ci.mims[0].mask;
+				}
+				lab := "";
+				if((CU->config).imagelvl == CU->ImgNone) {
+					lab = i.altrep;
+					i = nil;
+				}
+				ans = Control.newbutton(f, pic, picmask, lab, i, 0, 0);
+			}
+		}
+	Fselect =>
+		n := len ff.options;
+		if(n > 0) {
+			ao := array[n] of Option;
+			l := ff.options;
+			for(i := 0; i < n; i++) {
+				o := hd l;
+				# these are copied, so selected can be used for current state
+				ao[i] = *o;
+				l = tl l;
+			}
+			nvis := ff.size;
+			ans = Control.newselect(f, nvis, ao);
+		}
+	Ffile =>
+		if(dbg)
+			sys->print("warning: unimplemented file form field\n");
+	}
+	if(ans != nil)
+		ans.ff = ff;
+	return ans;
+}
+
+Control.newscroll(f: ref Frame, isvert, length, breadth: int) : ref Control
+{
+	# need room for at least two squares and 2 borders of size 2
+	if(length < 12) {
+		breadth = 0;
+		length = 0;
+	}
+	else if(breadth*2 + 4 > length)
+		breadth = (length - 4) / 2;
+	maxpt : Point;
+	flags := CFenabled;
+	if(isvert) {
+		maxpt = Point(breadth, length);
+		flags |= CFscrvert;
+	}
+	else
+		maxpt = Point(length, breadth);
+	return ref Control.Cscrollbar(f, nil, Rect(zp,maxpt), flags, nil, 0, 0, 1, 0, nil, (0, 0));
+}
+
+Control.newentry(f: ref Frame, nh, nv, linewrap: int) : ref Control
+{
+	w := ctlcharspace*nh + 2*ENTHMARGIN;
+	h := ctllinespace*nv + 2*ENTVMARGIN;
+	scr : ref Control;
+	if (linewrap) {
+		scr = Control.newscroll(f, 1, h-4, SCRFBREADTH);
+		scr.r.addpt(Point(w,0));
+		w += SCRFBREADTH;
+	}
+	ans := ref Control.Centry(f, nil, Rect(zp,Point(w,h)), CFenabled, nil, scr, "", (0, 0), 0, linewrap, 0);
+	if (scr != nil) {
+		pick pscr := scr {
+		Cscrollbar =>
+			pscr.ctl = ans;
+		}
+		scr.scrollset(0, 1, 1, 0, 0);
+	}
+	return ans;
+}
+
+Control.newbutton(f: ref Frame, pic, picmask: ref Image, lab: string, it: ref Item.Iimage, candisable, dorelief: int) : ref Control
+{
+	dpic, dpicmask: ref Image;
+	w := 0;
+	h := 0;
+	if(pic != nil) {
+		w = pic.r.dx();
+		h = pic.r.dy();
+	}
+	else if(it != nil) {
+		w = it.imwidth;
+		h = it.imheight;
+	}
+	else {
+		w = fonts[CtlFnt].f.width(lab);
+		h = ctllinespace;
+	}
+	if(dorelief) {
+		# form image buttons are shown without margins in other browsers
+		w += 2*BUTMARGIN;
+		h += 2*BUTMARGIN;
+	}
+	r := Rect(zp, Point(w,h));
+	if(candisable && pic != nil) {
+		# make "greyed out" image:
+		#	- convert pic to monochrome (ones where pic is non-white)
+		#	- draw pic in White, then DarkGrey shifted (-1,-1) and use
+		#	    union of those two areas as mask
+		dpicmask = display.newimage(pic.r, Draw->GREY1, 0, D->White);
+		dpic = display.newimage(pic.r, pic.chans, 0, D->White);
+		dpic.draw(dpic.r, colorimage(White), pic, zp);
+		dpicmask.draw(dpicmask.r, display.black, pic, zp);
+		dpic.draw(dpic.r.addpt(Point(-1,-1)), colorimage(DarkGrey), pic, zp);
+		dpicmask.draw(dpicmask.r.addpt(Point(-1,-1)), display.black, pic, zp);
+	}
+	b := ref Control.Cbutton(f, nil, r, CFenabled, nil, pic, picmask, dpic, dpicmask, lab, dorelief);
+	return b;
+}
+
+Control.newcheckbox(f: ref Frame, isradio: int) : ref Control
+{
+	return ref Control.Ccheckbox(f, nil, Rect((0,0),(CBOXWID,CBOXHT)), CFenabled, nil, isradio);
+}
+
+Control.newselect(f: ref Frame, nvis: int, options: array of B->Option) : ref Control
+{
+	nvis = min(5, len options);
+	if (nvis < 1)
+		nvis = 1;
+	fnt := fonts[CtlFnt].f;
+	w := 0;
+	first := -1;
+	for(i := 0; i < len options; i++) {
+		if (first == -1 && options[i].selected)
+			first = i;
+		w = max(w, fnt.width(options[i].display));
+	}
+	if (first == -1)
+		first = 0;
+	if (len options -nvis > 0 && len options - nvis < first)
+		first = len options - nvis;
+	w += 2*SELMARGIN;
+	h := ctllinespace*nvis + 2*SELMARGIN;
+	scr: ref Control;
+	if (nvis > 1 && nvis < len options) {
+		scr = Control.newscroll(f, 1, h, SCRFBREADTH);
+		scr.r.addpt(Point(w,0));
+	}
+	if (nvis < len options)
+		w += SCRFBREADTH;
+	ans := ref Control.Cselect(f, nil, Rect(zp, Point(w,h)), CFenabled, nil, nil, scr, nvis, first, options);
+	if(scr != nil) {
+		pick pscr := scr {
+		Cscrollbar =>
+			pscr.ctl = ans;
+		}
+		scr.scrollset(first, first+nvis, len options, len options, 0);
+	}
+	return ans;
+}
+
+Control.newlistbox(f: ref Frame, nrow, ncol: int, options: array of B->Option) : ref Control
+{
+	fnt := fonts[CtlFnt].f;
+	w := charspace*ncol + 2*SELMARGIN;
+	h := fnt.height*nrow + 2*SELMARGIN;
+
+	vscr: ref Control = nil;
+	#if(nrow < len options) {
+		vscr = Control.newscroll(f, 1, (h-4)+SCRFBREADTH, SCRFBREADTH);
+		vscr.r.addpt(Point(w-SCRFBREADTH,0));
+		w += SCRFBREADTH;
+	#}
+
+	maxw := 0;
+	for(i := 0; i < len options; i++)
+		maxw = max(maxw, fnt.width(options[i].display));
+
+	hscr: ref Control = nil;
+	#if(w < maxw) {
+		# allow for border (inset(2))
+		hscr = Control.newscroll(f, 0, (w-4)-SCRFBREADTH, SCRFBREADTH);
+		hscr.r.addpt(Point(0, h-SCRBREADTH));
+		h += SCRFBREADTH;
+	#}
+
+	ans := ref Control.Clistbox(f, nil, Rect(zp, Point(w,h)), CFenabled, nil, hscr, vscr, nrow, 0, 0, maxw/charspace, options, nil);
+	if(vscr != nil) {
+		pick pscr := vscr {
+		Cscrollbar =>
+			pscr.ctl = ans;
+		}
+		vscr.scrollset(0, nrow, len options, len options, 0);
+	}
+	if(hscr != nil) {
+		pick pscr := hscr {
+		Cscrollbar =>
+			pscr.ctl = ans;
+		}
+		hscr.scrollset(0, w-SCRFBREADTH, maxw, 0, 0);
+	}
+	return ans;	
+}
+
+Control.newanimimage(f: ref Frame, cim: ref CU->CImage, bg: Background) : ref Control
+{
+	return ref Control.Canimimage(f, nil, Rect((0,0),(cim.width,cim.height)), 0, nil, cim, 0, 0, big 0, bg);
+}
+
+Control.newlabel(f: ref Frame, s: string) : ref Control
+{
+	w := fonts[DefFnt].f.width(s);
+	h := ctllinespace + 2*ENTVMARGIN;	# give it same height as an entry box
+	return ref Control.Clabel(f, nil, Rect(zp,Point(w,h)), 0, nil, s);
+}
+
+Control.disable(c: self ref Control)
+{
+	if(c.flags & CFenabled) {
+		win := c.f.cim;
+		c.flags &= ~CFenabled;
+		if(c.f.cim != nil)
+			c.draw(1);
+	}
+}
+
+Control.enable(c: self ref Control)
+{
+	if(!(c.flags & CFenabled)) {
+		c.flags |= CFenabled;
+		if(c.f.cim != nil)
+			c.draw(1);
+	}
+}
+
+changeevent(c: ref Control)
+{
+	onchange := 0;
+	pick pc := c {
+	Centry =>
+		onchange = pc.onchange;
+		pc.onchange = 0;
+# this code reproduced Navigator 2 bug
+# changes to Select Formfield selection only resulted in onchange event upon
+# loss of focus.  Now handled by domouse() code so event can be raised
+# immediately
+#	Cselect =>
+#		onchange = pc.onchange;
+#		pc.onchange = 0;
+	}
+	if(onchange && (c.ff.evmask & E->SEonchange)) {
+		se := ref E->ScriptEvent(E->SEonchange, c.f.id, c.ff.form.formid, c.ff.fieldid, -1, -1, -1, -1, 1, nil, nil, 0);
+		J->jevchan <-= se;
+	}
+}
+
+blurfocusevent(c: ref Control, kind, raisex: int)
+{
+	if((CU->config).doscripts && c.ff != nil && c.ff.evmask) {
+		if(kind == E->SEonblur)
+			changeevent(c);
+		if (!raisex || !(c.ff.evmask & kind))
+			return;
+		se := ref E->ScriptEvent(kind, c.f.id, c.ff.form.formid, c.ff.fieldid, -1, -1, -1, -1, 0, nil, nil, 0);
+		J->jevchan <-= se;
+	}
+}
+
+Control.losefocus(c: self ref Control, raisex: int)
+{
+	if(c.flags & CFhasfocus) {
+		c.flags &= ~CFhasfocus;
+		if(c.f.cim != nil) {
+			blurfocusevent(c, E->SEonblur, raisex);
+			c.draw(1);
+		}
+	}
+}
+
+Control.gainfocus(c: self ref Control, raisex: int)
+{
+	if(!(c.flags & CFhasfocus)) {
+		c.flags |= CFhasfocus;
+		if(c.f.cim != nil) {
+			blurfocusevent(c, E->SEonfocus, raisex);
+			c.draw(1);
+		}
+		G->clientfocus();
+	}
+}
+
+Control.scrollset(c: self ref Control, v1, v2, vmax, nsteps, draw: int)
+{
+	pick sc := c {
+	Cscrollbar =>
+		if(v1 < 0)
+			v1 = 0;
+		if(v2 > vmax)
+			v2 = vmax;
+		if(v1 > v2)
+			v1 = v2;
+		if(v1 == 0 && v2 == vmax) {
+			sc.mindelta = 1;
+			sc.deltaval = 0;
+			sc.top = 0;
+			sc.bot = 0;
+		}
+		else {
+			length, breadth: int;
+			if(sc.flags&CFscrvert) {
+				length = sc.r.max.y - sc.r.min.y;
+				breadth = sc.r.max.x - sc.r.min.x;
+			}
+			else {
+				length = sc.r.max.x - sc.r.min.x;
+				breadth = sc.r.max.y - sc.r.min.y;
+			}
+			l := length - (2*breadth + MINSCR);
+			if(l < 0)
+				CU->raisex("EXInternal: negative scrollbar trough");
+			sc.top = l*v1/vmax;
+			sc.bot = l*(vmax-v2)/vmax;
+			if (nsteps == 0)
+				sc.mindelta = 1;
+			else
+				sc.mindelta = max(1, length/nsteps);
+			sc.deltaval = max(1, vmax/(l/sc.mindelta))*SCRDELTASF;
+		}
+		if(sc.f.cim != nil && draw)
+			sc.draw(1);
+	}
+}
+
+SPECMASK : con 16rf000;
+CTRLMASK : con 16r1f;
+DEL : con 16r7f;
+TAB : con '\t';
+CR: con '\n';
+
+Control.dokey(ctl: self ref Control, keychar: int) : int
+{
+	if(!(ctl.flags&CFenabled))
+		return CAnone;
+	ans := CAnone;
+	pick c := ctl {
+	Centry =>
+		olds := c.s;
+		slen := len c.s;
+		(sels, sele) := normalsel(c.sel);
+		modified := 0;
+		(osels, osele) := (sels, sele);
+		case keychar {
+			('a' & CTRLMASK) or Keyboard->Home =>
+				(sels, sele) = (0, 0);
+			('e' & CTRLMASK) or Keyboard->End =>
+				(sels, sele) = (slen, slen);
+			'f' & CTRLMASK or Keyboard->Right =>
+				if(sele < slen)
+					(sels, sele) = (sele+1, sele+1);
+			'b' & CTRLMASK or Keyboard->Left =>
+				if(sels > 0)
+					(sels, sele) = (sels-1, sels-1);
+			Keyboard->Up =>
+				if (c.linewrap)
+					sels = sele = entryupdown(c, sels, -1);
+			Keyboard->Down =>
+				if (c.linewrap)
+					sels = sele = entryupdown(c, sele, 1);
+			'u' & CTRLMASK =>
+				entrydelrange(c, 0, slen);
+				modified = 1;
+				(sels, sele) = c.sel;
+			'c' & CTRLMASK =>
+				entrysetsnarf(c);
+			'v' & CTRLMASK =>
+				entryinsertsnarf(c);
+				modified = 1;
+				(sels, sele) = c.sel;
+			'h' & CTRLMASK or DEL=>
+				if (sels != sele) {
+					entrydelrange(c, sels, sele);
+					modified = 1;
+				} else if(sels > 0) {
+					entrydelrange(c, sels-1, sels);
+					modified = 1;
+				}
+				(sels, sele) = c.sel;
+			Keyboard->Del =>
+				if (sels != sele) {
+					entrydelrange(c, sels, sele);
+					modified = 1;
+				} else if(sels < len c.s) {
+					entrydelrange(c, sels, sels+1);
+					modified = 1;
+				}
+				(sels, sele) = c.sel;
+			TAB =>
+				ans = CAtabkey;
+			* =>
+				if ((keychar & SPECMASK) == Keyboard->Spec)
+					# ignore all other special keys
+					break;
+				if(keychar == CR) {
+					if(c.linewrap)
+						keychar = '\n';
+					else
+						ans = CAreturnkey;
+				}
+				if(keychar > CTRLMASK || (keychar == '\n' && c.linewrap)) {
+					if (sels != sele) {
+						entrydelrange(c, sels, sele);
+						(sels, sele) = c.sel;
+					}
+					slen = len c.s;
+					c.s[slen] = 0;	# expand string by 1 char
+					for(k := slen; k > sels; k--)
+						c.s[k] = c.s[k-1];
+					c.s[sels] = keychar;
+					(sels, sele) = (sels+1, sels+1);
+					modified = 1;
+				}
+		}
+		c.sel = (sels, sele);
+		if(osels != sels || osele != sele || modified) {
+			entryscroll(c);
+			c.draw(1);
+		}
+		if (c.s != olds)
+			c.onchange = 1;
+	}
+	return ans;
+}
+
+Control.domouse(ctl: self ref Control, p: Point, mtype: int, oldgrab : ref Control) : (int, ref Control)
+{
+	up := (mtype == E->Mlbuttonup || mtype == E->Mldrop);
+	down := (mtype == E->Mlbuttondown);
+	drag := (mtype == E->Mldrag);
+	hold := (mtype == E->Mhold);
+	move := (mtype == E->Mmove);
+
+	# any button actions stop auto-repeat
+	# it's up to the individual controls to re-instate it
+	if (!move)
+		E->autorepeat(nil, 0, 0);
+
+	if(!(ctl.flags&CFenabled))
+		return (CAnone, nil);
+	ans := CAnone;
+	changed := 0;
+	newgrab : ref Control;
+	grabbed := oldgrab != nil;
+	pick c := ctl {
+	Cbutton =>
+		if(down) {
+			c.flags |= CFactive;
+			newgrab = c;
+			changed = 1;
+		}
+		else if(move && c.ff == nil) {
+			ans = CAflyover;
+		}
+		else if (drag && grabbed) {
+			newgrab = c;
+			active := 0;
+			if (p.in(c.r))
+				active = CFactive;
+			if ((c.flags & CFactive) != active)
+				changed = 1;
+			c.flags = (c.flags & ~CFactive) | active;
+		}
+		else if(up) {
+			if (c.flags & CFactive)
+				ans = CAbuttonpush;
+			c.flags &= ~CFactive;
+			changed = 1;
+		}
+	Centry =>
+		if(c.scr != nil && !grabbed && p.x >= c.r.max.x-SCRFBREADTH) {
+			pick scr := c.scr {
+			Cscrollbar =>
+				return scr.domouse(p, mtype, oldgrab);
+			}
+		}
+		(sels, sele) := c.sel;
+		if(mtype == E->Mlbuttonup && grabbed) {
+			if (sels != sele)
+				ans = CAselected;
+		}
+		if(down || (drag && grabbed)) {
+			newgrab = c;
+			x := c.r.min.x+ENTHMARGIN;
+			fnt := fonts[CtlFnt].f;
+			s := c.s;
+			if(c.flags&CFsecure) {
+				for(i := 0; i < len s; i++)
+					s[i] = '*';
+			}
+			(osels, osele) := c.sel;
+			s1 := " ";
+			i := 0;
+			iend := len s - 1;
+			if(c.linewrap) {
+				(lines, linestarts, topline, cursline) := entrywrapcalc(c);
+				if(len lines > 1) {
+					lineno := topline + (p.y - (c.r.min.y+ENTVMARGIN)) / ctllinespace;
+					lineno = min(lineno, len lines -1);
+					lineno = max(lineno, 0);
+
+					i = linestarts[lineno];
+					iend = i + len lines[lineno] -1;
+				}
+			} else
+				x -= fnt.width(s[:c.left]);
+			for(; i <= iend; i++) {
+				s1[0] = s[i];
+				cx := fnt.width(s1);
+				if(p.x < x + cx)
+					break;
+				x += cx;
+			}
+			sele = i;
+
+			if (down)
+				sels = sele;
+			c.sel = (sels, sele);
+
+			if (sels != osels || sele != osele) {
+				changed = 1;
+				entryscroll(c);
+				if (p.x < c.r.min.x + ENTHMARGIN || p.x > c.r.max.x - ENTHMARGIN
+				|| p.y < c.r.min.y + ENTVMARGIN || p.y > c.r.max.y - ENTVMARGIN) {
+					E->autorepeat(ref (Event.Emouse)(p, mtype), ARTICK, ARTICK);
+				}
+			}
+
+			if(!(c.flags&CFhasfocus))
+				ans = CAkeyfocus;
+		}
+	Ccheckbox=>
+		if(up) {
+			if(c.isradio) {
+				if(!(c.flags&CFactive)) {
+					c.flags |= CFactive;
+					changed = 1;
+					ans = CAbuttonpush;
+					# turn off other radio button
+					frm := c.ff.form;
+					for(lf := frm.fields; lf != nil; lf = tl lf) {
+						ff := hd lf;
+						if(ff == c.ff)
+							continue;
+						if(ff.ftype == Fradio && ff.name==c.ff.name && ff.ctlid >= 0) {
+							d := c.f.controls[ff.ctlid];
+							if(d.flags&CFactive) {
+								d.flags &= ~CFactive;
+								d.draw(1);
+								break;		# at most one other should be on
+							}
+						}
+					}
+				}
+			}
+			else {
+				c.flags ^= CFactive;
+				changed = 1;
+			}
+		}
+	Cselect =>
+		if (c.nvis == 1 && up && c.popup == nil && c.r.contains(p))
+			return (CAdopopup, nil);
+		if(c.scr != nil && (grabbed || p.x >= c.r.max.x-SCRFBREADTH)) {
+			pick scr := c.scr {
+			Cscrollbar =>
+				(a, grab) := scr.domouse(p, mtype, oldgrab);
+				if (grab != nil)
+					grab = c;
+				return (a, grab);
+			}
+			return (ans, nil);
+		}
+		n := (p.y - (c.r.min.y+SELMARGIN))/ctllinespace + c.first;
+		if (n >= c.first && n < c.first+c.nvis) {
+			if ((c.ff.flags&B->FFmultiple) != byte 0) {
+				if (down) {
+					c.options[n].selected ^= 1;
+					changed = 1;
+				}
+			} else if (up || drag) {
+				changed = c.options[n].selected == 0;
+				c.options[n].selected = 1;
+				for(i := 0; i < len c.options; i++) {
+					if(i != n)
+						c.options[i].selected = 0;
+				}
+			}
+		}
+		if (up) {
+			if (c.popup != nil)
+				ans = CAdonepopup;
+			else
+				ans = CAchanged;
+		}
+	Clistbox =>
+		if(c.vscr != nil && (c.grab == c.vscr || (!grabbed && p.x >= c.r.max.x-SCRFBREADTH))) {
+			c.grab = nil;
+			pick vscr := c.vscr {
+			Cscrollbar =>
+				(a, grab) := vscr.domouse(p, mtype, oldgrab);
+				if (grab != nil) {
+					c.grab = c.vscr;
+					grab = c;
+				}
+				return (a, grab);
+			}
+		}
+		else if(c.hscr != nil && (c.grab == c.hscr || (!grabbed && p.y >= c.r.max.y-SCRFBREADTH))) {
+			c.grab = nil;
+			pick hscr := c.hscr {
+			Cscrollbar =>
+				(a, grab) := hscr.domouse(p, mtype, oldgrab);
+				if (grab != nil) {
+					c.grab = c.hscr;
+					grab = c;
+				}
+				return (a, grab);
+			}
+		}
+		else if(up) {
+			fnt := fonts[CtlFnt].f;
+			n := (p.y - (c.r.min.y+SELMARGIN))/fnt.height + c.first;
+			if(n >= 0 && n < len c.options) {
+				c.options[n].selected ^= 1;
+				# turn off other selections
+				for(i := 0; i < len c.options; i++) {
+					if(i != n)
+						c.options[i].selected = 0;
+				}
+				ans = CAchanged;
+				changed = 1;
+			}
+		}
+	Cscrollbar =>
+		val := 0;
+		v, vmin, vmax, b: int;
+		if(c.flags&CFscrvert) {
+			v = p.y;
+			vmin = c.r.min.y;
+			vmax = c.r.max.y;
+			b = c.r.dx();
+		}
+		else {
+			v = p.x;
+			vmin = c.r.min.x;
+			vmax = c.r.max.x;
+			b = c.r.dy();
+		}
+		vsltop := vmin+b+c.top;
+		vslbot := vmax-b-c.bot;
+		actflags := 0;
+		oldactflags := c.flags&CFscrallact;
+
+		if ((down || drag) && !up && !hold)
+			newgrab = c;
+
+		if (down) {
+			newgrab = c;
+			holdval := 0;
+			repeat := 1;
+			if (v >= vsltop && v < vslbot) {
+				holdval = v - vsltop;
+				actflags = CFactive;
+				repeat = 0;
+			}
+			if(v < vmin+b) {
+				holdval = -1;
+				actflags = CFscracta1;
+			}
+			else if(v < vsltop) {
+				holdval = -1;
+				actflags = CFscracttr1;
+			}
+			else if(v >= vmax-b) {
+				holdval = 1;
+				actflags = CFscracta2;
+			}
+			else if(v >= vslbot) {
+				holdval = 1;
+				actflags = CFscracttr2;
+			}
+			c.holdstate = (actflags, holdval);
+			if (repeat) {
+				E->autorepeat(ref (Event.Emouse)(p, E->Mhold), ARPAUSE, ARTICK);
+			}
+		}
+		if (drag) {
+			(actflags, val) = c.holdstate;
+			if (actflags == CFactive) {
+				# dragging main scroll widget (relative to top of drag block)
+				val = (v - vsltop) - val;
+				if(abs(val) >= c.mindelta) {
+					ans = CAscrolldelta;
+					val = (c.deltaval * (val / c.mindelta))/SCRDELTASF;
+				}
+			} else {
+				E->autorepeat(ref (Event.Emouse)(p, E->Mhold), ARTICK, ARTICK);
+			}
+		}
+		if (up || hold) {
+			# set the action according to the hold state
+			# Note: main widget (case CFactive) handled by drag
+			act := 0;
+			(act, val) = c.holdstate;
+			case act {
+			CFscracta1 or
+			CFscracta2 =>
+				ans = CAscrollline;
+			CFscracttr1 or
+			CFscracttr2 =>
+				ans = CAscrollpage;
+			}
+			if (up) {
+				c.holdstate = (0, 0);
+			} else { # hold
+				(actflags, nil) = c.holdstate;
+				if (ans != CAnone) {
+					E->autorepeat(ref (Event.Emouse)(p, E->Mhold), ARTICK, ARTICK);
+					newgrab = c;
+				}
+			}
+		}
+		c.flags = (c.flags & ~CFscrallact) | actflags;
+		if(ans != CAnone) {
+			ftoscroll := c.f;
+			if(c.ctl != nil) {
+				pick cff := c.ctl {
+				Centry =>
+					ny := (cff.r.dy() - 2 * ENTVMARGIN) / ctllinespace;
+					(nil, linestarts, topline, nil) := entrywrapcalc(cff);
+					nlines := len linestarts;
+					case ans {
+					CAscrollpage =>
+						topline += val*ny;
+					CAscrollline =>
+						topline += val;
+					CAscrolldelta =>
+#						# insufficient for large number of lines
+						topline += val;
+#						if(val > 0)
+#							topline++;
+#						else
+#							topline--;
+					}
+					if (topline+ny >= nlines)
+						topline = (nlines-1) - ny;
+					if (topline < 0)
+						topline = 0;
+					cff.left = linestarts[topline];
+					c.scrollset(topline, topline+ny, nlines - 1, nlines, 1);
+					cff.draw(1);
+					return (ans, newgrab);
+				Cselect =>
+					newfirst := cff.first;
+					case ans {
+					CAscrollpage =>
+						newfirst += val*cff.nvis;
+					CAscrollline =>
+						newfirst += val;
+					CAscrolldelta =>
+#						# insufficient for very long select lists
+						newfirst += val;
+#						if(val > 0)
+#							newfirst++;
+#						else
+#							newfirst--;
+					}
+					newfirst = max(0, min(newfirst, len cff.options - cff.nvis));
+					cff.first = newfirst;
+					nopt := len cff.options;
+					c.scrollset(newfirst, newfirst+cff.nvis, nopt, nopt, 0);
+					cff.draw(1);
+					return (ans, newgrab);
+				Clistbox =>
+					if(c.flags&CFscrvert) {
+						newfirst := cff.first;
+						case ans {
+						CAscrollpage =>
+							newfirst += val*cff.nvis;
+						CAscrollline =>
+							newfirst += val;
+						CAscrolldelta =>
+							newfirst += val;
+#							if(val > 0)
+#								newfirst++;
+#							else
+#								newfirst--;
+						}
+						newfirst = max(0, min(newfirst, len cff.options - cff.nvis));
+						cff.first = newfirst;
+						c.scrollset(newfirst, newfirst+cff.nvis, len cff.options, 0, 1);
+						# TODO: need redraw only vscr and content
+					}
+					else {
+						hw := cff.maxcol;
+						w := (c.r.max.x - c.r.min.x - SCRFBREADTH)/charspace;
+						newstart := cff.start;
+						case ans {
+						CAscrollpage =>
+								newstart += val*hw;
+						CAscrollline =>
+								newstart += val;
+						CAscrolldelta =>
+							if(val > 0)
+								newstart++;
+							else
+								newstart--;
+						}
+						if(hw < w)
+							newstart = 0;
+						else
+							newstart = max(0, min(newstart, hw - w));
+						cff.start = newstart;
+						c.scrollset(newstart, w+newstart, hw, 0, 1);
+						# TODO: need redraw only hscr and content
+					}
+					cff.draw(1);
+					return (ans, newgrab);
+				}
+			}
+			else {
+				if(c.flags&CFscrvert)
+					c.f.yscroll(ans, val);
+				else
+					c.f.xscroll(ans, val);
+			}
+			changed = 1;
+		}
+		else if(actflags != oldactflags) {
+			changed = 1;
+		}
+	}
+	if(changed)
+		ctl.draw(1);
+	return (ans, newgrab);
+}
+
+# returns a new popup control
+Control.dopopup(ctl: self ref Control): ref Control
+{
+	sel : ref Control.Cselect;
+	pick c := ctl {
+	Cselect =>
+		if (c.nvis > 1)
+			return nil;
+		sel = c;
+	* =>
+		return nil;
+	}
+
+	w := sel.r.dx();
+	nopt := len sel.options;
+	nvis := min(nopt, POPUPLINES);
+	first := sel.first;
+	if (first + nvis > nopt)
+		first = nopt - nvis;
+	h := ctllinespace*nvis + 2*SELMARGIN;
+	r := Rect(sel.r.min, sel.r.min.add(Point(w, h)));
+	popup := G->getpopup(r);
+	if (popup == nil)
+		return nil;
+	scr : ref Control;
+	if (nvis < nopt) {
+		scr = Control.newscroll(sel.f, 1, h, SCRFBREADTH);
+		scr.r.addpt(Point(w,0));
+	}
+	newsel := ref Control.Cselect(sel.f, sel.ff, r, sel.flags, popup, sel, scr, nvis, first, sel.options);
+	if(scr != nil) {
+		pick pscr := scr {
+		Cscrollbar =>
+			pscr.ctl = newsel;
+		}
+		scr.popup = popup;
+		scr.scrollset(first, first+nvis, nopt, nopt, 0);
+	}
+	newsel.draw(1);
+	return newsel;
+}
+
+# returns original control for which this was a popup
+Control.donepopup(ctl: self ref Control): ref Control
+{
+	owner: ref Control;
+	pick c := ctl {
+	Cselect =>
+		if (c.owner == nil)
+			return nil;
+		owner = c.owner;
+	* =>
+		return nil;
+	}
+	G->cancelpopup();
+	pick c := owner {
+	Cselect =>
+		for (first := 0; first < len c.options; first++)
+			if (c.options[first].selected)
+				break;
+		if (first == len c.options)
+			first = 0;
+		c.first = first;
+	}
+	owner.draw(1);
+	return owner;
+}
+
+
+Control.reset(ctl: self ref Control)
+{
+	pick c := ctl {
+	Cbutton =>
+		c.flags &= ~CFactive;
+	Centry =>
+		c.s = "";
+		c.sel = (0, 0);
+		c.left = 0;
+		if(c.ff != nil && c.ff.value != "")
+			c.s = c.ff.value;
+		if (c.scr != nil)
+			c.scr.scrollset(0, 1, 1, 0, 0);
+	Ccheckbox=>
+		c.flags &= ~CFactive;
+		if(c.ff != nil && (c.ff.flags&B->FFchecked) != byte 0)
+			c.flags |= CFactive;
+	Cselect =>
+		nopt := len c.options;
+		if(c.ff != nil) {
+			l := c.ff.options;
+			for(i := 0; i < nopt; i++) {
+				o := hd l;
+				c.options[i].selected = o.selected;
+				l = tl l;
+			}
+		}
+		c.first = 0;
+		if(c.scr != nil) {
+			c.scr.scrollset(0, c.nvis, nopt, nopt, 0);
+		}
+	Clistbox =>
+		c.first = 0;
+		nopt := len c.options;
+		if(c.vscr != nil) {
+			c.vscr.scrollset(0, c.nvis, nopt, nopt, 0);
+		}
+		hw := 0;
+		for(i := 0; i < len c.options; i++)
+			hw = max(hw, fonts[DefFnt].f.width(c.options[i].display)); 
+		if(c.hscr != nil) {
+			c.hscr.scrollset(0, c.r.max.x, hw, 0, 0); 
+		}
+	Canimimage =>
+		c.cur = 0;
+	}
+	ctl.draw(0);
+}
+
+Control.draw(ctl: self ref Control, flush: int)
+{
+	win := ctl.f.cim;
+	if (ctl.popup != nil)
+		win = ctl.popup.image;
+	if (win == nil)
+		return;
+	oclipr := win.clipr;
+	clipr := oclipr;
+	any: int;
+	if (ctl.popup == nil) {
+		(clipr, any) = ctl.r.clip(ctl.f.cr);
+		if(!any && ctl != ctl.f.vscr && ctl != ctl.f.hscr)
+			return;
+		win.clipr = clipr;
+	}
+	pick c := ctl {
+	Cbutton =>
+		if(c.ff != nil && c.ff.image != nil && c.pic == nil) {
+			# check to see if image arrived
+			# (dimensions will have been set by checkffsize, if needed;
+			# this code is only for when the HTML specified the dimensions)
+			pick imi := c.ff.image {
+			Iimage =>
+				if(imi.ci.mims != nil) {
+					c.pic = imi.ci.mims[0].im;
+					c.picmask = imi.ci.mims[0].mask;
+				}
+			}
+		}
+		if(c.dorelief || c.pic == nil)
+			win.draw(c.r, colorimage(Grey), nil, zp);
+		if(c.pic != nil) {
+			p, m: ref Image;
+			if(c.flags & CFenabled) {
+				p = c.pic;
+				m = c.picmask;
+			}
+			else {
+				p = c.dpic;
+				m = c.dpicmask;
+			}
+			w := p.r.dx();
+			h := p.r.dy();
+			x := c.r.min.x + (c.r.dx() - w) / 2;
+			y := c.r.min.y + (c.r.dy() - h) / 2;
+			if((c.flags & CFactive) && c.dorelief) {
+				x++;
+				y++;
+			}
+			win.draw(Rect((x,y),(x+w,y+h)), p, m, zp);
+		}
+		else if(c.label != "") {
+			p := c.r.min.add(Point(BUTMARGIN, BUTMARGIN));
+			if(c.flags & CFactive)
+				p = p.add(Point(1,1));
+			win.text(p, colorimage(Black), zp, fonts[CtlFnt].f, c.label);
+		}
+		if(c.dorelief) {
+			relief := ReliefRaised;
+			if(c.flags & CFactive)
+				relief = ReliefSunk;
+			drawrelief(win, c.r.inset(2), relief);
+		}
+	Centry =>
+		win.draw(c.r, colorimage(White), nil, zp);
+		insetr := c.r.inset(2);
+		drawrelief(win,insetr, ReliefSunk);
+		eclipr := c.r;
+		eclipr.min.x += ENTHMARGIN;
+		eclipr.max.x -= ENTHMARGIN;
+		eclipr.min.y += ENTVMARGIN;
+		eclipr.max.y -= ENTVMARGIN;
+#		if (c.scr != nil)
+#			eclipr.max.x -= SCRFBREADTH;
+		(eclipr, any) = clipr.clip(eclipr);
+		win.clipr = eclipr;
+		p := c.r.min.add(Point(ENTHMARGIN,ENTVMARGIN));
+		s := c.s;
+		fnt := fonts[CtlFnt].f;
+		if(c.left > 0)
+			s = s[c.left:];
+		if(c.flags&CFsecure) {
+			for(i := 0; i < len s; i++)
+				s[i] = '*';
+		}
+
+		(sels, sele) := normalsel(c.sel);
+		(sels, sele) = (sels-c.left, sele-c.left);
+
+		lines : array of string;
+		linestarts : array of int;
+		textw := c.r.dx()-2*ENTHMARGIN;
+		if (c.scr != nil) {
+			textw -= SCRFBREADTH;
+			c.scr.r = c.scr.r.subpt(c.scr.r.min);
+			c.scr.r = c.scr.r.addpt(Point(insetr.max.x-SCRFBREADTH,insetr.min.y));
+			c.scr.draw(0);
+		}
+		if (c.linewrap)
+			(lines, linestarts) = wrapstring(fnt, s, textw);
+		else
+			(lines, linestarts) = (array [] of {s}, array [] of {0});
+
+		q := p;
+		black := colorimage(Black);
+		white := colorimage(White);
+		navy := colorimage(Navy);
+		nlines := len lines;
+		for (n := 0; n < nlines; n++) {
+			segs : list of (int, int, int);
+			# only show cursor or selection if we have focus
+			if (c.flags & CFhasfocus)
+				segs = selsegs(len lines[n], sels-linestarts[n], sele-linestarts[n]);
+			else
+				segs = (0, len lines[n], 0) :: nil;
+			for (; segs != nil; segs = tl segs) {
+				(ss, se, sel) := hd segs;
+				txt := lines[n][ss:se];
+				w := fnt.width(txt);
+				txtcol : ref Image;
+				if (!sel)
+					txtcol = black;
+				else {
+					txtcol = white;
+					bgcol := navy;
+					if (n < nlines-1 && sele >= linestarts[n+1])
+						w = (p.x-q.x) + textw;
+					selr := Rect((q.x, q.y-1), (q.x+w, q.y+ctllinespace+1));
+					if (selr.dx() == 0) {
+						# empty selection - assume cursor
+						bgcol = black;
+						selr.max.x = selr.min.x + 2;
+					}
+					win.draw(selr, bgcol, nil, zp);
+				}
+				if (se > ss)
+					win.text(q, txtcol, zp, fnt, txt);
+				q.x += w;
+			}
+			q = (p.x, q.y + ctllinespace);
+		}
+	Ccheckbox=>
+		win.draw(c.r, colorimage(White), nil, zp);
+		if(c.isradio) {
+			a := CBOXHT/2;
+			a1 := a-1;
+			cen := Point(c.r.min.x+a,c.r.min.y+a);
+			win.ellipse(cen, a1, a1, 1, colorimage(DarkGrey), zp);
+			win.arc(cen, a, a, 0, colorimage(Black), zp, 45, 180);
+			win.arc(cen, a, a, 0, colorimage(Grey), zp, 225, 180);
+			if(c.flags&CFactive)
+				win.fillellipse(cen, 2, 2, colorimage(Black), zp);
+		}
+		else {
+			ir := c.r.inset(2);
+			ir.min.x += CBOXWID-CBOXHT;
+			ir.max.x -= CBOXWID-CBOXHT;
+			drawrelief(win, ir, ReliefSunk);
+			if(c.flags&CFactive) {
+				p1 := Point(ir.min.x, ir.min.y);
+				p2 := Point(ir.max.x, ir.max.y);
+				p3 := Point(ir.max.x, ir.min.y);
+				p4 := Point(ir.min.x, ir.max.y);
+				win.line(p1, p2, D->Endsquare, D->Endsquare, 0, colorimage(Black), zp);
+				win.line(p3, p4, D->Endsquare, D->Endsquare, 0, colorimage(Black), zp);
+			}
+		}
+	Cselect =>
+		black := colorimage(Black);
+		white := colorimage(White);
+		navy := colorimage(Navy);
+		win.draw(c.r, white, nil, zp);
+		drawrelief(win, c.r.inset(2), ReliefSunk);
+		ir := c.r.inset(SELMARGIN);
+		p := ir.min;
+		fnt := fonts[CtlFnt].f;
+		drawsel := c.nvis > 1;
+		for(i := c.first; i < len c.options && i < c.first+c.nvis; i++) {
+			if(drawsel && c.options[i].selected) {
+				maxx := ir.max.x;
+				if (c.scr != nil)
+					maxx -= SCRFBREADTH;
+				r := Rect((p.x-SELMARGIN,p.y),(maxx,p.y+ctllinespace));
+				win.draw(r, navy, nil, zp);
+				win.text(p, white, zp, fnt, c.options[i].display);
+			}
+			else {
+				win.text(p, black, zp, fnt, c.options[i].display);
+			}
+			p.y += ctllinespace;
+		}
+		if (c.nvis == 1 && len c.options > 1) {
+			# drop down select list - draw marker (must be same width as scroll bar)
+			r := Rect((ir.max.x - SCRFBREADTH, ir.min.y), ir.max);
+			drawtriangle(win, r, TRIdown, ReliefRaised);
+		} 
+		if(c.scr != nil) {
+			c.scr.r = Rect((ir.max.x - SCRFBREADTH, ir.min.y), ir.max);
+			c.scr.draw(0);
+		}
+	Clistbox =>
+		black := colorimage(Black);
+		white := colorimage(White);
+		navy := colorimage(Navy);
+		win.draw(c.r, white, nil, zp);
+		insetr := c.r.inset(2);
+		#drawrelief(win, c.r.inset(2), ReliefSunk);
+		ir := c.r.inset(SELMARGIN);
+		p := ir.min;
+		fnt := fonts[CtlFnt].f;
+		for(i := c.first; i < len c.options && i < c.first+c.nvis; i++) {
+			txt := "";
+			if (c.start < len c.options[i].display)
+				txt = c.options[i].display[c.start:];
+			if(c.options[i].selected) {
+				r := Rect((p.x-SELMARGIN,p.y),(c.r.max.x-SCRFBREADTH,p.y+fnt.height));
+				win.draw(r, navy, nil, zp);
+				win.text(p, white, zp, fnt, txt);
+			}
+			else {
+ 				win.text(p, black, zp, fnt, txt);
+			}
+			p.y +=fnt.height;
+		}
+		if(c.vscr != nil) {
+			c.vscr.r = c.vscr.r.subpt(c.vscr.r.min);
+			c.vscr.r = c.vscr.r.addpt(Point(insetr.max.x-SCRFBREADTH,insetr.min.y));
+			c.vscr.draw(0);
+ 		}
+ 		if(c.hscr != nil) {
+			c.hscr.r = c.hscr.r.subpt(c.hscr.r.min);
+			c.hscr.r = c.hscr.r.addpt(Point(insetr.min.x, insetr.max.y-SCRFBREADTH));
+ 			c.hscr.draw(0);
+		}
+		drawrelief(win, insetr, ReliefSunk);
+
+	Cscrollbar =>
+		# Scrollbar components: arrow 1 (a1), trough 1 (t1), slider (s), trough 2 (t2), arrow 2 (a2)
+		x := c.r.min.x;
+		y := c.r.min.y;
+		ra1, rt1, rs, rt2, ra2: Rect;
+		b, l, a1kind, a2kind: int;
+		if(c.flags&CFscrvert) {
+			l = c.r.max.y - c.r.min.y;
+			b = c.r.max.x - c.r.min.x;
+			xr := x+b;
+			yt1 := y+b;
+			ys := yt1+c.top;
+			yb := y+l;
+			ya2 := yb-b;
+			yt2 := ya2-c.bot;
+			ra1 = Rect(Point(x,y),Point(xr,yt1));
+			rt1 = Rect(Point(x,yt1),Point(xr,ys));
+			rs = Rect(Point(x,ys),Point(xr,yt2));
+			rt2 = Rect(Point(x,yt2),Point(xr,ya2));
+			ra2 = Rect(Point(x,ya2),Point(xr,yb));
+			a1kind = TRIup;
+			a2kind = TRIdown;
+		}
+		else {
+			l = c.r.max.x - c.r.min.x;
+			b = c.r.max.y - c.r.min.y;
+			yb := y+b;
+			xt1 := x+b;
+			xs := xt1+c.top;
+			xr := x+l;
+			xa2 := xr-b;
+			xt2 := xa2-c.bot;
+			ra1 = Rect(Point(x,y),Point(xt1,yb));
+			rt1 = Rect(Point(xt1,y),Point(xs,yb));
+			rs = Rect(Point(xs,y),Point(xt2,yb));
+			rt2 = Rect(Point(xt2,y),Point(xa2,yb));
+			ra2 = Rect(Point(xa2,y),Point(xr,yb));
+			a1kind = TRIleft;
+			a2kind = TRIright;
+		}
+		a1relief := ReliefRaised;
+		if(c.flags&CFscracta1)
+			a1relief = ReliefSunk;
+		a2relief := ReliefRaised;
+		if(c.flags&CFscracta2)
+			a2relief = ReliefSunk;
+		drawtriangle(win, ra1, a1kind, a1relief);
+		drawtriangle(win, ra2, a2kind, a2relief);
+		drawfill(win, rt1, Grey);
+		rs = rs.inset(2);
+		drawfill(win, rs, Grey);
+		rsrelief := ReliefRaised;
+		if(c.flags&CFactive)
+			rsrelief = ReliefSunk;
+		drawrelief(win, rs, rsrelief);
+		drawfill(win, rt2, Grey);
+	Canimimage =>
+		i := c.cur;
+		if(c.redraw)
+			i = 0;
+		else if(i > 0) {
+			iprev := i-1;
+			if(c.cim.mims[iprev].bgcolor != -1) {
+				i = iprev;
+				# get i back to before all "reset to previous"
+				# images (which will be skipped in following
+				# image drawing loop)
+				while(i > 0 && c.cim.mims[i].bgcolor == -2)
+					i--;
+			}
+		}
+		bgi := colorimage(c.bg.color);
+		if(c.bg.image != nil && c.bg.image.ci != nil && len c.bg.image.ci.mims > 0)
+			bgi = c.bg.image.ci.mims[0].im;
+		for( ; i <= c.cur; i++) {
+			mim := c.cim.mims[i];
+			if(i > 0 && i < c.cur && mim.bgcolor == -2)
+				continue;
+			p := c.r.min.add(mim.origin);
+			r := mim.im.r;
+			r = Rect(p, p.add(Point(r.dx(), r.dy())));
+
+			# IE takes "clear-to-background" disposal method to mean
+			# clear to background of HTML page, ignoring any background
+			# color specified in the GIF.
+			# IE clears to background before frame 0
+			if(i == 0)
+				win.draw(c.r, bgi, nil, zp);
+
+			if(i != c.cur && mim.bgcolor >= 0)
+				win.draw(r, bgi, nil, zp);
+			else
+				win.draw(r, mim.im, mim.mask, zp);
+		}
+	Clabel =>
+		p := c.r.min.add(Point(0,ENTVMARGIN));
+		win.text(p, colorimage(Black), zp, fonts[DefFnt].f, c.s);
+	}
+	if(flush) {
+		if (ctl.popup != nil)
+			ctl.popup.flush(ctl.r);
+		else
+			G->flush(ctl.r);
+	}
+	win.clipr = oclipr;
+}
+
+# Break s up into substrings that fit in width availw
+# when printing with font fnt.
+# The second returned array contains the indexes into the original
+# string where the corresponding line starts (which might not be simply
+# the sum of the preceding lines because of cr/lf's in the original string
+# which are omitted from the lines array.
+# Empty lines (ending in cr) get put into the array as empty strings.
+# The start indices array has an entry for the phantom next line, to avoid
+# the need for special cases in the rest of the code.
+wrapstring(fnt: ref Font, s: string, availw: int) : (array of string, array of int)
+{
+	sl : list of (string, int) = nil;
+	sw := fnt.width(s);
+	n := 0;
+	k := 0;	# index into original s where current s starts
+	origlen := len s;
+	done := 0;
+	while(!done) {
+		kincr := 0;
+		s1, s2: string;
+		if(s == "") {
+			s1 = s;
+			done = 1;
+		}
+		else {
+			# if any newlines in s1, it's a forced break
+			# (and newlines aren't to appear in result)
+			(s1, s2) = S->splitl(s, "\n");
+			if(s2 != nil && fnt.width(s1) <= availw) {
+				s = s2[1:];
+				sw = fnt.width(s);
+				kincr = (len s1) + 1;
+			}
+			else if(sw <= availw) {
+				s1 = s;
+				done = 1;
+			}
+			else {
+				(s1, nil, s, sw) = breakstring(s, sw, fnt, availw, 0);
+				kincr = len s1;
+				if(s == "")
+					done = 1;
+			}
+		}
+		sl = (s1, k) :: sl;
+		k += kincr;
+		n++;
+	}
+	# reverse sl back to original order
+	lines := array[n] of string;
+	linestarts := array[n+1] of int;
+	linestarts[n] = origlen;
+	while(sl != nil) {
+		(ss, nn) := hd sl;
+		lines[--n] = ss;
+		linestarts[n] = nn;
+		sl = tl sl;
+	}
+	return (lines, linestarts);
+}
+
+normalsel(sel : (int, int)) : (int, int)
+{
+	(s, e) := sel;
+	if (s > e)
+		(e, s) = sel;
+	return (s, e);
+}
+
+selsegs(n, s, e : int) : list of (int, int, int)
+{
+	if (e < 0 || s > n)
+		# selection is not in 0..n
+		return (0, n, 0) :: nil;
+
+	if (e > n) {
+		# second half of string is selected
+		if (s <= 0)
+			return (0, n, 1) :: nil;
+		return (0, s, 0) :: (s, n, 1) :: nil;
+	}
+
+	if (s < 0) {
+		# first half of string is selected
+		if (e >= n)
+			return (0, n, 1) :: nil;
+		return (0, e, 1) :: (e, n, 0) :: nil;
+	}
+	# middle section of string is selected
+	return (0, s, 0) :: (s, e, 1) :: (e, n, 0) :: nil;
+}
+
+# Figure out in which area of scrollbar, if any, p lies.
+# Then use p and mtype from mouse event to return desired action.
+Control.entryset(c: self ref Control, s: string)
+{
+	pick e := c {
+	Centry =>
+		e.s = s;
+		e.sel = (0, 0);
+		e.left = 0;
+		# calculate scroll bar settings
+		if (e.linewrap && e.scr != nil) {
+			(lines, nil, nil, nil) := entrywrapcalc(e);
+			nlines := len lines;
+			ny := (e.r.dy() - 2 * ENTVMARGIN)/ctllinespace;
+			e.scr.scrollset(0, ny, (nlines - 1), nlines, 0);
+		}
+	}
+}
+
+entryupdown(e: ref Control.Centry, cur : int, delta : int) : int
+{
+	e.sel = (cur, cur);
+	(lines, linestarts, topline, cursline) := entrywrapcalc(e);
+	newl := cursline + delta;
+	if (newl < 0 || newl >= len lines)
+		return cur;
+
+	fnt := fonts[CtlFnt].f;
+	x := cur - linestarts[cursline];
+	w := fnt.width(lines[cursline][0:x]);
+	l := lines[newl];
+	if (len l == 0)
+		return linestarts[newl];
+	prevw := fnt.width(l);
+	curw := prevw;
+	for (ix := len l - 1; ix > 0 ; ix--) {
+		prevw = curw;
+		curw = fnt.width(l[:ix]);
+		if (curw < w)
+			break;
+	}
+	# decide on closest (curw <= w <= prevw)
+	if (prevw-w <= w - curw)
+		# closer to rhs
+		ix++;
+	return linestarts[newl]+ix;
+}
+
+# delete given range of characters, and redraw
+entrydelrange(e: ref Control.Centry, istart, iend: int)
+{
+	n := iend - istart;
+	(sels, sele) := normalsel(e.sel);
+	if(n > 0) {
+		e.s = e.s[0:istart] + e.s[iend:];
+
+		if(sels > istart) {
+			if(sels < iend)
+				sels = istart;
+			else
+				sels -= n;
+		}
+		if (sele > istart) {
+			if (sele < iend)
+				sele = istart;
+			else
+				sele -= n;
+		}
+
+		if(e.left > istart)
+			e.left = max(istart-1, 0);
+		e.sel = (sels, sele);
+		entryscroll(e);
+	}
+}
+
+snarf : string;
+entrysetsnarf(e: ref Control.Centry)
+{
+	if (e.s == nil)
+		return;
+	s := e.s;
+	(sels, sele) := normalsel(e.sel);
+	if (sels != sele)
+		s = e.s[sels:sele];
+		
+	f := sys->open("/chan/snarf", sys->OWRITE);
+	if (f == nil)
+		snarf = s;
+	else {
+		data := array of byte s;
+		sys->write(f, data, len data);
+	}
+}
+
+entryinsertsnarf(e: ref Control.Centry)
+{
+	f := sys->open("/chan/snarf", sys->OREAD);
+	if(f != nil) {
+		buf := array[sys->ATOMICIO] of byte;
+		n := sys->read(f, buf, len buf);
+		if(n > 0) {
+			# trim a trailing newline, as a service...
+			if(buf[n-1] == byte '\n')
+				n--;
+		}
+		snarf = "";
+		if (n > 0)
+			snarf = string buf[:n];
+	}
+
+	if (snarf != nil) {
+		(sels, sele) := normalsel(e.sel);
+		if (sels != sele) {
+			entrydelrange(e, sels, sele);
+			(sels, sele) = e.sel;
+		}
+		lhs, rhs : string;
+		if (sels > 0)
+			lhs = e.s[:sels];
+		if (sels < len e.s)
+			rhs  = e.s[sels:];
+		e.entryset(lhs + snarf + rhs);
+		e.sel = (len lhs, len lhs + len snarf);
+	}
+}
+
+# make sure can see cursor and following char or two
+entryscroll(e: ref Control.Centry)
+{
+	s := e.s;
+	slen := len s;
+	if(e.flags&CFsecure) {
+		for(i := 0; i < slen; i++)
+			s[i] = '*';
+	}
+	if(e.linewrap) {
+		# For multiple line entries, c.left is the char
+		# at the beginning of the topmost visible line,
+		# and we just want to scroll to make sure that
+		# the line with the cursor is visible
+		(lines, linestarts, topline, cursline) := entrywrapcalc(e);
+		vislines := (e.r.dy()-2*ENTVMARGIN) / ctllinespace;
+		nlines := len linestarts;
+		if(cursline < topline)
+			topline = cursline;
+		else {
+			if(cursline >= topline+vislines)
+				topline = cursline-vislines+1;
+			if (topline + vislines >= nlines)
+				topline = max(0, (nlines-1) - vislines);
+		}
+		e.left = linestarts[topline];
+		if (e.scr != nil)
+			e.scr.scrollset(topline, topline+vislines, nlines-1, nlines, 1);
+	}
+	else {
+		(nil, sele) := e.sel;
+		# sele is always the drag point
+		if(sele < e.left)
+			e.left = sele;
+		else if(sele > e.left) {
+			fnt := fonts[CtlFnt].f;
+			wantw := e.r.dx() -2*ENTHMARGIN; # - 2*ctlspspace;
+			while(e.left < sele-1) {
+				w := fnt.width(e.s[e.left:sele]);
+				if(w < wantw)
+					break;
+				e.left++;
+			}
+		}
+	}
+}
+
+# Given e, a Centry with line wrapping,
+# return (wrapped lines, line start indices, line# of top displayed line, line# containing cursor).
+entrywrapcalc(e: ref Control.Centry) : (array of string, array of int, int, int)
+{
+	s := e.s;
+	if(e.flags&CFsecure) {
+		for(i := 0; i < len s; i++)
+			s[i] = '*';
+	}
+	(nil, sele) := e.sel;
+	textw := e.r.dx()-2*ENTHMARGIN;
+	if (e.scr != nil)
+		textw -= SCRFBREADTH;
+	(lines, linestarts) := wrapstring(fonts[CtlFnt].f, s, textw);
+	topline := 0;
+	cursline := 0;
+	for(i := 0; i < len lines; i++) {
+		s = lines[i];
+		i1 := linestarts[i];
+		i2 := linestarts[i+1];
+		if(e.left >= i1 && e.left < i2)
+			topline = i;
+		if(sele >= i1 && sele < i2)
+			cursline = i;
+	}
+	if(sele == linestarts[len lines])
+		cursline = len lines - 1;
+	return (lines, linestarts, topline, cursline);
+}
+
+Lay.new(targwidth: int, just: byte, margin: int, bg: Background) : ref Lay
+{
+	ans := ref Lay(Line.new(), Line.new(),
+			targwidth, 0, 0, margin, nil, bg, just, byte 0);
+	if(ans.targetwidth < 0)
+		ans.targetwidth = 0;
+	ans.start.pos = Point(margin, margin);
+	ans.start.next = ans.end;
+	ans.end.prev = ans.start;
+	# dummy item at end so ans.end will have correct y coord
+	it := Item.newspacer(ISPnull, 0);
+	it.state = IFbrk|IFcleft|IFcright;
+	ans.end.items = it;
+	return ans;
+}
+
+Line.new() : ref Line
+{
+	return ref Line(
+			nil, nil, nil,	# items, next, prev
+			zp,		# pos
+			0, 0, 0,	# width, height, ascent
+			byte 0);	# flags
+}
+
+Loc.new() : ref Loc
+{
+	return ref Loc(array[10] of Locelem, 0, zp);	# le, n, pos
+}
+
+Loc.add(loc: self ref Loc, kind: int, pos: Point)
+{
+	if(loc.n == len loc.le) {
+		newa := array[len loc.le + 10] of Locelem;
+		newa[0:] = loc.le;
+		loc.le = newa;
+	}
+	loc.le[loc.n].kind = kind;
+	loc.le[loc.n].pos = pos;
+	loc.n++;
+}
+
+# return last frame in loc's path
+Loc.lastframe(loc: self ref Loc) : ref Frame
+{
+	if (loc == nil)
+		return nil;
+	for(i := loc.n-1; i >=0; i--)
+		if(loc.le[i].kind == LEframe)
+			return loc.le[i].frame;
+	return nil;
+}
+
+Loc.print(loc: self ref Loc, msg: string)
+{
+	sys->print("%s: Loc with %d components, pos=(%d,%d)\n", msg, loc.n, loc.pos.x, loc.pos.y);
+	for(i := 0; i < loc.n; i++) {
+		case loc.le[i].kind {
+		LEframe =>
+			sys->print("frame %x\n",  loc.le[i].frame);
+		LEline =>
+			sys->print("line %x\n", loc.le[i].line);
+		LEitem =>
+			sys->print("item: %x", loc.le[i].item);
+			loc.le[i].item.print();
+		LEtablecell =>
+			sys->print("tablecell: %x, cellid=%d\n", loc.le[i].tcell, loc.le[i].tcell.cellid);
+		LEcontrol =>
+			sys->print("control %x\n", loc.le[i].control);
+		}
+	}
+}
+
+Sources.new(m : ref Source) : ref Sources
+{
+	srcs := ref Sources;
+	srcs.main = m;
+	return srcs;
+}
+
+Sources.add(srcs: self ref Sources, s: ref Source, required: int)
+{
+	if (required) {
+		CU->assert(srcs.reqd == nil);
+		srcs.reqd = s;
+	} else
+		srcs.srcs = s :: srcs.srcs;
+}
+
+Sources.done(srcs: self ref Sources, s: ref Source)
+{
+	if (s == srcs.main) {
+		if (srcs.reqd != nil) {
+			sys->print("FREEING MAIN WHEN REQD != nil\n");
+			if (s.bs == nil)
+				sys->print("s.bs == nil\n");
+			else
+				sys->print("main.eof = %d main.lim = %d, main.edata = %d\n", s.bs.eof, s.bs.lim, s.bs.edata);
+		}
+		srcs.main = nil;
+	}
+	else if (s == srcs.reqd)
+		srcs.reqd = nil;
+	else {
+		new : list of ref Source;
+		for (old := srcs.srcs; old != nil; old = tl old) {
+			src := hd old;
+			if (src == s)
+				continue;
+			new = src :: new;
+		}
+		srcs.srcs = new;
+	}
+}
+
+Sources.waitsrc(srcs: self ref Sources) : ref Source
+{
+	if (srcs == nil)
+		return nil;
+
+	bsl : list of ref ByteSource;
+
+	if (srcs.reqd == nil && srcs.main != nil) {
+		pick s := srcs.main {
+		Shtml =>
+			if (s.itsrc.toks != nil || s.itsrc.reqddata != nil)
+				return s;
+		}
+	}
+
+	# always check for subordinates
+	for (sl := srcs.srcs; sl != nil; sl = tl sl)
+		bsl = (hd sl).bs :: bsl;
+	# reqd is taken in preference to main source as main
+	# cannot be processed until we have the whole of reqd
+	if (srcs.reqd != nil)
+		bsl = srcs.reqd.bs :: bsl;
+	else if (srcs.main != nil)
+		bsl = srcs.main.bs :: bsl;
+	if (bsl == nil)
+		return nil;
+	bs : ref ByteSource;
+	for (;;) {
+		bs = CU->waitreq(bsl);
+		if (srcs.reqd == nil || srcs.reqd.bs != bs)
+			break;
+		# only interested in reqd if we have got it all
+		if (bs.err != "" || bs.eof)
+			return srcs.reqd;
+	}
+	if (srcs.main != nil && srcs.main.bs == bs)
+		return srcs.main;
+	found : ref Source;
+	for(sl = srcs.srcs; sl != nil; sl = tl sl) {
+		s := hd sl;
+		if(s.bs == bs) {
+			found = s;
+			break;
+		}
+	}
+	CU->assert(found != nil);
+	return found;
+}
+
+# spawned to animate images in frame f
+animproc(f: ref Frame)
+{
+	f.animpid = sys->pctl(0, nil);
+	aits : list of ref Item = nil;
+	# let del be millisecs to sleep before next frame change
+	del := 10000000;
+	d : int;
+	for(il := f.doc.images; il != nil; il = tl il) {
+		it := hd il;
+		pick i := it {
+		Iimage =>
+			ms := i.ci.mims;
+			if(len ms > 1) {
+				loc := f.find(zp, it);
+				if(loc == nil) {
+					# could be background, I suppose -- don't animate it
+					if(dbg)
+						sys->print("couldn't find item for animated image\n");
+					continue;
+				}
+				p := loc.le[loc.n-1].pos;
+				p.x += int i.hspace + int i.border;
+				# BUG: should get background from least enclosing layout
+				ctl := Control.newanimimage(f, i.ci, f.layout.background);
+				ctl.r = ctl.r.addpt(p);
+				i.ctlid = f.addcontrol(ctl);
+				d = ms[0].delay;
+				if(dbg)
+					sys->print("added anim ctl %d for image %s, initial delay %d\n",
+						i.ctlid, i.ci.src.tostring(), d);
+				aits = it :: aits;
+				if(d < del)
+					del = d;
+			}
+		}
+	}
+	if(aits == nil)
+		return;
+	tot := big 0;
+	for(;;) {
+		sys->sleep(del);
+		tot = tot + big del;
+		newdel := 10000000;
+		for(al := aits; al != nil; al = tl al) {
+			it := hd al;
+			pick i := hd al {
+			Iimage =>
+				ms := i.ci.mims;
+				pick c := f.controls[i.ctlid] {
+				Canimimage =>
+					m := ms[c.cur];
+					d = m.delay;
+					if(d > 0)
+						d -= int (tot - c.ts);
+					if(d == 0) {
+						# advance to next frame and show it
+						c.cur++;
+						if(c.cur == len ms)
+							c.cur = 0;
+						d = ms[c.cur].delay;
+						c.ts = tot;
+						c.draw(1);
+					}
+					if(d < newdel)
+						newdel = d;
+				}
+			}
+		}
+		del = newdel;
+	}
+}