src/cmd/acme/dat.h - plan9 - Git at Google

 enum
 {
 	Qdir,
 	Qacme,
 	Qcons,
 	Qconsctl,
 	Qdraw,
 	Qeditout,
 	Qindex,
 	Qlabel,
 	Qnew,

 	QWaddr,
 	QWbody,
 	QWctl,
 	QWdata,
 	QWeditout,
 	QWerrors,
 	QWevent,
 	QWrdsel,
 	QWwrsel,
 	QWtag,
 	QWxdata,
 	QMAX
 };

 enum
 {
 	Blockincr =	256,
 	Maxblock = 	8*1024,
 	NRange =		10,
 	Infinity = 		0x7FFFFFFF	/* huge value for regexp address */
 };

 #define Buffer AcmeBuffer
 typedef	struct	Block Block;
 typedef	struct	Buffer Buffer;
 typedef	struct	Command Command;
 typedef	struct	Column Column;
 typedef	struct	Dirlist Dirlist;
 typedef	struct	Dirtab Dirtab;
 typedef	struct	Disk Disk;
 typedef	struct	Expand Expand;
 typedef	struct	Fid Fid;
 typedef	struct	File File;
 typedef	struct	Elog Elog;
 typedef	struct	Mntdir Mntdir;
 typedef	struct	Range Range;
 typedef	struct	Rangeset Rangeset;
 typedef	struct	Reffont Reffont;
 typedef	struct	Row Row;
 typedef	struct	Runestr Runestr;
 typedef	struct	Text Text;
 typedef	struct	Timer Timer;
 typedef	struct	Window Window;
 typedef	struct	Xfid Xfid;

 struct Runestr
 {
 	Rune	*r;
 	int	nr;
 };

 struct Range
 {
 	int	q0;
 	int	q1;
 };

 struct Block
 {
 	uint		addr;	/* disk address in bytes */
 	union
 	{
 		uint	n;		/* number of used runes in block */
 		Block	*next;	/* pointer to next in free list */
 	} u;
 };

 struct Disk
 {
 	int		fd;
 	uint		addr;	/* length of temp file */
 	Block	*free[Maxblock/Blockincr+1];
 };

 Disk*	diskinit(void);
 Block*	disknewblock(Disk*, uint);
 void		diskrelease(Disk*, Block*);
 void		diskread(Disk*, Block*, Rune*, uint);
 void		diskwrite(Disk*, Block**, Rune*, uint);

 struct Buffer
 {
 	uint	nc;
 	Rune	*c;			/* cache */
 	uint	cnc;			/* bytes in cache */
 	uint	cmax;		/* size of allocated cache */
 	uint	cq;			/* position of cache */
 	int		cdirty;	/* cache needs to be written */
 	uint	cbi;			/* index of cache Block */
 	Block	**bl;		/* array of blocks */
 	uint	nbl;			/* number of blocks */
 };
 void		bufinsert(Buffer*, uint, Rune*, uint);
 void		bufdelete(Buffer*, uint, uint);
 uint		bufload(Buffer*, uint, int, int*);
 void		bufread(Buffer*, uint, Rune*, uint);
 void		bufclose(Buffer*);
 void		bufreset(Buffer*);

 struct Elog
 {
 	short	type;		/* Delete, Insert, Filename */
 	uint		q0;		/* location of change (unused in f) */
 	uint		nd;		/* number of deleted characters */
 	uint		nr;		/* # runes in string or file name */
 	Rune		*r;
 };
 void	elogterm(File*);
 void	elogclose(File*);
 void	eloginsert(File*, int, Rune*, int);
 void	elogdelete(File*, int, int);
 void	elogreplace(File*, int, int, Rune*, int);
 void	elogapply(File*);

 struct File
 {
 	Buffer	b;			/* the data */
 	Buffer	delta;	/* transcript of changes */
 	Buffer	epsilon;	/* inversion of delta for redo */
 	Buffer	*elogbuf;	/* log of pending editor changes */
 	Elog		elog;		/* current pending change */
 	Rune		*name;	/* name of associated file */
 	int		nname;	/* size of name */
 	uvlong	qidpath;	/* of file when read */
 	ulong		mtime;	/* of file when read */
 	int		dev;		/* of file when read */
 	int		unread;	/* file has not been read from disk */
 	int		editclean;	/* mark clean after edit command */

 	int		seq;		/* if seq==0, File acts like Buffer */
 	int		mod;
 	Text		*curtext;	/* most recently used associated text */
 	Text		**text;	/* list of associated texts */
 	int		ntext;
 	int		dumpid;	/* used in dumping zeroxed windows */
 };
 File*		fileaddtext(File*, Text*);
 void		fileclose(File*);
 void		filedelete(File*, uint, uint);
 void		filedeltext(File*, Text*);
 void		fileinsert(File*, uint, Rune*, uint);
 uint		fileload(File*, uint, int, int*);
 void		filemark(File*);
 void		filereset(File*);
 void		filesetname(File*, Rune*, int);
 void		fileundelete(File*, Buffer*, uint, uint);
 void		fileuninsert(File*, Buffer*, uint, uint);
 void		fileunsetname(File*, Buffer*);
 void		fileundo(File*, int, uint*, uint*);
 uint		fileredoseq(File*);

 enum	/* Text.what */
 {
 	Columntag,
 	Rowtag,
 	Tag,
 	Body
 };

 struct Text
 {
 	File		*file;
 	Frame	fr;
 	Reffont	*reffont;
 	uint	org;
 	uint	q0;
 	uint	q1;
 	int	what;
 	int	tabstop;
 	Window	*w;
 	Rectangle scrollr;
 	Rectangle lastsr;
 	Rectangle all;
 	Row		*row;
 	Column	*col;

 	uint	iq1;	/* last input position */
 	uint	eq0;	/* start of typing for ESC */
 	uint	cq0;	/* cache position */
 	int		ncache;	/* storage for insert */
 	int		ncachealloc;
 	Rune	*cache;
 	int	nofill;
 	int	needundo;
 };

 uint		textbacknl(Text*, uint, uint);
 uint		textbsinsert(Text*, uint, Rune*, uint, int, int*);
 int		textbswidth(Text*, Rune);
 int		textclickhtmlmatch(Text*, uint*, uint*);
 int		textclickmatch(Text*, int, int, int, uint*);
 void		textclose(Text*);
 void		textcolumnate(Text*, Dirlist**, int);
 void		textcommit(Text*, int);
 void		textconstrain(Text*, uint, uint, uint*, uint*);
 void		textdelete(Text*, uint, uint, int);
 void		textdoubleclick(Text*, uint*, uint*);
 void		textfill(Text*);
 void		textframescroll(Text*, int);
 void		textinit(Text*, File*, Rectangle, Reffont*, Image**);
 void		textinsert(Text*, uint, Rune*, uint, int);
 int		textload(Text*, uint, char*, int);
 Rune		textreadc(Text*, uint);
 void		textredraw(Text*, Rectangle, Font*, Image*, int);
 void		textreset(Text*);
 int		textresize(Text*, Rectangle, int);
 void		textscrdraw(Text*);
 void		textscroll(Text*, int);
 void		textselect(Text*);
 int		textselect2(Text*, uint*, uint*, Text**);
 int		textselect23(Text*, uint*, uint*, Image*, int);
 int		textselect3(Text*, uint*, uint*);
 void		textsetorigin(Text*, uint, int);
 void		textsetselect(Text*, uint, uint);
 void		textshow(Text*, uint, uint, int);
 void		texttype(Text*, Rune);

 struct Window
 {
 	QLock	lk;
 	Ref	ref;
 	Text		tag;
 	Text		body;
 	Rectangle	r;
 	uchar	isdir;
 	uchar	isscratch;
 	uchar	filemenu;
 	uchar	dirty;
 	uchar	autoindent;
 	uchar	showdel;
 	int		id;
 	Range	addr;
 	Range	limit;
 	uchar	nopen[QMAX];
 	uchar	nomark;
 	Range	wrselrange;
 	int		rdselfd;
 	Column	*col;
 	Xfid		*eventx;
 	char		*events;
 	int		nevents;
 	int		owner;
 	int		maxlines;
 	Dirlist	**dlp;
 	int		ndl;
 	int		putseq;
 	int		nincl;
 	Rune		**incl;
 	Reffont	*reffont;
 	QLock	ctllock;
 	uint		ctlfid;
 	char		*dumpstr;
 	char		*dumpdir;
 	int		dumpid;
 	int		utflastqid;
 	int		utflastboff;
 	int		utflastq;
 	int		tagsafe;		/* taglines is correct */
 	int		tagexpand;
 	int		taglines;
 	Rectangle	tagtop;
 	QLock	editoutlk;
 };

 void	wininit(Window*, Window*, Rectangle);
 void	winlock(Window*, int);
 void	winlock1(Window*, int);
 void	winunlock(Window*);
 void	wintype(Window*, Text*, Rune);
 void	winundo(Window*, int);
 void	winsetname(Window*, Rune*, int);
 void	winsettag(Window*);
 void	winsettag1(Window*);
 void	wincommit(Window*, Text*);
 int	winresize(Window*, Rectangle, int, int);
 void	winclose(Window*);
 void	windelete(Window*);
 int	winclean(Window*, int);
 void	windirfree(Window*);
 void	winevent(Window*, char*, ...);
 void	winmousebut(Window*);
 void	winaddincl(Window*, Rune*, int);
 void	wincleartag(Window*);
 char	*winctlprint(Window*, char*, int);

 struct Column
 {
 	Rectangle r;
 	Text	tag;
 	Row		*row;
 	Window	**w;
 	int		nw;
 	int		safe;
 };

 void		colinit(Column*, Rectangle);
 Window*	coladd(Column*, Window*, Window*, int);
 void		colclose(Column*, Window*, int);
 void		colcloseall(Column*);
 void		colresize(Column*, Rectangle);
 Text*	colwhich(Column*, Point);
 void		coldragwin(Column*, Window*, int);
 void		colgrow(Column*, Window*, int);
 int		colclean(Column*);
 void		colsort(Column*);
 void		colmousebut(Column*);

 struct Row
 {
 	QLock	lk;
 	Rectangle r;
 	Text	tag;
 	Column	**col;
 	int		ncol;

 };

 void		rowinit(Row*, Rectangle);
 Column*	rowadd(Row*, Column *c, int);
 void		rowclose(Row*, Column*, int);
 Text*	rowwhich(Row*, Point);
 Column*	rowwhichcol(Row*, Point);
 void		rowresize(Row*, Rectangle);
 Text*	rowtype(Row*, Rune, Point);
 void		rowdragcol(Row*, Column*, int but);
 int		rowclean(Row*);
 void		rowdump(Row*, char*);
 int		rowload(Row*, char*, int);
 void		rowloadfonts(char*);

 struct Timer
 {
 	int		dt;
 	int		cancel;
 	Channel	*c;	/* chan(int) */
 	Timer	*next;
 };

 struct Command
 {
 	int		pid;
 	Rune		*name;
 	int		nname;
 	char		*text;
 	char		**av;
 	int		iseditcmd;
 	Mntdir	*md;
 	Command	*next;
 };

 struct Dirtab
 {
 	char	*name;
 	uchar	type;
 	uint	qid;
 	uint	perm;
 };

 struct Mntdir
 {
 	int		id;
 	int		ref;
 	Rune		*dir;
 	int		ndir;
 	Mntdir	*next;
 	int		nincl;
 	Rune		**incl;
 };

 struct Fid
 {
 	int		fid;
 	int		busy;
 	int		open;
 	Qid		qid;
 	Window	*w;
 	Dirtab	*dir;
 	Fid		*next;
 	Mntdir	*mntdir;
 	int		nrpart;
 	uchar	rpart[UTFmax];
 };


 struct Xfid
 {
 	void		*arg;	/* args to xfidinit */
 	Fcall	fcall;
 	Xfid	*next;
 	Channel	*c;		/* chan(void(*)(Xfid*)) */
 	Fid	*f;
 	uchar	*buf;
 	int	flushed;

 };

 void		xfidctl(void *);
 void		xfidflush(Xfid*);
 void		xfidopen(Xfid*);
 void		xfidclose(Xfid*);
 void		xfidread(Xfid*);
 void		xfidwrite(Xfid*);
 void		xfidctlwrite(Xfid*, Window*);
 void		xfideventread(Xfid*, Window*);
 void		xfideventwrite(Xfid*, Window*);
 void		xfidindexread(Xfid*);
 void		xfidutfread(Xfid*, Text*, uint, int);
 int		xfidruneread(Xfid*, Text*, uint, uint);

 struct Reffont
 {
 	Ref	ref;
 	Font	*f;

 };
 Reffont	*rfget(int, int, int, char*);
 void		rfclose(Reffont*);

 struct Rangeset
 {
 	Range	r[NRange];
 };

 struct Dirlist
 {
 	Rune	*r;
 	int		nr;
 	int		wid;
 };

 struct Expand
 {
 	uint	q0;
 	uint	q1;
 	Rune	*name;
 	int	nname;
 	char	*bname;
 	int	jump;
 	union{
 		Text	*at;
 		Rune	*ar;
 	} u;
 	int	(*agetc)(void*, uint);
 	int	a0;
 	int	a1;
 };

 enum
 {
 	/* fbufalloc() guarantees room off end of BUFSIZE */
 	BUFSIZE = Maxblock+IOHDRSZ,	/* size from fbufalloc() */
 	RBUFSIZE = BUFSIZE/sizeof(Rune),
 	EVENTSIZE = 256,
 	Scrollwid = 12,	/* width of scroll bar */
 	Scrollgap = 4,	/* gap right of scroll bar */
 	Margin = 4,	/* margin around text */
 	Border = 2	/* line between rows, cols, windows */
 };

 #define	QID(w,q)	((w<<8)|(q))
 #define	WIN(q)	((((ulong)(q).path)>>8) & 0xFFFFFF)
 #define	FILE(q)	((q).path & 0xFF)

 #undef FALSE
 #undef TRUE

 enum
 {
 	FALSE,
 	TRUE,
 	XXX
 };

 enum
 {
 	Empty	= 0,
 	Null		= '-',
 	Delete	= 'd',
 	Insert	= 'i',
 	Replace	= 'r',
 	Filename	= 'f'
 };

 enum	/* editing */
 {
 	Inactive	= 0,
 	Inserting,
 	Collecting
 };

 uint		globalincref;
 uint		seq;
 uint		maxtab;	/* size of a tab, in units of the '0' character */

 Display		*display;
 Image		*screen;
 Font			*font;
 Mouse		*mouse;
 Mousectl		*mousectl;
 Keyboardctl	*keyboardctl;
 Reffont		reffont;
 Image		*modbutton;
 Image		*colbutton;
 Image		*button;
 Image		*but2col;
 Image		*but3col;
 Cursor		boxcursor;
 Row			row;
 int			timerpid;
 Disk			*disk;
 Text			*seltext;
 Text			*argtext;
 Text			*mousetext;	/* global because Text.close needs to clear it */
 Text			*typetext;		/* global because Text.close needs to clear it */
 Text			*barttext;		/* shared between mousetask and keyboardthread */
 int			bartflag;
 int			swapscrollbuttons;
 Window		*activewin;
 Column		*activecol;
 Buffer		snarfbuf;
 Rectangle		nullrect;
 int			fsyspid;
 char			*cputype;
 char			*objtype;
 char			*home;
 char			*fontnames[2];
 Image		*tagcols[NCOL];
 Image		*textcols[NCOL];
 extern char		wdir[]; /* must use extern because no dimension given */
 int			editing;
 int			erroutfd;
 int			messagesize;		/* negotiated in 9P version setup */
 int			globalautoindent;
 int			dodollarsigns;
 char*		mtpt;

 enum
 {
 	Kscrolloneup		= KF|0x20,
 	Kscrollonedown	= KF|0x21
 };

 Channel	*cplumb;		/* chan(Plumbmsg*) */
 Channel	*cwait;		/* chan(Waitmsg) */
 Channel	*ccommand;	/* chan(Command*) */
 Channel	*ckill;		/* chan(Rune*) */
 Channel	*cxfidalloc;	/* chan(Xfid*) */
 Channel	*cxfidfree;	/* chan(Xfid*) */
 Channel	*cnewwindow;	/* chan(Channel*) */
 Channel	*mouseexit0;	/* chan(int) */
 Channel	*mouseexit1;	/* chan(int) */
 Channel	*cexit;		/* chan(int) */
 Channel	*cerr;		/* chan(char*) */
 Channel	*cedit;		/* chan(int) */
 Channel	*cwarn;		/* chan(void*)[1] (really chan(unit)[1]) */

 QLock	editoutlk;

 #define	STACK	65536
	enum
	{
	Qdir,
	Qacme,
	Qcons,
	Qconsctl,
	Qdraw,
	Qeditout,
	Qindex,
	Qlabel,
	Qnew,

	QWaddr,
	QWbody,
	QWctl,
	QWdata,
	QWeditout,
	QWerrors,
	QWevent,
	QWrdsel,
	QWwrsel,
	QWtag,
	QWxdata,
	QMAX
	};

	enum
	{
	Blockincr = 256,
	Maxblock = 8*1024,
	NRange = 10,
	Infinity = 0x7FFFFFFF /* huge value for regexp address */
	};

	#define Buffer AcmeBuffer
	typedef struct Block Block;
	typedef struct Buffer Buffer;
	typedef struct Command Command;
	typedef struct Column Column;
	typedef struct Dirlist Dirlist;
	typedef struct Dirtab Dirtab;
	typedef struct Disk Disk;
	typedef struct Expand Expand;
	typedef struct Fid Fid;
	typedef struct File File;
	typedef struct Elog Elog;
	typedef struct Mntdir Mntdir;
	typedef struct Range Range;
	typedef struct Rangeset Rangeset;
	typedef struct Reffont Reffont;
	typedef struct Row Row;
	typedef struct Runestr Runestr;
	typedef struct Text Text;
	typedef struct Timer Timer;
	typedef struct Window Window;
	typedef struct Xfid Xfid;

	struct Runestr
	{
	Rune *r;
	int nr;
	};

	struct Range
	{
	int q0;
	int q1;
	};

	struct Block
	{
	uint addr; /* disk address in bytes */
	union
	{
	uint n; /* number of used runes in block */
	Block next; / pointer to next in free list */
	} u;
	};

	struct Disk
	{
	int fd;
	uint addr; /* length of temp file */
	Block *free[Maxblock/Blockincr+1];
	};

	Disk* diskinit(void);
	Block* disknewblock(Disk*, uint);
	void diskrelease(Disk, Block);
	void diskread(Disk, Block, Rune*, uint);
	void diskwrite(Disk, Block, Rune, uint);

	struct Buffer
	{
	uint nc;
	Rune c; / cache */
	uint cnc; /* bytes in cache */
	uint cmax; /* size of allocated cache */
	uint cq; /* position of cache */
	int cdirty; /* cache needs to be written */
	uint cbi; /* index of cache Block */
	Block *bl; / array of blocks */
	uint nbl; /* number of blocks */
	};
	void bufinsert(Buffer, uint, Rune, uint);
	void bufdelete(Buffer*, uint, uint);
	uint bufload(Buffer, uint, int, int);
	void bufread(Buffer, uint, Rune, uint);
	void bufclose(Buffer*);
	void bufreset(Buffer*);

	struct Elog
	{
	short type; /* Delete, Insert, Filename */
	uint q0; /* location of change (unused in f) */
	uint nd; /* number of deleted characters */
	uint nr; /* # runes in string or file name */
	Rune *r;
	};
	void elogterm(File*);
	void elogclose(File*);
	void eloginsert(File, int, Rune, int);
	void elogdelete(File*, int, int);
	void elogreplace(File, int, int, Rune, int);
	void elogapply(File*);

	struct File
	{
	Buffer b; /* the data */
	Buffer delta; /* transcript of changes */
	Buffer epsilon; /* inversion of delta for redo */
	Buffer elogbuf; / log of pending editor changes */
	Elog elog; /* current pending change */
	Rune name; / name of associated file */
	int nname; /* size of name */
	uvlong qidpath; /* of file when read */
	ulong mtime; /* of file when read */
	int dev; /* of file when read */
	int unread; /* file has not been read from disk */
	int editclean; /* mark clean after edit command */

	int seq; /* if seq==0, File acts like Buffer */
	int mod;
	Text curtext; / most recently used associated text */
	Text *text; / list of associated texts */
	int ntext;
	int dumpid; /* used in dumping zeroxed windows */
	};
	File* fileaddtext(File, Text);
	void fileclose(File*);
	void filedelete(File*, uint, uint);
	void filedeltext(File, Text);
	void fileinsert(File, uint, Rune, uint);
	uint fileload(File, uint, int, int);
	void filemark(File*);
	void filereset(File*);
	void filesetname(File, Rune, int);
	void fileundelete(File, Buffer, uint, uint);
	void fileuninsert(File, Buffer, uint, uint);
	void fileunsetname(File, Buffer);
	void fileundo(File, int, uint, uint*);
	uint fileredoseq(File*);

	enum /* Text.what */
	{
	Columntag,
	Rowtag,
	Tag,
	Body
	};

	struct Text
	{
	File *file;
	Frame fr;
	Reffont *reffont;
	uint org;
	uint q0;
	uint q1;
	int what;
	int tabstop;
	Window *w;
	Rectangle scrollr;
	Rectangle lastsr;
	Rectangle all;
	Row *row;
	Column *col;

	uint iq1; /* last input position */
	uint eq0; /* start of typing for ESC */
	uint cq0; /* cache position */
	int ncache; /* storage for insert */
	int ncachealloc;
	Rune *cache;
	int nofill;
	int needundo;
	};

	uint textbacknl(Text*, uint, uint);
	uint textbsinsert(Text, uint, Rune, uint, int, int*);
	int textbswidth(Text*, Rune);
	int textclickhtmlmatch(Text, uint, uint*);
	int textclickmatch(Text, int, int, int, uint);
	void textclose(Text*);
	void textcolumnate(Text, Dirlist*, int);
	void textcommit(Text*, int);
	void textconstrain(Text, uint, uint, uint, uint*);
	void textdelete(Text*, uint, uint, int);
	void textdoubleclick(Text, uint, uint*);
	void textfill(Text*);
	void textframescroll(Text*, int);
	void textinit(Text, File, Rectangle, Reffont, Image*);
	void textinsert(Text, uint, Rune, uint, int);
	int textload(Text, uint, char, int);
	Rune textreadc(Text*, uint);
	void textredraw(Text, Rectangle, Font, Image*, int);
	void textreset(Text*);
	int textresize(Text*, Rectangle, int);
	void textscrdraw(Text*);
	void textscroll(Text*, int);
	void textselect(Text*);
	int textselect2(Text, uint, uint, Text*);
	int textselect23(Text, uint, uint, Image, int);
	int textselect3(Text, uint, uint*);
	void textsetorigin(Text*, uint, int);
	void textsetselect(Text*, uint, uint);
	void textshow(Text*, uint, uint, int);
	void texttype(Text*, Rune);

	struct Window
	{
	QLock lk;
	Ref ref;
	Text tag;
	Text body;
	Rectangle r;
	uchar isdir;
	uchar isscratch;
	uchar filemenu;
	uchar dirty;
	uchar autoindent;
	uchar showdel;
	int id;
	Range addr;
	Range limit;
	uchar nopen[QMAX];
	uchar nomark;
	Range wrselrange;
	int rdselfd;
	Column *col;
	Xfid *eventx;
	char *events;
	int nevents;
	int owner;
	int maxlines;
	Dirlist **dlp;
	int ndl;
	int putseq;
	int nincl;
	Rune **incl;
	Reffont *reffont;
	QLock ctllock;
	uint ctlfid;
	char *dumpstr;
	char *dumpdir;
	int dumpid;
	int utflastqid;
	int utflastboff;
	int utflastq;
	int tagsafe; /* taglines is correct */
	int tagexpand;
	int taglines;
	Rectangle tagtop;
	QLock editoutlk;
	};

	void wininit(Window, Window, Rectangle);
	void winlock(Window*, int);
	void winlock1(Window*, int);
	void winunlock(Window*);
	void wintype(Window, Text, Rune);
	void winundo(Window*, int);
	void winsetname(Window, Rune, int);
	void winsettag(Window*);
	void winsettag1(Window*);
	void wincommit(Window, Text);
	int winresize(Window*, Rectangle, int, int);
	void winclose(Window*);
	void windelete(Window*);
	int winclean(Window*, int);
	void windirfree(Window*);
	void winevent(Window, char, ...);
	void winmousebut(Window*);
	void winaddincl(Window, Rune, int);
	void wincleartag(Window*);
	char winctlprint(Window, char*, int);

	struct Column
	{
	Rectangle r;
	Text tag;
	Row *row;
	Window **w;
	int nw;
	int safe;
	};

	void colinit(Column*, Rectangle);
	Window* coladd(Column, Window, Window*, int);
	void colclose(Column, Window, int);
	void colcloseall(Column*);
	void colresize(Column*, Rectangle);
	Text* colwhich(Column*, Point);
	void coldragwin(Column, Window, int);
	void colgrow(Column, Window, int);
	int colclean(Column*);
	void colsort(Column*);
	void colmousebut(Column*);

	struct Row
	{
	QLock lk;
	Rectangle r;
	Text tag;
	Column **col;
	int ncol;

	};

	void rowinit(Row*, Rectangle);
	Column* rowadd(Row, Column c, int);
	void rowclose(Row, Column, int);
	Text* rowwhich(Row*, Point);
	Column* rowwhichcol(Row*, Point);
	void rowresize(Row*, Rectangle);
	Text* rowtype(Row*, Rune, Point);
	void rowdragcol(Row, Column, int but);
	int rowclean(Row*);
	void rowdump(Row, char);
	int rowload(Row, char, int);
	void rowloadfonts(char*);

	struct Timer
	{
	int dt;
	int cancel;
	Channel c; / chan(int) */
	Timer *next;
	};

	struct Command
	{
	int pid;
	Rune *name;
	int nname;
	char *text;
	char **av;
	int iseditcmd;
	Mntdir *md;
	Command *next;
	};

	struct Dirtab
	{
	char *name;
	uchar type;
	uint qid;
	uint perm;
	};

	struct Mntdir
	{
	int id;
	int ref;
	Rune *dir;
	int ndir;
	Mntdir *next;
	int nincl;
	Rune **incl;
	};

	struct Fid
	{
	int fid;
	int busy;
	int open;
	Qid qid;
	Window *w;
	Dirtab *dir;
	Fid *next;
	Mntdir *mntdir;
	int nrpart;
	uchar rpart[UTFmax];
	};


	struct Xfid
	{
	void arg; / args to xfidinit */
	Fcall fcall;
	Xfid *next;
	Channel c; / chan(void()(Xfid)) */
	Fid *f;
	uchar *buf;
	int flushed;

	};

	void xfidctl(void *);
	void xfidflush(Xfid*);
	void xfidopen(Xfid*);
	void xfidclose(Xfid*);
	void xfidread(Xfid*);
	void xfidwrite(Xfid*);
	void xfidctlwrite(Xfid, Window);
	void xfideventread(Xfid, Window);
	void xfideventwrite(Xfid, Window);
	void xfidindexread(Xfid*);
	void xfidutfread(Xfid, Text, uint, int);
	int xfidruneread(Xfid, Text, uint, uint);

	struct Reffont
	{
	Ref ref;
	Font *f;

	};
	Reffont rfget(int, int, int, char);
	void rfclose(Reffont*);

	struct Rangeset
	{
	Range r[NRange];
	};

	struct Dirlist
	{
	Rune *r;
	int nr;
	int wid;
	};

	struct Expand
	{
	uint q0;
	uint q1;
	Rune *name;
	int nname;
	char *bname;
	int jump;
	union{
	Text *at;
	Rune *ar;
	} u;
	int (agetc)(void, uint);
	int a0;
	int a1;
	};

	enum
	{
	/* fbufalloc() guarantees room off end of BUFSIZE */
	BUFSIZE = Maxblock+IOHDRSZ, /* size from fbufalloc() */
	RBUFSIZE = BUFSIZE/sizeof(Rune),
	EVENTSIZE = 256,
	Scrollwid = 12, /* width of scroll bar */
	Scrollgap = 4, /* gap right of scroll bar */
	Margin = 4, /* margin around text */
	Border = 2 /* line between rows, cols, windows */
	};

	#define QID(w,q) ((w<<8)\|(q))
	#define WIN(q) ((((ulong)(q).path)>>8) & 0xFFFFFF)
	#define FILE(q) ((q).path & 0xFF)

	#undef FALSE
	#undef TRUE

	enum
	{
	FALSE,
	TRUE,
	XXX
	};

	enum
	{
	Empty = 0,
	Null = '-',
	Delete = 'd',
	Insert = 'i',
	Replace = 'r',
	Filename = 'f'
	};

	enum /* editing */
	{
	Inactive = 0,
	Inserting,
	Collecting
	};

	uint globalincref;
	uint seq;
	uint maxtab; /* size of a tab, in units of the '0' character */

	Display *display;
	Image *screen;
	Font *font;
	Mouse *mouse;
	Mousectl *mousectl;
	Keyboardctl *keyboardctl;
	Reffont reffont;
	Image *modbutton;
	Image *colbutton;
	Image *button;
	Image *but2col;
	Image *but3col;
	Cursor boxcursor;
	Row row;
	int timerpid;
	Disk *disk;
	Text *seltext;
	Text *argtext;
	Text mousetext; / global because Text.close needs to clear it */
	Text typetext; / global because Text.close needs to clear it */
	Text barttext; / shared between mousetask and keyboardthread */
	int bartflag;
	int swapscrollbuttons;
	Window *activewin;
	Column *activecol;
	Buffer snarfbuf;
	Rectangle nullrect;
	int fsyspid;
	char *cputype;
	char *objtype;
	char *home;
	char *fontnames[2];
	Image *tagcols[NCOL];
	Image *textcols[NCOL];
	extern char wdir[]; /* must use extern because no dimension given */
	int editing;
	int erroutfd;
	int messagesize; /* negotiated in 9P version setup */
	int globalautoindent;
	int dodollarsigns;
	char* mtpt;

	enum
	{
	Kscrolloneup = KF\|0x20,
	Kscrollonedown = KF\|0x21
	};

	Channel cplumb; / chan(Plumbmsg) /
	Channel cwait; / chan(Waitmsg) */
	Channel ccommand; / chan(Command) /
	Channel ckill; / chan(Rune) /
	Channel cxfidalloc; / chan(Xfid) /
	Channel cxfidfree; / chan(Xfid) /
	Channel cnewwindow; / chan(Channel) /
	Channel mouseexit0; / chan(int) */
	Channel mouseexit1; / chan(int) */
	Channel cexit; / chan(int) */
	Channel cerr; / chan(char) /
	Channel cedit; / chan(int) */
	Channel cwarn; / chan(void)[1] (really chan(unit)[1]) /

	QLock editoutlk;

	#define STACK 65536