placeholder; does not yet build

13 files changed, 3661 insertions, 0 deletions

diff --git a/src/cmd/page/filter.c b/src/cmd/page/filter.c
new file mode 100644
index 00000000..07c3df2b
--- /dev/null
+++ b/src/cmd/page/filter.c
@@ -0,0 +1,107 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include "page.h"
+
+Document*
+initfilt(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf, char *type, char *cmd, int docopy)
+{
+	int ofd;
+	int p[2];
+	char xbuf[8192];
+	int n;
+
+	if(argc > 1) {
+		fprint(2, "can only view one %s file at a time\n", type);
+		return nil;
+	}
+
+	fprint(2, "converting from %s to postscript...\n", type);
+
+	if(docopy){
+		if(pipe(p) < 0){
+			fprint(2, "pipe fails: %r\n");
+			exits("Epipe");
+		}
+	}else{
+		p[0] = open("/dev/null", ORDWR);
+		p[1] = open("/dev/null", ORDWR);
+	}
+
+	ofd = opentemp("/tmp/pagecvtXXXXXXXXX");
+	switch(fork()){
+	case -1:
+		fprint(2, "fork fails: %r\n");
+		exits("Efork");
+	default:
+		close(p[1]);
+		if(docopy){
+			write(p[0], buf, nbuf);
+			if(b)
+				while((n = Bread(b, xbuf, sizeof xbuf)) > 0)
+					write(p[0], xbuf, n);
+			else
+				while((n = read(stdinfd, xbuf, sizeof xbuf)) > 0)
+					write(p[0], xbuf, n);
+		}
+		close(p[0]);
+		waitpid();
+		break;
+	case 0:
+		close(p[0]);
+		dup(p[1], 0);
+		dup(ofd, 1);
+		/* stderr shines through */
+		execl("/bin/rc", "rc", "-c", cmd, nil);
+		break;
+	}
+
+	if(b)
+		Bterm(b);
+	seek(ofd, 0, 0);
+	b = emalloc(sizeof(Biobuf));
+	Binit(b, ofd, OREAD);
+
+	return initps(b, argc, argv, nil, 0);
+}
+
+Document*
+initdvi(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf)
+{
+	int fd;
+	char *name;
+	char cmd[256];
+	char fdbuf[20];
+
+	/*
+	 * Stupid DVIPS won't take standard input.
+	 */
+	if(b == nil){	/* standard input; spool to disk (ouch) */
+		fd = spooltodisk(buf, nbuf, &name);
+		sprint(fdbuf, "/fd/%d", fd);
+		b = Bopen(fdbuf, OREAD);
+		if(b == nil){
+			fprint(2, "cannot open disk spool file\n");
+			wexits("Bopen temp");
+		}
+		argv = &name;
+		argc = 1;
+	}
+
+	snprint(cmd, sizeof cmd, "dvips -Pps -r0 -q1 -f1 '%s'", argv[0]);
+	return initfilt(b, argc, argv, buf, nbuf, "dvi", cmd, 0);
+}
+
+Document*
+inittroff(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf)
+{
+	return initfilt(b, argc, argv, buf, nbuf, "troff", "lp -dstdout", 1);
+}
+
+Document*
+initmsdoc(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf)
+{
+	return initfilt(b, argc, argv, buf, nbuf, "microsoft office", "doc2ps", 1);
+}
diff --git a/src/cmd/page/gfx.c b/src/cmd/page/gfx.c
new file mode 100644
index 00000000..72254de8
--- /dev/null
+++ b/src/cmd/page/gfx.c
@@ -0,0 +1,331 @@
+/*
+ * graphics file reading for page
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include "page.h"
+
+typedef struct Convert	Convert;
+typedef struct GfxInfo	GfxInfo;
+typedef struct Graphic	Graphic;
+
+struct Convert {
+	char *name;
+	char *cmd;
+	char *truecmd;	/* cmd for true color */
+};
+
+struct GfxInfo {
+	Graphic *g;
+};
+
+struct Graphic {
+	int type;
+	char *name;
+	uchar *buf;	/* if stdin */
+	int nbuf;
+};
+
+enum {
+	Ipic,
+	Itiff,
+	Ijpeg,
+	Igif,
+	Iinferno,
+	Ifax,
+	Icvt2pic,
+	Iplan9bm,
+	Iccittg4,
+	Ippm,
+	Ipng,
+	Iyuv,
+	Ibmp,
+};
+
+/*
+ * N.B. These commands need to read stdin if %a is replaced
+ * with an empty string.
+ */
+Convert cvt[] = {
+[Ipic]		{ "plan9",	"fb/3to1 rgbv %a |fb/pcp -tplan9" },
+[Itiff]		{ "tiff",	"fb/tiff2pic %a | fb/3to1 rgbv | fb/pcp -tplan9" },
+[Iplan9bm]	{ "plan9bm",	nil },
+[Ijpeg]		{ "jpeg",	"jpg -9 %a", "jpg -t9 %a" },
+[Igif]		{ "gif",	"gif -9 %a", "gif -t9 %a" },
+[Iinferno]	{ "inferno",	nil },
+[Ifax]		{ "fax",	"aux/g3p9bit -g %a" },
+[Icvt2pic]	{ "unknown",	"fb/cvt2pic %a |fb/3to1 rgbv" },
+[Ippm]		{ "ppm",	"ppm -9 %a", "ppm -t9 %a" },
+/* ``temporary'' hack for hobby */
+[Iccittg4]	{ "ccitt-g4",	"cat %a|rx nslocum /usr/lib/ocr/bin/bcp -M|fb/pcp -tcompressed -l0" },
+[Ipng]		{ "png",	"png -9 %a", "png -t9 %a" },
+[Iyuv]		{ "yuv",	"yuv -9 %a", "yuv -t9 %a"  },
+[Ibmp]		{ "bmp",	"bmp -9 %a", "bmp -t9 %a"  },
+};
+
+static Image*	convert(Graphic*);
+static Image*	gfxdrawpage(Document *d, int page);
+static char*	gfxpagename(Document*, int);
+static int	spawnrc(char*, uchar*, int);
+static int	addpage(Document*, char*);
+static int	rmpage(Document*, int);
+static int	genaddpage(Document*, char*, uchar*, int);
+
+static char*
+gfxpagename(Document *doc, int page)
+{
+	GfxInfo *gfx = doc->extra;
+	return gfx->g[page].name;
+}
+
+static Image*
+gfxdrawpage(Document *doc, int page)
+{
+	GfxInfo *gfx = doc->extra;
+	return convert(gfx->g+page);
+}
+
+Document*
+initgfx(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf)
+{
+	GfxInfo *gfx;
+	Document *doc;
+	int i;
+
+	USED(b);
+	doc = emalloc(sizeof(*doc));
+	gfx = emalloc(sizeof(*gfx));
+	gfx->g = nil;
+	
+	doc->npage = 0;
+	doc->drawpage = gfxdrawpage;
+	doc->pagename = gfxpagename;
+	doc->addpage = addpage;
+	doc->rmpage = rmpage;
+	doc->extra = gfx;
+	doc->fwdonly = 0;
+
+	fprint(2, "reading through graphics...\n");
+	if(argc==0 && buf)
+		genaddpage(doc, nil, buf, nbuf);
+	else{
+		for(i=0; i<argc; i++)
+			if(addpage(doc, argv[i]) < 0)
+				fprint(2, "warning: not including %s: %r\n", argv[i]);
+	}
+
+	return doc;
+}
+
+static int
+genaddpage(Document *doc, char *name, uchar *buf, int nbuf)
+{
+	Graphic *g;
+	GfxInfo *gfx;
+	Biobuf *b;
+	uchar xbuf[32];
+	int i, l;
+
+	l = 0;
+	gfx = doc->extra;
+
+	assert((name == nil) ^ (buf == nil));
+	assert(name != nil || doc->npage == 0);
+
+	for(i=0; i<doc->npage; i++)
+		if(strcmp(gfx->g[i].name, name) == 0)
+			return i;
+
+	if(name){
+		l = strlen(name);
+		if((b = Bopen(name, OREAD)) == nil) {
+			werrstr("Bopen: %r");
+			return -1;
+		}
+
+		if(Bread(b, xbuf, sizeof xbuf) != sizeof xbuf) {
+			werrstr("short read: %r");
+			return -1;
+		}
+		Bterm(b);
+		buf = xbuf;
+		nbuf = sizeof xbuf;
+	}
+
+
+	gfx->g = erealloc(gfx->g, (doc->npage+1)*(sizeof(*gfx->g)));
+	g = &gfx->g[doc->npage];
+
+	memset(g, 0, sizeof *g);
+	if(memcmp(buf, "GIF", 3) == 0)
+		g->type = Igif;
+	else if(memcmp(buf, "\111\111\052\000", 4) == 0) 
+		g->type = Itiff;
+	else if(memcmp(buf, "\115\115\000\052", 4) == 0)
+		g->type = Itiff;
+	else if(memcmp(buf, "\377\330\377", 3) == 0)
+		g->type = Ijpeg;
+	else if(memcmp(buf, "\211PNG\r\n\032\n", 3) == 0)
+		g->type = Ipng;
+	else if(memcmp(buf, "compressed\n", 11) == 0)
+		g->type = Iinferno;
+	else if(memcmp(buf, "\0PC Research, Inc", 17) == 0)
+		g->type = Ifax;
+	else if(memcmp(buf, "TYPE=ccitt-g31", 14) == 0)
+		g->type = Ifax;
+	else if(memcmp(buf, "II*", 3) == 0)
+		g->type = Ifax;
+	else if(memcmp(buf, "TYPE=ccitt-g4", 13) == 0)
+		g->type = Iccittg4;
+	else if(memcmp(buf, "TYPE=", 5) == 0)
+		g->type = Ipic;
+	else if(buf[0] == 'P' && '0' <= buf[1] && buf[1] <= '9')
+		g->type = Ippm;
+	else if(memcmp(buf, "BM", 2) == 0)
+		g->type = Ibmp;
+	else if(memcmp(buf, "          ", 10) == 0 &&
+		'0' <= buf[10] && buf[10] <= '9' &&
+		buf[11] == ' ')
+		g->type = Iplan9bm;
+	else if(strtochan((char*)buf) != 0)
+		g->type = Iplan9bm;
+	else if (l > 4 && strcmp(name + l -4, ".yuv") == 0)
+		g->type = Iyuv;
+	else
+		g->type = Icvt2pic;
+
+	if(name)
+		g->name = estrdup(name);
+	else{
+		g->name = estrdup("stdin");	/* so it can be freed */
+		g->buf = buf;
+		g->nbuf = nbuf;
+	}
+
+	if(chatty) fprint(2, "classified \"%s\" as \"%s\"\n", g->name, cvt[g->type].name);
+	return doc->npage++;
+}
+
+static int 
+addpage(Document *doc, char *name)
+{
+	return genaddpage(doc, name, nil, 0);
+}
+
+static int
+rmpage(Document *doc, int n)
+{
+	int i;
+	GfxInfo *gfx;
+
+	if(n < 0 || n >= doc->npage)
+		return -1;
+
+	gfx = doc->extra;
+	doc->npage--;
+	free(gfx->g[n].name);
+
+	for(i=n; i<doc->npage; i++)
+		gfx->g[i] = gfx->g[i+1];
+
+	if(n < doc->npage)
+		return n;
+	if(n == 0)
+		return 0;
+	return n-1;
+}
+
+
+static Image*
+convert(Graphic *g)
+{
+	int fd;
+	Convert c;
+	char *cmd;
+	char *name, buf[1000];
+	Image *im;
+	int rcspawned = 0;
+	Waitmsg *w;
+
+	c = cvt[g->type];
+	if(c.cmd == nil) {
+		if(chatty) fprint(2, "no conversion for bitmap \"%s\"...\n", g->name);
+		if(g->buf == nil){	/* not stdin */
+			fd = open(g->name, OREAD);
+			if(fd < 0) {
+				fprint(2, "cannot open file: %r\n");
+				wexits("open");
+			}
+		}else
+			fd = stdinpipe(g->buf, g->nbuf);	
+	} else {
+		cmd = c.cmd;
+		if(truecolor && c.truecmd)
+			cmd = c.truecmd;
+
+		if(g->buf != nil)	/* is stdin */
+			name = "";
+		else
+			name = g->name;
+		if(strlen(cmd)+strlen(name) > sizeof buf) {
+			fprint(2, "command too long\n");
+			wexits("convert");
+		}
+		snprint(buf, sizeof buf, cmd, name);
+		if(chatty) fprint(2, "using \"%s\" to convert \"%s\"...\n", buf, g->name);
+		fd = spawnrc(buf, g->buf, g->nbuf);
+		rcspawned++;
+		if(fd < 0) {
+			fprint(2, "cannot spawn converter: %r\n");
+			wexits("convert");
+		}	
+	}
+
+	im = readimage(display, fd, 0);
+	if(im == nil) {
+		fprint(2, "warning: couldn't read image: %r\n");
+	}
+	close(fd);
+
+	/* for some reason rx doesn't work well with wait */
+	/* for some reason 3to1 exits on success with a non-null status of |3to1 */
+	if(rcspawned && g->type != Iccittg4) {
+		if((w=wait())!=nil && w->msg[0] && !strstr(w->msg, "3to1"))
+			fprint(2, "slave wait error: %s\n", w->msg);
+		free(w);
+	}
+	return im;
+}
+
+static int
+spawnrc(char *cmd, uchar *stdinbuf, int nstdinbuf)
+{
+	int pfd[2];
+	int pid;
+
+	if(chatty) fprint(2, "spawning(%s)...", cmd);
+
+	if(pipe(pfd) < 0)
+		return -1;
+	if((pid = fork()) < 0)
+		return -1;
+
+	if(pid == 0) {
+		close(pfd[1]);
+		if(stdinbuf)
+			dup(stdinpipe(stdinbuf, nstdinbuf), 0);
+		else
+			dup(open("/dev/null", OREAD), 0);
+		dup(pfd[0], 1);
+		//dup(pfd[0], 2);
+		execl("/bin/rc", "rc", "-c", cmd, nil);
+		wexits("exec");
+	}
+	close(pfd[0]);
+	return pfd[1];
+}
+
diff --git a/src/cmd/page/gs.c b/src/cmd/page/gs.c
new file mode 100644
index 00000000..524701e3
--- /dev/null
+++ b/src/cmd/page/gs.c
@@ -0,0 +1,342 @@
+/*
+ * gs interface for page.
+ * ps.c and pdf.c both use these routines.
+ * a caveat: if you run more than one gs, only the last 
+ * one gets killed by killgs 
+ */
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include "page.h"
+
+static int gspid;	/* globals for atexit */
+static int gsfd;
+static void	killgs(void);
+
+static void
+killgs(void)
+{
+	char tmpfile[100];
+
+	close(gsfd);
+	postnote(PNGROUP, getpid(), "die");
+
+	/*
+	 * from ghostscript's use.txt:
+	 * ``Ghostscript currently doesn't do a very good job of deleting temporary
+	 * files when it exits; you may have to delete them manually from time to
+	 * time.''
+	 */
+	sprint(tmpfile, "/tmp/gs_%.5da", (gspid+300000)%100000);
+	if(chatty) fprint(2, "remove %s...\n", tmpfile);
+	remove(tmpfile);
+	sleep(100);
+	postnote(PNPROC, gspid, "die yankee pig dog");
+}
+
+int
+spawnwriter(GSInfo *g, Biobuf *b)
+{
+	char buf[4096];
+	int n;
+	int fd;
+
+	switch(fork()){
+	case -1:	return -1;
+	case 0:	break;
+	default:	return 0;
+	}
+
+	Bseek(b, 0, 0);
+	fd = g->gsfd;
+	while((n = Bread(b, buf, sizeof buf)) > 0)
+		write(fd, buf, n);
+	fprint(fd, "(/fd/3) (w) file dup (THIS IS NOT AN INFERNO BITMAP\\n) writestring flushfile\n");
+	_exits(0);
+	return -1;
+}
+
+int
+spawnreader(int fd)
+{
+	int n, pfd[2];
+	char buf[1024];
+
+	if(pipe(pfd)<0)
+		return -1;
+	switch(fork()){
+	case -1:
+		return -1;
+	case 0:
+		break;
+	default:
+		close(pfd[0]);
+		return pfd[1];
+	}
+
+	close(pfd[1]);
+	switch(fork()){
+	case -1:
+		wexits("fork failed");
+	case 0:
+		while((n=read(fd, buf, sizeof buf)) > 0) {
+			write(1, buf, n);
+			write(pfd[0], buf, n);
+		}
+		break;
+	default:
+		while((n=read(pfd[0], buf, sizeof buf)) > 0) {
+			write(1, buf, n);
+			write(fd, buf, n);
+		}
+		break;
+	}
+	postnote(PNGROUP, getpid(), "i'm die-ing");
+	_exits(0);
+	return -1;
+}
+
+void
+spawnmonitor(int fd)
+{
+	char buf[4096];
+	char *xbuf;
+	int n;
+	int out;
+	int first;
+
+	switch(rfork(RFFDG|RFNOTEG|RFPROC)){
+	case -1:
+	default:
+		return;
+
+	case 0:
+		break;
+	}
+
+	out = open("/dev/cons", OWRITE);
+	if(out < 0)
+		out = 2;
+
+	xbuf = buf;	/* for ease of acid */
+	first = 1;
+	while((n = read(fd, xbuf, sizeof buf)) > 0){
+		if(first){
+			first = 0;
+			fprint(2, "Ghostscript Error:\n");
+		}
+		write(out, xbuf, n);
+		alarm(500);
+	}
+	_exits(0);
+}
+
+int 
+spawngs(GSInfo *g)
+{
+	char *args[16];
+	char tb[32], gb[32];
+	int i, nargs;
+	int devnull;
+	int stdinout[2];
+	int dataout[2];
+	int errout[2];
+
+	/*
+	 * spawn gs
+	 *
+ 	 * gs's standard input is fed from stdinout.
+	 * gs output written to fd-2 (i.e. output we generate intentionally) is fed to stdinout.
+	 * gs output written to fd 1 (i.e. ouptut gs generates on error) is fed to errout.
+	 * gs data output is written to fd 3, which is dataout.
+	 */
+	if(pipe(stdinout) < 0 || pipe(dataout)<0 || pipe(errout)<0)
+		return -1;
+
+	nargs = 0;
+	args[nargs++] = "gs";
+	args[nargs++] = "-dNOPAUSE";
+	args[nargs++] = "-dSAFER";
+	args[nargs++] = "-sDEVICE=plan9";
+	args[nargs++] = "-sOutputFile=/fd/3";
+	args[nargs++] = "-dQUIET";
+	args[nargs++] = "-r100";
+	sprint(tb, "-dTextAlphaBits=%d", textbits);
+	sprint(gb, "-dGraphicsAlphaBits=%d", gfxbits);
+	if(textbits)
+		args[nargs++] = tb;
+	if(gfxbits)
+		args[nargs++] = gb;
+	args[nargs++] = "-";
+	args[nargs] = nil;
+
+	gspid = fork();
+	if(gspid == 0) {
+		close(stdinout[1]);
+		close(dataout[1]);
+		close(errout[1]);
+
+		/*
+		 * Horrible problem: we want to dup fd's 0-4 below,
+		 * but some of the source fd's might have those small numbers.
+		 * So we need to reallocate those.  In order to not step on
+		 * anything else, we'll dup the fd's to higher ones using
+		 * dup(x, -1), but we need to use up the lower ones first.
+		 */
+		while((devnull = open("/dev/null", ORDWR)) < 5)
+			;
+
+		stdinout[0] = dup(stdinout[0], -1);
+		errout[0] = dup(errout[0], -1);
+		dataout[0] = dup(dataout[0], -1);
+
+		dup(stdinout[0], 0);
+		dup(errout[0], 1);
+		dup(devnull, 2);	/* never anything useful */
+		dup(dataout[0], 3);
+		dup(stdinout[0], 4);
+		for(i=5; i<20; i++)
+			close(i);
+		exec("/bin/gs", args);
+		wexits("exec");
+	}
+	close(stdinout[0]);
+	close(errout[0]);
+	close(dataout[0]);
+	atexit(killgs);
+
+	if(teegs)
+		stdinout[1] = spawnreader(stdinout[1]);
+
+	gsfd = g->gsfd = stdinout[1];
+	g->gsdfd = dataout[1];
+	g->gspid = gspid;
+
+	spawnmonitor(errout[1]);
+	Binit(&g->gsrd, g->gsfd, OREAD);
+
+	gscmd(g, "/PAGEOUT (/fd/4) (w) file def\n");
+	gscmd(g, "/PAGE== { PAGEOUT exch write==only PAGEOUT (\\n) writestring PAGEOUT flushfile } def\n");
+	waitgs(g);
+
+	return 0;
+}
+
+int
+gscmd(GSInfo *gs, char *fmt, ...)
+{
+	char buf[1024];
+	int n;
+
+	va_list v;
+	va_start(v, fmt);
+	n = vseprint(buf, buf+sizeof buf, fmt, v) - buf;
+	if(n <= 0)
+		return n;
+
+	if(chatty) {
+		fprint(2, "cmd: ");
+		write(2, buf, n);
+	}
+
+	if(write(gs->gsfd, buf, n) != 0)
+		return -1;
+
+	return n;
+}
+
+/*
+ * set the dimensions of the bitmap we expect to get back from GS.
+ */
+void
+setdim(GSInfo *gs, Rectangle bbox, int ppi, int landscape)
+{
+	Rectangle pbox;
+
+	if(chatty)
+		fprint(2, "setdim: bbox=%R\n", bbox);
+
+	if(ppi)
+		gs->ppi = ppi;
+
+	gscmd(gs, "mark\n");
+	if(ppi)
+		gscmd(gs, "/HWResolution [%d %d]\n", ppi, ppi);
+
+	if(!Dx(bbox))
+		bbox = Rect(0, 0, 612, 792);	/* 8½×11 */
+
+	switch(landscape){
+	case 0:
+		pbox = bbox;
+		break;
+	case 1:
+		pbox = Rect(bbox.min.y, bbox.min.x, bbox.max.y, bbox.max.x);
+		break;
+	}
+	gscmd(gs, "/PageSize [%d %d]\n", Dx(pbox), Dy(pbox));
+	gscmd(gs, "/Margins [%d %d]\n", -pbox.min.x, -pbox.min.y);
+	gscmd(gs, "currentdevice putdeviceprops pop\n");
+	gscmd(gs, "/#copies 1 store\n");
+
+	if(!eqpt(bbox.min, ZP))
+		gscmd(gs, "%d %d translate\n", -bbox.min.x, -bbox.min.y);
+
+	switch(landscape){
+	case 0:
+		break;
+	case 1:
+		gscmd(gs, "%d 0 translate\n", Dy(bbox));
+		gscmd(gs, "90 rotate\n");
+		break;
+	}
+
+	waitgs(gs);
+}
+
+void
+waitgs(GSInfo *gs)
+{
+	/* we figure out that gs is done by telling it to
+	 * print something and waiting until it does.
+	 */
+	char *p;
+	Biobuf *b = &gs->gsrd;
+	uchar buf[1024];
+	int n;
+
+//	gscmd(gs, "(\\n**bstack\\n) print flush\n");
+//	gscmd(gs, "stack flush\n");
+//	gscmd(gs, "(**estack\\n) print flush\n");
+	gscmd(gs, "(\\n//GO.SYSIN DD\\n) PAGE==\n");
+
+	alarm(300*1000);
+	for(;;) {
+		p = Brdline(b, '\n');
+		if(p == nil) {
+			n = Bbuffered(b);
+			if(n <= 0)
+				break;
+			if(n > sizeof buf)
+				n = sizeof buf;
+			Bread(b, buf, n);
+			continue;
+		}
+		p[Blinelen(b)-1] = 0;
+		if(chatty) fprint(2, "p: ");
+		if(chatty) write(2, p, Blinelen(b)-1);
+		if(chatty) fprint(2, "\n");
+		if(strstr(p, "Error:")) {
+			alarm(0);
+			fprint(2, "ghostscript error: %s\n", p);
+			wexits("gs error");
+		}
+
+		if(strstr(p, "//GO.SYSIN DD")) {
+			break;
+		}
+	}
+	alarm(0);
+}
diff --git a/src/cmd/page/mkfile b/src/cmd/page/mkfile
new file mode 100644
index 00000000..e8dbf52a
--- /dev/null
+++ b/src/cmd/page/mkfile
@@ -0,0 +1,23 @@
+<$PLAN9/src/mkhdr
+
+TARG=page
+
+HFILES=page.h
+OFILES=\
+	filter.$O\
+	gfx.$O\
+	gs.$O\
+	page.$O\
+	pdf.$O\
+	ps.$O\
+	rotate.$O\
+	util.$O\
+	view.$O\
+
+<$PLAN9/src//mkone
+
+pdfprolog.c: pdfprolog.ps
+	cat pdfprolog.ps | sed 's/.*/"&\\n"/g' >pdfprolog.c
+
+pdf.$O: pdfprolog.c
+
diff --git a/src/cmd/page/nrotate.c b/src/cmd/page/nrotate.c
new file mode 100644
index 00000000..2225ec3f
--- /dev/null
+++ b/src/cmd/page/nrotate.c
@@ -0,0 +1,277 @@
+/*
+ * Rotate an image 180° in O(log Dx + log Dy)
+ * draw calls, using an extra buffer the same size
+ * as the image.
+ *
+ * The basic concept is that you can invert an array by
+ * inverting the top half, inverting the bottom half, and
+ * then swapping them.
+ * 
+ * This is usually overkill, but it speeds up slow remote
+ * connections quite a bit.
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <draw.h>
+#include <event.h>
+#include "page.h"
+
+int ndraw = 0;
+
+enum {
+	Xaxis,
+	Yaxis,
+};
+
+static void reverse(Image*, Image*, int);
+static void shuffle(Image*, Image*, int, int, Image*, int, int);
+static void writefile(char *name, Image *im, int gran);
+static void halvemaskdim(Image*);
+static void swapranges(Image*, Image*, int, int, int, int);
+
+/*
+ * Rotate the image 180° by reflecting first
+ * along the X axis, and then along the Y axis.
+ */
+void
+rot180(Image *img)
+{
+	Image *tmp;
+
+	tmp = xallocimage(display, img->r, img->chan, 0, DNofill);
+	if(tmp == nil)
+		return;
+
+	reverse(img, tmp, Xaxis);
+	reverse(img, tmp, Yaxis);
+
+	freeimage(tmp);
+}
+
+Image *mtmp;
+
+static void
+reverse(Image *img, Image *tmp, int axis)
+{
+	Image *mask;
+	Rectangle r;
+	int i, d;
+
+	/*
+	 * We start by swapping large chunks at a time.
+	 * The chunk size should be the largest power of
+	 * two that fits in the dimension.
+	 */
+	d = axis==Xaxis ? Dx(img) : Dy(img);
+	for(i = 1; i*2 <= d; i *= 2)
+		;
+
+	r = axis==Xaxis ? Rect(0,0, i,100) : Rect(0,0, 100,i);
+	mask = xallocimage(display, r, GREY1, 1, DTransparent);
+	mtmp = xallocimage(display, r, GREY1, 1, DTransparent);
+
+	/*
+	 * Now color the bottom (or left) half of the mask opaque.
+	 */
+	if(axis==Xaxis)
+		r.max.x /= 2;
+	else
+		r.max.y /= 2;
+
+	draw(mask, r, display->opaque, nil, ZP);
+	writefile("mask", mask, i);
+
+	/*
+	 * Shuffle will recur, shuffling the pieces as necessary
+	 * and making the mask a finer and finer grating.
+	 */
+	shuffle(img, tmp, axis, d, mask, i, 0);
+
+	freeimage(mask);
+}
+
+/*
+ * Shuffle the image by swapping pieces of size maskdim.
+ */
+static void
+shuffle(Image *img, Image *tmp, int axis, int imgdim, Image *mask, int maskdim)
+{
+	int slop;
+
+	if(maskdim == 0)
+		return;
+
+	/*
+	 * Figure out how much will be left over that needs to be
+	 * shifted specially to the bottom.
+	 */
+	slop = imgdim % maskdim;
+
+	/*
+	 * Swap adjacent grating lines as per mask.
+	 */
+	swapadjacent(img, tmp, axis, imgdim - slop, mask, maskdim);
+
+	/*
+	 * Calculate the mask with gratings half as wide and recur.
+	 */
+	halvemaskdim(mask, maskdim, axis);
+	writefile("mask", mask, maskdim/2);
+
+	shuffle(img, tmp, axis, imgdim, mask, maskdim/2);
+
+	/*
+	 * Move the slop down to the bottom of the image.
+	 */
+	swapranges(img, tmp, 0, imgdim-slop, imgdim, axis);
+	moveup(im, tmp, lastnn, nn, n, axis);
+}
+
+/*
+ * Halve the grating period in the mask.
+ * The grating currently looks like 
+ * ####____####____####____####____
+ * where #### is opacity.
+ *
+ * We want
+ * ##__##__##__##__##__##__##__##__
+ * which is achieved by shifting the mask
+ * and drawing on itself through itself.
+ * Draw doesn't actually allow this, so 
+ * we have to copy it first.
+ *
+ *     ####____####____####____####____ (dst)
+ * +   ____####____####____####____#### (src)
+ * in  __####____####____####____####__ (mask)
+ * ===========================================
+ *     ##__##__##__##__##__##__##__##__
+ */
+static void
+halvemaskdim(Image *m, int maskdim, int axis)
+{
+	Point δ;
+
+	δ = axis==Xaxis ? Pt(maskdim,0) : Pt(0,maskdim);
+	draw(mtmp, mtmp->r, mask, nil, mask->r.min);
+	gendraw(mask, mask->r, mtmp, δ, mtmp, divpt(δ,2));
+	writefile("mask", mask, maskdim/2);
+}
+
+/*
+ * Swap the regions [a,b] and [b,c]
+ */
+static void
+swapranges(Image *img, Image *tmp, int a, int b, int c, int axis)
+{
+	Rectangle r;
+	Point δ;
+
+	if(a == b || b == c)
+		return;
+
+	writefile("swap", img, 0);
+	draw(tmp, tmp->r, im, nil, im->r.min);
+
+	/* [a,a+(c-b)] gets [b,c] */
+	r = img->r;
+	if(axis==Xaxis){
+		δ = Pt(1,0);
+		r.min.x = img->r.min.x + a;
+		r.max.x = img->r.min.x + a + (c-b);
+	}else{
+		δ = Pt(0,1);
+		r.min.y = img->r.min.y + a;
+		r.max.y = img->r.min.y + a + (c-b);
+	}
+	draw(img, r, tmp, nil, addpt(tmp->r.min, mulpt(δ, b)));
+
+	/* [a+(c-b), c] gets [a,b] */
+	r = img->r;
+	if(axis==Xaxis){
+		r.min.x = img->r.min.x + a + (c-b);
+		r.max.x = img->r.min.x + c;
+	}else{
+		r.min.y = img->r.min.y + a + (c-b);
+		r.max.y = img->r.min.y + c;
+	}
+	draw(img, r, tmp, nil, addpt(tmp->r.min, mulpt(δ, a)));
+	writefile("swap", img, 1);
+}
+
+/*
+ * Swap adjacent regions as specified by the grating.
+ * We do this by copying the image through the mask twice,
+ * once aligned with the grading and once 180° out of phase.
+ */
+static void
+swapadjacent(Image *img, Image *tmp, int axis, int imgdim, Image *mask, int maskdim)
+{
+	Point δ;
+	Rectangle r0, r1;
+
+	δ = axis==Xaxis ? Pt(1,0) : Pt(0,1);
+
+	r0 = img->r;
+	r1 = img->r;
+	switch(axis){
+	case Xaxis:
+		r0.max.x = imgdim;
+		r1.min.x = imgdim;
+		break;
+	case Yaxis:
+		r0.max.y = imgdim;
+		r1.min.y = imgdim;
+	}
+
+	/*
+	 * r0 is the lower rectangle, while r1 is the upper one.
+	 */
+	draw(tmp, tmp->r, img, nil, 
+}
+
+void
+interlace(Image *im, Image *tmp, int axis, int n, Image *mask, int gran)
+{
+	Point p0, p1;
+	Rectangle r0, r1;
+
+	r0 = im->r;
+	r1 = im->r;
+	switch(axis) {
+	case Xaxis:
+		r0.max.x = n;
+		r1.min.x = n;
+		p0 = (Point){gran, 0};
+		p1 = (Point){-gran, 0};
+		break;
+	case Yaxis:
+		r0.max.y = n;
+		r1.min.y = n;
+		p0 = (Point){0, gran};
+		p1 = (Point){0, -gran};
+		break;
+	}
+
+	draw(tmp, im->r, im, display->black, im->r.min);
+	gendraw(im, r0, tmp, p0, mask, mask->r.min);
+	gendraw(im, r0, tmp, p1, mask, p1);
+}
+
+
+static void
+writefile(char *name, Image *im, int gran)
+{
+	static int c = 100;
+	int fd;
+	char buf[200];
+
+	snprint(buf, sizeof buf, "%d%s%d", c++, name, gran);
+	fd = create(buf, OWRITE, 0666);
+	if(fd < 0)
+		return;	
+	writeimage(fd, im, 0);
+	close(fd);
+}
+
diff --git a/src/cmd/page/page.c b/src/cmd/page/page.c
new file mode 100644
index 00000000..3669ebfb
--- /dev/null
+++ b/src/cmd/page/page.c
@@ -0,0 +1,236 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include "page.h"
+
+int resizing;
+int mknewwindow;
+int doabort;
+int chatty;
+int reverse = -1;
+int goodps = 1;
+int ppi = 100;
+int teegs = 0;
+int truetoboundingbox;
+int textbits=4, gfxbits=4;
+int wctlfd = -1;
+int stdinfd;
+int truecolor;
+int imagemode;
+int notewatcher;
+int notegp;
+
+int
+watcher(void *v, char *x)
+{
+	USED(v);
+
+	if(strcmp(x, "die") != 0)
+		postnote(PNGROUP, notegp, x);
+	_exits(0);
+	return 0;
+}
+
+int
+bell(void *u, char *x)
+{
+	if(x && strcmp(x, "hangup") == 0)
+		_exits(0);
+
+	if(x && strstr(x, "die") == nil)
+		fprint(2, "postnote %d: %s\n", getpid(), x);
+
+	/* alarms come from the gs monitor */
+	if(x && strstr(x, "alarm")){
+		postnote(PNGROUP, getpid(), "die (gs error)");
+		postnote(PNPROC, notewatcher, "die (gs error)");
+	}
+
+	/* function mentions u so that it's in the stack trace */
+	if((u == nil || u != x) && doabort)
+		abort();
+
+/*	fprint(2, "exiting %d\n", getpid()); */
+	wexits("note");
+	return 0;
+}
+
+static int
+afmt(Fmt *fmt)
+{
+	char *s;
+
+	s = va_arg(fmt->args, char*);
+	if(s == nil || s[0] == '\0')
+		return fmtstrcpy(fmt, "");
+	else
+		return fmtprint(fmt, "%#q", s);
+}
+
+void
+usage(void)
+{
+	fprint(2, "usage: page [-biRrw] [-p ppi] file...\n");
+	exits("usage");
+}
+
+void
+main(int argc, char **argv)
+{
+	Document *doc;
+	Biobuf *b;
+	enum { Ninput = 16 };
+	uchar buf[Ninput+1];
+	int readstdin;
+
+	ARGBEGIN{
+	/* "temporary" debugging options */
+	case 'P':
+		goodps = 0;
+		break;
+	case 'v':
+		chatty++;
+		break;
+	case 'V':
+		teegs++;
+		break;
+	case 'a':
+		doabort++;
+		break;
+	case 'T':
+		textbits = atoi(EARGF(usage()));
+		gfxbits = atoi(EARGF(usage()));
+		break;
+
+	/* real options */
+	case 'R':
+		resizing = 1;
+		break;
+	case 'r':
+		reverse = 1;
+		break;
+	case 'p':
+		ppi = atoi(EARGF(usage()));
+		break;
+	case 'b':
+		truetoboundingbox = 1;
+		break;
+	case 'w':
+		mknewwindow = 1;
+		resizing = 1;
+		break;
+	case 'i':
+		imagemode = 1;
+		break;
+	default:
+		usage();
+	}ARGEND;
+
+	notegp = getpid();
+
+	switch(notewatcher = fork()){
+	case -1:
+		sysfatal("fork\n");
+		exits(0);
+	default:
+		break;
+	case 0:
+		atnotify(watcher, 1);
+		for(;;)
+			sleep(1000);
+		_exits(0);
+	}
+
+	rfork(RFNOTEG);
+	atnotify(bell, 1);
+
+	readstdin = 0;
+	if(imagemode == 0 && argc == 0){
+		readstdin = 1;
+		stdinfd = dup(0, -1);
+		close(0);
+		open("/dev/cons", OREAD);
+	}
+
+	quotefmtinstall();
+	fmtinstall('a', afmt);
+
+	fmtinstall('R', Rfmt);
+	fmtinstall('P', Pfmt);
+
+	if(readstdin){
+		b = nil;
+		if(readn(stdinfd, buf, Ninput) != Ninput){
+			fprint(2, "page: short read reading %s\n", argv[0]);
+			wexits("read");
+		}
+	}else if(argc != 0){
+		if(!(b = Bopen(argv[0], OREAD))) {
+			fprint(2, "page: cannot open \"%s\"\n", argv[0]);
+			wexits("open");
+		}	
+
+		if(Bread(b, buf, Ninput) != Ninput) {
+			fprint(2, "page: short read reading %s\n", argv[0]);
+			wexits("read");
+		}
+	}else
+		b = nil;
+
+	buf[Ninput] = '\0';
+	if(imagemode)
+		doc = initgfx(nil, 0, nil, nil, 0);
+	else if(strncmp((char*)buf, "%PDF-", 5) == 0)
+		doc = initpdf(b, argc, argv, buf, Ninput);
+	else if(strncmp((char*)buf, "\x04%!", 2) == 0)
+		doc = initps(b, argc, argv, buf, Ninput);
+	else if(buf[0] == '\x1B' && strstr((char*)buf, "@PJL"))
+		doc = initps(b, argc, argv, buf, Ninput);
+	else if(strncmp((char*)buf, "%!", 2) == 0)
+		doc = initps(b, argc, argv, buf, Ninput);
+	else if(strcmp((char*)buf, "\xF7\x02\x01\x83\x92\xC0\x1C;") == 0)
+		doc = initdvi(b, argc, argv, buf, Ninput);
+	else if(strncmp((char*)buf, "\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1", 8) == 0)
+		doc = initmsdoc(b, argc, argv, buf, Ninput);
+	else if(strncmp((char*)buf, "x T ", 4) == 0)
+		doc = inittroff(b, argc, argv, buf, Ninput);
+	else {
+		if(ppi != 100) {
+			fprint(2, "page: you can't specify -p with graphic files\n");
+			wexits("-p and graphics");
+		}
+		doc = initgfx(b, argc, argv, buf, Ninput);
+	}
+
+	if(doc == nil) {
+		fprint(2, "page: error reading file: %r\n");
+		wexits("document init");
+	}
+
+	if(doc->npage < 1 && !imagemode) {
+		fprint(2, "page: no pages found?\n");
+		wexits("pagecount");
+	}
+
+	if(reverse == -1) /* neither cmdline nor ps reader set it */
+		reverse = 0;
+
+	if(initdraw(0, 0, "page") < 0){
+		fprint(2, "page: initdraw failed: %r\n");
+		wexits("initdraw");
+	}
+	truecolor = screen->depth > 8;
+	viewer(doc);
+	wexits(0);
+}
+
+void
+wexits(char *s)
+{
+	if(s && *s && strcmp(s, "note") != 0 && mknewwindow)
+		sleep(10*1000);
+	postnote(PNPROC, notewatcher, "die");
+	exits(s);
+}
diff --git a/src/cmd/page/page.h b/src/cmd/page/page.h
new file mode 100644
index 00000000..aa19ff71
--- /dev/null
+++ b/src/cmd/page/page.h
@@ -0,0 +1,84 @@
+#include <cursor.h>
+
+typedef struct Document Document;
+
+struct Document {
+	char *docname;
+	int npage;
+	int fwdonly;
+	char* (*pagename)(Document*, int);
+	Image* (*drawpage)(Document*, int);
+	int	(*addpage)(Document*, char*);
+	int	(*rmpage)(Document*, int);
+	Biobuf *b;
+	void *extra;
+};
+
+void *emalloc(int);
+void *erealloc(void*, int);
+char *estrdup(char*);
+int spawncmd(char*, char **, int, int, int);
+
+int spooltodisk(uchar*, int, char**);
+int stdinpipe(uchar*, int);
+Document *initps(Biobuf*, int, char**, uchar*, int);
+Document *initpdf(Biobuf*, int, char**, uchar*, int);
+Document *initgfx(Biobuf*, int, char**, uchar*, int);
+Document *inittroff(Biobuf*, int, char**, uchar*, int);
+Document *initdvi(Biobuf*, int, char**, uchar*, int);
+Document *initmsdoc(Biobuf*, int, char**, uchar*, int);
+
+void viewer(Document*);
+extern Cursor reading;
+extern int chatty;
+extern int goodps;
+extern int textbits, gfxbits;
+extern int reverse;
+extern int clean;
+extern int ppi;
+extern int teegs;
+extern int truetoboundingbox;
+extern int wctlfd;
+extern int resizing;
+extern int mknewwindow;
+
+void rot180(Image*);
+Image *rot90(Image*);
+Image *resample(Image*, Image*);
+
+/* ghostscript interface shared by ps, pdf */
+typedef struct GSInfo	GSInfo;
+struct GSInfo {
+	int gsfd;
+	Biobuf gsrd;
+	int gspid;
+	int gsdfd;
+	int ppi;
+};
+void	waitgs(GSInfo*);
+int	gscmd(GSInfo*, char*, ...);
+int	spawngs(GSInfo*);
+void	setdim(GSInfo*, Rectangle, int, int);
+int	spawnwriter(GSInfo*, Biobuf*);
+Rectangle	screenrect(void);
+void	newwin(void);
+void	zerox(void);
+Rectangle winrect(void);
+void	resize(int, int);
+int	max(int, int);
+int	min(int, int);
+void	wexits(char*);
+Image*	xallocimage(Display*, Rectangle, ulong, int, ulong);
+int	bell(void*, char*);
+int	opentemp(char *template);
+
+extern int stdinfd;
+extern int truecolor;
+
+/* BUG BUG BUG BUG BUG: cannot use new draw operations in drawterm,
+ * or in vncs, and there is a bug in the kernel for copying images
+ * from cpu memory -> video memory (memmove is not being used).
+ * until all that is settled, ignore the draw operators.
+ */
+#define drawop(a,b,c,d,e,f) draw(a,b,c,d,e)
+#define gendrawop(a,b,c,d,e,f,g) gendraw(a,b,c,d,e,f)
diff --git a/src/cmd/page/pdf.c b/src/cmd/page/pdf.c
new file mode 100644
index 00000000..44615a21
--- /dev/null
+++ b/src/cmd/page/pdf.c
@@ -0,0 +1,155 @@
+/*
+ * pdf.c
+ * 
+ * pdf file support for page
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include "page.h"
+
+typedef struct PDFInfo	PDFInfo;
+struct PDFInfo {
+	GSInfo gs;
+	Rectangle *pagebbox;
+};
+
+static Image*	pdfdrawpage(Document *d, int page);
+static char*	pdfpagename(Document*, int);
+
+char *pdfprolog = 
+#include "pdfprolog.c"
+	;
+
+Rectangle
+pdfbbox(GSInfo *gs)
+{
+	char *p;
+	char *f[4];
+	Rectangle r;
+	
+	r = Rect(0,0,0,0);
+	waitgs(gs);
+	gscmd(gs, "/CropBox knownoget {} {[0 0 0 0]} ifelse PAGE==\n");
+	p = Brdline(&gs->gsrd, '\n');
+	p[Blinelen(&gs->gsrd)-1] ='\0';
+	if(p[0] != '[')
+		return r;
+	if(tokenize(p+1, f, 4) != 4)
+		return r;
+	r = Rect(atoi(f[0]), atoi(f[1]), atoi(f[2]), atoi(f[3]));
+	waitgs(gs);
+	return r;
+}
+
+Document*
+initpdf(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf)
+{
+	Document *d;
+	PDFInfo *pdf;
+	char *p;
+	char *fn;
+	char fdbuf[20];
+	int fd;
+	int i, npage;
+	Rectangle bbox;
+
+	if(argc > 1) {
+		fprint(2, "can only view one pdf file at a time\n");
+		return nil;
+	}
+
+	fprint(2, "reading through pdf...\n");
+	if(b == nil){	/* standard input; spool to disk (ouch) */
+		fd = spooltodisk(buf, nbuf, &fn);
+		sprint(fdbuf, "/fd/%d", fd);
+		b = Bopen(fdbuf, OREAD);
+		if(b == nil){
+			fprint(2, "cannot open disk spool file\n");
+			wexits("Bopen temp");
+		}
+	}else
+		fn = argv[0];
+
+	/* sanity check */
+	Bseek(b, 0, 0);
+	if(!(p = Brdline(b, '\n')) && !(p = Brdline(b, '\r'))) {
+		fprint(2, "cannot find end of first line\n");
+		wexits("initps");
+	}
+	if(strncmp(p, "%PDF-", 5) != 0) {
+		werrstr("not pdf");
+		return nil;
+	}
+
+	/* setup structures so one free suffices */
+	p = emalloc(sizeof(*d) + sizeof(*pdf));
+	d = (Document*) p;
+	p += sizeof(*d);
+	pdf = (PDFInfo*) p;
+
+	d->extra = pdf;
+	d->b = b;
+	d->drawpage = pdfdrawpage;
+	d->pagename = pdfpagename;
+	d->fwdonly = 0;
+
+	if(spawngs(&pdf->gs) < 0)
+		return nil;
+
+	gscmd(&pdf->gs, "%s", pdfprolog);
+	waitgs(&pdf->gs);
+
+	setdim(&pdf->gs, Rect(0,0,0,0), ppi, 0);
+	gscmd(&pdf->gs, "(%s) (r) file pdfopen begin\n", fn);
+	gscmd(&pdf->gs, "pdfpagecount PAGE==\n");
+	p = Brdline(&pdf->gs.gsrd, '\n');
+	npage = atoi(p);
+	if(npage < 1) {
+		fprint(2, "no pages?\n");
+		return nil;
+	}
+	d->npage = npage;
+	d->docname = argv[0];
+
+	gscmd(&pdf->gs, "Trailer\n");
+	bbox = pdfbbox(&pdf->gs);
+
+	pdf->pagebbox = emalloc(sizeof(Rectangle)*npage);
+	for(i=0; i<npage; i++) {
+		gscmd(&pdf->gs, "%d pdfgetpage\n", i+1);
+		pdf->pagebbox[i] = pdfbbox(&pdf->gs);
+		if(Dx(pdf->pagebbox[i]) <= 0)
+			pdf->pagebbox[i] = bbox;
+	}
+
+	return d;
+}
+
+static Image*
+pdfdrawpage(Document *doc, int page)
+{
+	PDFInfo *pdf = doc->extra;
+	Image *im;
+
+	gscmd(&pdf->gs, "%d DoPDFPage\n", page+1);
+	im = readimage(display, pdf->gs.gsdfd, 0);
+	if(im == nil) {
+		fprint(2, "fatal: readimage error %r\n");
+		wexits("readimage");
+	}
+	waitgs(&pdf->gs);
+	return im;
+}
+
+static char*
+pdfpagename(Document *d, int page)
+{
+	static char str[15];
+	USED(d);
+	sprint(str, "p %d", page+1);
+	return str;
+}
diff --git a/src/cmd/page/pdfprolog.c b/src/cmd/page/pdfprolog.c
new file mode 100644
index 00000000..8493e6d2
--- /dev/null
+++ b/src/cmd/page/pdfprolog.c
@@ -0,0 +1,29 @@
+"/Page null def\n"
+"/Page# 0 def\n"
+"/PDFSave null def\n"
+"/DSCPageCount 0 def\n"
+"/DoPDFPage {dup /Page# exch store pdfgetpage mypdfshowpage } def\n"
+"\n"
+"/pdfshowpage_mysetpage {	% <pagedict> pdfshowpage_mysetpage <pagedict>\n"
+"  dup /CropBox pget {\n"
+"      boxrect\n"
+"      2 array astore /PageSize exch 4 2 roll\n"
+"      neg exch neg exch 2 array astore /PageOffset exch\n"
+"      << 5 1 roll >> setpagedevice\n"
+"  } if\n"
+"} bind def\n"
+"\n"
+"/mypdfshowpage		% <pagedict> pdfshowpage -\n"
+" { dup /Page exch store\n"
+"   pdfshowpage_init \n"
+"   pdfshowpage_setpage \n"
+"   pdfshowpage_mysetpage\n"
+"   save /PDFSave exch store\n"
+"   (before exec) VMDEBUG\n"
+"     pdfshowpage_finish\n"
+"   (after exec) VMDEBUG\n"
+"   PDFSave restore\n"
+" } bind def\n"
+"\n"
+"GS_PDF_ProcSet begin\n"
+"pdfdict begin\n"
diff --git a/src/cmd/page/ps.c b/src/cmd/page/ps.c
new file mode 100644
index 00000000..46ad5cdb
--- /dev/null
+++ b/src/cmd/page/ps.c
@@ -0,0 +1,450 @@
+/*
+ * ps.c
+ * 
+ * provide postscript file reading support for page
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include <ctype.h>
+#include "page.h"
+
+typedef struct PSInfo	PSInfo;
+typedef struct Page	Page;
+	
+struct Page {
+	char *name;
+	int offset;			/* offset of page beginning within file */
+};
+
+struct PSInfo {
+	GSInfo gs;
+	Rectangle bbox;	/* default bounding box */
+	Page *page;
+	int npage;
+	int clueless;	/* don't know where page boundaries are */
+	long psoff;	/* location of %! in file */
+	char ctm[256];
+};
+
+static int	pswritepage(Document *d, int fd, int page);
+static Image*	psdrawpage(Document *d, int page);
+static char*	pspagename(Document*, int);
+
+#define R(r) (r).min.x, (r).min.y, (r).max.x, (r).max.y
+Rectangle
+rdbbox(char *p)
+{
+	Rectangle r;
+	int a;
+	char *f[4];
+	while(*p == ':' || *p == ' ' || *p == '\t')
+		p++;
+	if(tokenize(p, f, 4) != 4)
+		return Rect(0,0,0,0);
+	r = Rect(atoi(f[0]), atoi(f[1]), atoi(f[2]), atoi(f[3]));
+	r = canonrect(r);
+	if(Dx(r) <= 0 || Dy(r) <= 0)
+		return Rect(0,0,0,0);
+
+	if(truetoboundingbox)
+		return r;
+
+	/* initdraw not called yet, can't use %R */
+	if(chatty) fprint(2, "[%d %d %d %d] -> ", R(r));
+	/*
+	 * attempt to sniff out A4, 8½×11, others
+	 * A4 is 596×842
+	 * 8½×11 is 612×792
+	 */
+
+	a = Dx(r)*Dy(r);
+	if(a < 300*300){	/* really small, probably supposed to be */
+		/* empty */
+	} else if(Dx(r) <= 596 && r.max.x <= 596 && Dy(r) > 792 && Dy(r) <= 842 && r.max.y <= 842)	/* A4 */
+		r = Rect(0, 0, 596, 842);
+	else {	/* cast up to 8½×11 */
+		if(Dx(r) <= 612 && r.max.x <= 612){
+			r.min.x = 0;
+			r.max.x = 612;
+		}
+		if(Dy(r) <= 792 && r.max.y <= 792){
+			r.min.y = 0;
+			r.max.y = 792;
+		}
+	}
+	if(chatty) fprint(2, "[%d %d %d %d]\n", R(r));
+	return r;
+}
+
+#define RECT(X) X.min.x, X.min.y, X.max.x, X.max.y
+
+int
+prefix(char *x, char *y)
+{
+	return strncmp(x, y, strlen(y)) == 0;
+}
+
+/*
+ * document ps is really being printed as n-up pages.
+ * we need to treat every n pages as 1.
+ */
+void
+repaginate(PSInfo *ps, int n)
+{
+	int i, np, onp;
+	Page *page;
+
+	page = ps->page;
+	onp = ps->npage;
+	np = (ps->npage+n-1)/n;
+
+	if(chatty) {
+		for(i=0; i<=onp+1; i++)
+			print("page %d: %d\n", i, page[i].offset);
+	}
+
+	for(i=0; i<np; i++)
+		page[i] = page[n*i];
+
+	/* trailer */
+	page[np] = page[onp];
+
+	/* EOF */
+	page[np+1] = page[onp+1];
+
+	ps->npage = np;
+
+	if(chatty) {
+		for(i=0; i<=np+1; i++)
+			print("page %d: %d\n", i, page[i].offset);
+	}
+
+}
+
+Document*
+initps(Biobuf *b, int argc, char **argv, uchar *buf, int nbuf)
+{
+	Document *d;
+	PSInfo *ps;
+	char *p;
+	char *q, *r;
+	char eol;
+	char *nargv[1];
+	char fdbuf[20];
+	char tmp[32];
+	int fd;
+	int i;
+	int incomments;
+	int cantranslate;
+	int trailer=0;
+	int nesting=0;
+	int dumb=0;
+	int landscape=0;
+	long psoff;
+	long npage, mpage;
+	Page *page;
+	Rectangle bbox = Rect(0,0,0,0);
+
+	if(argc > 1) {
+		fprint(2, "can only view one ps file at a time\n");
+		return nil;
+	}
+
+	fprint(2, "reading through postscript...\n");
+	if(b == nil){	/* standard input; spool to disk (ouch) */
+		fd = spooltodisk(buf, nbuf, nil);
+		sprint(fdbuf, "/fd/%d", fd);
+		b = Bopen(fdbuf, OREAD);
+		if(b == nil){
+			fprint(2, "cannot open disk spool file\n");
+			wexits("Bopen temp");
+		}
+		nargv[0] = fdbuf;
+		argv = nargv;
+	}
+
+	/* find %!, perhaps after PCL nonsense */
+	Bseek(b, 0, 0);
+	psoff = 0;
+	eol = 0;
+	for(i=0; i<16; i++){
+		psoff = Boffset(b);
+		if(!(p = Brdline(b, eol='\n')) && !(p = Brdline(b, eol='\r'))) {
+			fprint(2, "cannot find end of first line\n");
+			wexits("initps");
+		}
+		if(p[0]=='\x1B')
+			p++, psoff++;
+		if(p[0] == '%' && p[1] == '!')
+			break;
+	}
+	if(i == 16){
+		werrstr("not ps");
+		return nil;
+	}
+
+	/* page counting */
+	npage = 0;
+	mpage = 16;
+	page = emalloc(mpage*sizeof(*page));
+	memset(page, 0, mpage*sizeof(*page));
+
+	cantranslate = goodps;
+	incomments = 1;
+Keepreading:
+	while(p = Brdline(b, eol)) {
+		if(p[0] == '%')
+			if(chatty) fprint(2, "ps %.*s\n", utfnlen(p, Blinelen(b)-1), p);
+		if(npage == mpage) {
+			mpage *= 2;
+			page = erealloc(page, mpage*sizeof(*page));
+			memset(&page[npage], 0, npage*sizeof(*page));
+		}
+
+		if(p[0] != '%' || p[1] != '%')
+			continue;
+
+		if(prefix(p, "%%BeginDocument")) {
+			nesting++;
+			continue;
+		}
+		if(nesting > 0 && prefix(p, "%%EndDocument")) {
+			nesting--;
+			continue;
+		}
+		if(nesting)
+			continue;
+
+		if(prefix(p, "%%EndComment")) {
+			incomments = 0;
+			continue;
+		}
+		if(reverse == -1 && prefix(p, "%%PageOrder")) {
+			/* glean whether we should reverse the viewing order */
+			p[Blinelen(b)-1] = 0;
+			if(strstr(p, "Ascend"))
+				reverse = 0;
+			else if(strstr(p, "Descend"))
+				reverse = 1;
+			else if(strstr(p, "Special"))
+				dumb = 1;
+			p[Blinelen(b)-1] = '\n';
+			continue;
+		} else if(prefix(p, "%%Trailer")) {
+			incomments = 1;
+			page[npage].offset = Boffset(b)-Blinelen(b);
+			trailer = 1;
+			continue;
+		} else if(incomments && prefix(p, "%%Orientation")) {
+			if(strstr(p, "Landscape"))
+				landscape = 1;
+		} else if(incomments && Dx(bbox)==0 && prefix(p, q="%%BoundingBox")) {
+			bbox = rdbbox(p+strlen(q)+1);
+			if(chatty)
+				/* can't use %R because haven't initdraw() */
+				fprint(2, "document bbox [%d %d %d %d]\n",
+					RECT(bbox));
+			continue;
+		}
+
+		/*
+		 * If they use the initgraphics command, we can't play our translation tricks.
+		 */
+		p[Blinelen(b)-1] = 0;
+		if((q=strstr(p, "initgraphics")) && ((r=strchr(p, '%'))==nil || r > q))
+			cantranslate = 0;
+		p[Blinelen(b)-1] = eol;
+
+		if(!prefix(p, "%%Page:"))
+			continue;
+
+		/* 
+		 * figure out of the %%Page: line contains a page number
+		 * or some other page description to use in the menu bar.
+		 * 
+		 * lines look like %%Page: x y or %%Page: x
+		 * we prefer just x, and will generate our
+		 * own if necessary.
+		 */
+		p[Blinelen(b)-1] = 0;
+		if(chatty) fprint(2, "page %s\n", p);
+		r = p+7;
+		while(*r == ' ' || *r == '\t')
+			r++;
+		q = r;
+		while(*q && *q != ' ' && *q != '\t')
+			q++;
+		free(page[npage].name);
+		if(*r) {
+			if(*r == '"' && *q == '"')
+				r++, q--;
+			if(*q)
+				*q = 0;
+			page[npage].name = estrdup(r);
+			*q = 'x';
+		} else {
+			snprint(tmp, sizeof tmp, "p %ld", npage+1);
+			page[npage].name = estrdup(tmp);
+		}
+
+		/*
+		 * store the offset info for later viewing
+		 */
+		trailer = 0;
+		p[Blinelen(b)-1] = eol;
+		page[npage++].offset = Boffset(b)-Blinelen(b);
+	}
+	if(Blinelen(b) > 0){
+		fprint(2, "page: linelen %d\n", Blinelen(b));
+		Bseek(b, Blinelen(b), 1);
+		goto Keepreading;
+	}
+
+	if(Dx(bbox) == 0 || Dy(bbox) == 0)
+		bbox = Rect(0,0,612,792);	/* 8½×11 */
+	/*
+	 * if we didn't find any pages, assume the document
+	 * is one big page
+	 */
+	if(npage == 0) {
+		dumb = 1;
+		if(chatty) fprint(2, "don't know where pages are\n");
+		reverse = 0;
+		goodps = 0;
+		trailer = 0;
+		page[npage].name = "p 1";
+		page[npage++].offset = 0;
+	}
+
+	if(npage+2 > mpage) {
+		mpage += 2;
+		page = erealloc(page, mpage*sizeof(*page));
+		memset(&page[mpage-2], 0, 2*sizeof(*page));
+	}
+
+	if(!trailer)
+		page[npage].offset = Boffset(b);
+
+	Bseek(b, 0, 2); /* EOF */
+	page[npage+1].offset = Boffset(b);
+
+	d = emalloc(sizeof(*d));
+	ps = emalloc(sizeof(*ps));
+	ps->page = page;
+	ps->npage = npage;
+	ps->bbox = bbox;
+	ps->psoff = psoff;
+
+	d->extra = ps;
+	d->npage = ps->npage;
+	d->b = b;
+	d->drawpage = psdrawpage;
+	d->pagename = pspagename;
+
+	d->fwdonly = ps->clueless = dumb;
+	d->docname = argv[0];
+
+	if(spawngs(&ps->gs) < 0)
+		return nil;
+
+	if(!cantranslate)
+		bbox.min = ZP;
+	setdim(&ps->gs, bbox, ppi, landscape);
+
+	if(goodps){
+		/*
+		 * We want to only send the page (i.e. not header and trailer) information
+	 	 * for each page, so initialize the device by sending the header now.
+		 */
+		pswritepage(d, ps->gs.gsfd, -1);
+		waitgs(&ps->gs);
+	}
+
+	if(dumb) {
+		fprint(ps->gs.gsfd, "(%s) run\n", argv[0]);
+		fprint(ps->gs.gsfd, "(/fd/3) (w) file dup (THIS IS NOT A PLAN9 BITMAP 01234567890123456789012345678901234567890123456789\\n) writestring flushfile\n");
+	}
+
+	ps->bbox = bbox;
+
+	return d;
+}
+
+static int
+pswritepage(Document *d, int fd, int page)
+{
+	Biobuf *b = d->b;
+	PSInfo *ps = d->extra;
+	int t, n, i;
+	long begin, end;
+	char buf[8192];
+
+	if(page == -1)
+		begin = ps->psoff;
+	else
+		begin = ps->page[page].offset;
+
+	end = ps->page[page+1].offset;
+
+	if(chatty) {
+		fprint(2, "writepage(%d)... from #%ld to #%ld...\n",
+			page, begin, end);
+	}
+	Bseek(b, begin, 0);
+
+	t = end-begin;
+	n = sizeof(buf);
+	if(n > t) n = t;
+	while(t > 0 && (i=Bread(b, buf, n)) > 0) {
+		if(write(fd, buf, i) != i)
+			return -1;
+		t -= i;
+		if(n > t)
+			n = t;
+	}
+	return end-begin;
+}
+
+static Image*
+psdrawpage(Document *d, int page)
+{
+	PSInfo *ps = d->extra;
+	Image *im;
+
+	if(ps->clueless)
+		return readimage(display, ps->gs.gsdfd, 0);
+
+	waitgs(&ps->gs);
+
+	if(goodps)
+		pswritepage(d, ps->gs.gsfd, page);
+	else {
+		pswritepage(d, ps->gs.gsfd, -1);
+		pswritepage(d, ps->gs.gsfd, page);
+		pswritepage(d, ps->gs.gsfd, d->npage);
+	}
+	/*
+	 * If last line terminator is \r, gs will read ahead to check for \n
+	 * so send one to avoid deadlock.
+	 */
+	write(ps->gs.gsfd, "\n", 1);
+	im = readimage(display, ps->gs.gsdfd, 0);
+	if(im == nil) {
+		fprint(2, "fatal: readimage error %r\n");
+		wexits("readimage");
+	}
+	waitgs(&ps->gs);
+
+	return im;
+}
+
+static char*
+pspagename(Document *d, int page)
+{
+	PSInfo *ps = (PSInfo *) d->extra;
+	return ps->page[page].name;
+}
diff --git a/src/cmd/page/rotate.c b/src/cmd/page/rotate.c
new file mode 100644
index 00000000..b2952637
--- /dev/null
+++ b/src/cmd/page/rotate.c
@@ -0,0 +1,474 @@
+/*
+ * rotate an image 180° in O(log Dx + log Dy) /dev/draw writes,
+ * using an extra buffer same size as the image.
+ * 
+ * the basic concept is that you can invert an array by inverting
+ * the top half, inverting the bottom half, and then swapping them.
+ * the code does this slightly backwards to ensure O(log n) runtime.
+ * (If you do it wrong, you can get O(log² n) runtime.)
+ * 
+ * This is usually overkill, but it speeds up slow remote
+ * connections quite a bit.
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <draw.h>
+#include <event.h>
+#include "page.h"
+
+int ndraw = 0;
+enum {
+	Xaxis = 0,
+	Yaxis = 1,
+};
+
+Image *mtmp;
+
+void
+writefile(char *name, Image *im, int gran)
+{
+	static int c = 100;
+	int fd;
+	char buf[200];
+
+	snprint(buf, sizeof buf, "%d%s%d", c++, name, gran);
+	fd = create(buf, OWRITE, 0666);
+	if(fd < 0)
+		return;	
+	writeimage(fd, im, 0);
+	close(fd);
+}
+
+void
+moveup(Image *im, Image *tmp, int a, int b, int c, int axis)
+{
+	Rectangle range;
+	Rectangle dr0, dr1;
+	Point p0, p1;
+
+	if(a == b || b == c)
+		return;
+
+	drawop(tmp, tmp->r, im, nil, im->r.min, S);
+
+	switch(axis){
+	case Xaxis:
+		range = Rect(a, im->r.min.y,  c, im->r.max.y);
+		dr0 = range;
+		dr0.max.x = dr0.min.x+(c-b);
+		p0 = Pt(b, im->r.min.y);
+
+		dr1 = range;
+		dr1.min.x = dr1.max.x-(b-a);
+		p1 = Pt(a, im->r.min.y);
+		break;
+	case Yaxis:
+		range = Rect(im->r.min.x, a,  im->r.max.x, c);
+		dr0 = range;
+		dr0.max.y = dr0.min.y+(c-b);
+		p0 = Pt(im->r.min.x, b);
+
+		dr1 = range;
+		dr1.min.y = dr1.max.y-(b-a);
+		p1 = Pt(im->r.min.x, a);
+		break;
+	}
+	drawop(im, dr0, tmp, nil, p0, S);
+	drawop(im, dr1, tmp, nil, p1, S);
+}
+
+void
+interlace(Image *im, Image *tmp, int axis, int n, Image *mask, int gran)
+{
+	Point p0, p1;
+	Rectangle r0, r1;
+
+	r0 = im->r;
+	r1 = im->r;
+	switch(axis) {
+	case Xaxis:
+		r0.max.x = n;
+		r1.min.x = n;
+		p0 = (Point){gran, 0};
+		p1 = (Point){-gran, 0};
+		break;
+	case Yaxis:
+		r0.max.y = n;
+		r1.min.y = n;
+		p0 = (Point){0, gran};
+		p1 = (Point){0, -gran};
+		break;
+	}
+
+	drawop(tmp, im->r, im, display->opaque, im->r.min, S);
+	gendrawop(im, r0, tmp, p0, mask, mask->r.min, S);
+	gendrawop(im, r0, tmp, p1, mask, p1, S);
+}
+
+/*
+ * Halve the grating period in the mask.
+ * The grating currently looks like 
+ * ####____####____####____####____
+ * where #### is opacity.
+ *
+ * We want
+ * ##__##__##__##__##__##__##__##__
+ * which is achieved by shifting the mask
+ * and drawing on itself through itself.
+ * Draw doesn't actually allow this, so 
+ * we have to copy it first.
+ *
+ *     ####____####____####____####____ (dst)
+ * +   ____####____####____####____#### (src)
+ * in  __####____####____####____####__ (mask)
+ * ===========================================
+ *     ##__##__##__##__##__##__##__##__
+ */
+int
+nextmask(Image *mask, int axis, int maskdim)
+{
+	Point delta;
+
+	delta = axis==Xaxis ? Pt(maskdim,0) : Pt(0,maskdim);
+	drawop(mtmp, mtmp->r, mask, nil, mask->r.min, S);
+	gendrawop(mask, mask->r, mtmp, delta, mtmp, divpt(delta,-2), S);
+//	writefile("mask", mask, maskdim/2);
+	return maskdim/2;
+}
+
+void
+shuffle(Image *im, Image *tmp, int axis, int n, Image *mask, int gran,
+	int lastnn)
+{
+	int nn, left;
+
+	if(gran == 0)
+		return;
+	left = n%(2*gran);
+	nn = n - left;
+
+	interlace(im, tmp, axis, nn, mask, gran);
+//	writefile("interlace", im, gran);
+	
+	gran = nextmask(mask, axis, gran);
+	shuffle(im, tmp, axis, n, mask, gran, nn);
+//	writefile("shuffle", im, gran);
+	moveup(im, tmp, lastnn, nn, n, axis);
+//	writefile("move", im, gran);
+}
+
+void
+rot180(Image *im)
+{
+	Image *tmp, *tmp0;
+	Image *mask;
+	Rectangle rmask;
+	int gran;
+
+	if(chantodepth(im->chan) < 8){
+		/* this speeds things up dramatically; draw is too slow on sub-byte pixel sizes */
+		tmp0 = xallocimage(display, im->r, CMAP8, 0, DNofill);
+		drawop(tmp0, tmp0->r, im, nil, im->r.min, S);
+	}else
+		tmp0 = im;
+
+	tmp = xallocimage(display, tmp0->r, tmp0->chan, 0, DNofill);
+	if(tmp == nil){
+		if(tmp0 != im)
+			freeimage(tmp0);
+		return;
+	}
+	for(gran=1; gran<Dx(im->r); gran *= 2)
+		;
+	gran /= 4;
+
+	rmask.min = ZP;
+	rmask.max = (Point){2*gran, 100};
+
+	mask = xallocimage(display, rmask, GREY1, 1, DTransparent);
+	mtmp = xallocimage(display, rmask, GREY1, 1, DTransparent);
+	if(mask == nil || mtmp == nil) {
+		fprint(2, "out of memory during rot180: %r\n");
+		wexits("memory");
+	}
+	rmask.max.x = gran;
+	drawop(mask, rmask, display->opaque, nil, ZP, S);
+//	writefile("mask", mask, gran);
+	shuffle(im, tmp, Xaxis, Dx(im->r), mask, gran, 0);
+	freeimage(mask);
+	freeimage(mtmp);
+
+	for(gran=1; gran<Dy(im->r); gran *= 2)
+		;
+	gran /= 4;
+	rmask.max = (Point){100, 2*gran};
+	mask = xallocimage(display, rmask, GREY1, 1, DTransparent);
+	mtmp = xallocimage(display, rmask, GREY1, 1, DTransparent);
+	if(mask == nil || mtmp == nil) {
+		fprint(2, "out of memory during rot180: %r\n");
+		wexits("memory");
+	}
+	rmask.max.y = gran;
+	drawop(mask, rmask, display->opaque, nil, ZP, S);
+	shuffle(im, tmp, Yaxis, Dy(im->r), mask, gran, 0);
+	freeimage(mask);
+	freeimage(mtmp);
+	freeimage(tmp);
+	if(tmp0 != im)
+		freeimage(tmp0);
+}
+
+/* rotates an image 90 degrees clockwise */
+Image *
+rot90(Image *im)
+{
+	Image *tmp;
+	int i, j, dx, dy;
+
+	dx = Dx(im->r);
+	dy = Dy(im->r);
+	tmp = xallocimage(display, Rect(0, 0, dy, dx), im->chan, 0, DCyan);
+	if(tmp == nil) {
+		fprint(2, "out of memory during rot90: %r\n");
+		wexits("memory");
+	}
+
+	for(j = 0; j < dx; j++) {
+		for(i = 0; i < dy; i++) {
+			drawop(tmp, Rect(i, j, i+1, j+1), im, nil, Pt(j, dy-(i+1)), S);
+		}
+	}
+	freeimage(im);
+
+	return(tmp);
+}
+
+/* from resample.c -- resize from → to using interpolation */
+
+
+#define K2 7	/* from -.7 to +.7 inclusive, meaning .2 into each adjacent pixel */
+#define NK (2*K2+1)
+double K[NK];
+
+double
+fac(int L)
+{
+	int i, f;
+
+	f = 1;
+	for(i=L; i>1; --i)
+		f *= i;
+	return f;
+}
+
+/* 
+ * i0(x) is the modified Bessel function, Σ (x/2)^2L / (L!)²
+ * There are faster ways to calculate this, but we precompute
+ * into a table so let's keep it simple.
+ */
+double
+i0(double x)
+{
+	double v;
+	int L;
+
+	v = 1.0;
+	for(L=1; L<10; L++)
+		v += pow(x/2., 2*L)/pow(fac(L), 2);
+	return v;
+}
+
+double
+kaiser(double x, double tau, double alpha)
+{
+	if(fabs(x) > tau)
+		return 0.;
+	return i0(alpha*sqrt(1-(x*x/(tau*tau))))/i0(alpha);
+}
+
+void
+resamplex(uchar *in, int off, int d, int inx, uchar *out, int outx)
+{
+	int i, x, k;
+	double X, xx, v, rat;
+
+
+	rat = (double)inx/(double)outx;
+	for(x=0; x<outx; x++){
+		if(inx == outx){
+			/* don't resample if size unchanged */
+			out[off+x*d] = in[off+x*d];
+			continue;
+		}
+		v = 0.0;
+		X = x*rat;
+		for(k=-K2; k<=K2; k++){
+			xx = X + rat*k/10.;
+			i = xx;
+			if(i < 0)
+				i = 0;
+			if(i >= inx)
+				i = inx-1;
+			v += in[off+i*d] * K[K2+k];
+		}
+		out[off+x*d] = v;
+	}
+}
+
+void
+resampley(uchar **in, int off, int iny, uchar **out, int outy)
+{
+	int y, i, k;
+	double Y, yy, v, rat;
+
+	rat = (double)iny/(double)outy;
+	for(y=0; y<outy; y++){
+		if(iny == outy){
+			/* don't resample if size unchanged */
+			out[y][off] = in[y][off];
+			continue;
+		}
+		v = 0.0;
+		Y = y*rat;
+		for(k=-K2; k<=K2; k++){
+			yy = Y + rat*k/10.;
+			i = yy;
+			if(i < 0)
+				i = 0;
+			if(i >= iny)
+				i = iny-1;
+			v += in[i][off] * K[K2+k];
+		}
+		out[y][off] = v;
+	}
+
+}
+
+Image*
+resample(Image *from, Image *to)
+{
+	int i, j, bpl, nchan;
+	uchar **oscan, **nscan;
+	char tmp[20];
+	int xsize, ysize;
+	double v;
+	Image *t1, *t2;
+	ulong tchan;
+
+	for(i=-K2; i<=K2; i++){
+		K[K2+i] = kaiser(i/10., K2/10., 4.);
+	}
+
+	/* normalize */
+	v = 0.0;
+	for(i=0; i<NK; i++)
+		v += K[i];
+	for(i=0; i<NK; i++)
+		K[i] /= v;
+
+	switch(from->chan){
+	case GREY8:
+	case RGB24:
+	case RGBA32:
+	case ARGB32:
+	case XRGB32:
+		break;
+
+	case CMAP8:
+	case RGB15:
+	case RGB16:
+		tchan = RGB24;
+		goto Convert;
+
+	case GREY1:
+	case GREY2:
+	case GREY4:
+		tchan = GREY8;
+	Convert:
+		/* use library to convert to byte-per-chan form, then convert back */
+		t1 = xallocimage(display, Rect(0, 0, Dx(from->r), Dy(from->r)), tchan, 0, DNofill);
+		if(t1 == nil) {
+			fprint(2, "out of memory for temp image 1 in resample: %r\n");
+			wexits("memory");
+		}
+		drawop(t1, t1->r, from, nil, ZP, S);
+		t2 = xallocimage(display, to->r, tchan, 0, DNofill);
+		if(t2 == nil) {
+			fprint(2, "out of memory temp image 2 in resample: %r\n");
+			wexits("memory");
+		}
+		resample(t1, t2);
+		drawop(to, to->r, t2, nil, ZP, S);
+		freeimage(t1);
+		freeimage(t2);
+		return to;
+
+	default:
+		sysfatal("can't handle channel type %s", chantostr(tmp, from->chan));
+	}
+
+	xsize = Dx(to->r);
+	ysize = Dy(to->r);
+	oscan = malloc(Dy(from->r)*sizeof(uchar*));
+	nscan = malloc(max(ysize, Dy(from->r))*sizeof(uchar*));
+	if(oscan == nil || nscan == nil)
+		sysfatal("can't allocate: %r");
+
+	/* unload original image into scan lines */
+	bpl = bytesperline(from->r, from->depth);
+	for(i=0; i<Dy(from->r); i++){
+		oscan[i] = malloc(bpl);
+		if(oscan[i] == nil)
+			sysfatal("can't allocate: %r");
+		j = unloadimage(from, Rect(from->r.min.x, from->r.min.y+i, from->r.max.x, from->r.min.y+i+1), oscan[i], bpl);
+		if(j != bpl)
+			sysfatal("unloadimage");
+	}
+
+	/* allocate scan lines for destination. we do y first, so need at least Dy(from->r) lines */
+	bpl = bytesperline(Rect(0, 0, xsize, Dy(from->r)), from->depth);
+	for(i=0; i<max(ysize, Dy(from->r)); i++){
+		nscan[i] = malloc(bpl);
+		if(nscan[i] == nil)
+			sysfatal("can't allocate: %r");
+	}
+
+	/* resample in X */
+	nchan = from->depth/8;
+	for(i=0; i<Dy(from->r); i++){
+		for(j=0; j<nchan; j++){
+			if(j==0 && from->chan==XRGB32)
+				continue;
+			resamplex(oscan[i], j, nchan, Dx(from->r), nscan[i], xsize);
+		}
+		free(oscan[i]);
+		oscan[i] = nscan[i];
+		nscan[i] = malloc(bpl);
+		if(nscan[i] == nil)
+			sysfatal("can't allocate: %r");
+	}
+
+	/* resample in Y */
+	for(i=0; i<xsize; i++)
+		for(j=0; j<nchan; j++)
+			resampley(oscan, nchan*i+j, Dy(from->r), nscan, ysize);
+
+	/* pack data into destination */
+	bpl = bytesperline(to->r, from->depth);
+	for(i=0; i<ysize; i++){
+		j = loadimage(to, Rect(0, i, xsize, i+1), nscan[i], bpl);
+		if(j != bpl)
+			sysfatal("loadimage: %r");
+	}
+
+	for(i=0; i<Dy(from->r); i++){
+		free(oscan[i]);
+		free(nscan[i]);
+	}
+	free(oscan);
+	free(nscan);
+
+	return to;
+}
diff --git a/src/cmd/page/util.c b/src/cmd/page/util.c
new file mode 100644
index 00000000..22832baa
--- /dev/null
+++ b/src/cmd/page/util.c
@@ -0,0 +1,131 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <event.h>
+#include <bio.h>
+#include "page.h"
+
+void*
+emalloc(int sz)
+{
+	void *v;
+	v = malloc(sz);
+	if(v == nil) {
+		fprint(2, "out of memory allocating %d\n", sz);
+		wexits("mem");
+	}
+	memset(v, 0, sz);
+	return v;
+}
+
+void*
+erealloc(void *v, int sz)
+{
+	v = realloc(v, sz);
+	if(v == nil) {
+		fprint(2, "out of memory allocating %d\n", sz);
+		wexits("mem");
+	}
+	return v;
+}
+
+char*
+estrdup(char *s)
+{
+	char *t;
+	if((t = strdup(s)) == nil) {
+		fprint(2, "out of memory in strdup(%.10s)\n", s);
+		wexits("mem");
+	}
+	return t;
+}
+
+int
+opentemp(char *template)
+{
+	int fd, i;
+	char *p;
+
+	p = estrdup(template);
+	fd = -1;
+	for(i=0; i<10; i++){
+		mktemp(p);
+		if(access(p, 0) < 0 && (fd=create(p, ORDWR|ORCLOSE, 0400)) >= 0)
+			break;
+		strcpy(p, template);
+	}
+	if(fd < 0){
+		fprint(2, "couldn't make temporary file\n");
+		wexits("Ecreat");
+	}
+	strcpy(template, p);
+	free(p);
+
+	return fd;
+}
+
+/*
+ * spool standard input to /tmp.
+ * we've already read the initial in bytes into ibuf.
+ */
+int
+spooltodisk(uchar *ibuf, int in, char **name)
+{
+	uchar buf[8192];
+	int fd, n;
+	char temp[40];
+
+	strcpy(temp, "/tmp/pagespoolXXXXXXXXX");
+	fd = opentemp(temp);
+	if(name)
+		*name = estrdup(temp);
+
+	if(write(fd, ibuf, in) != in){
+		fprint(2, "error writing temporary file\n");
+		wexits("write temp");
+	}
+
+	while((n = read(stdinfd, buf, sizeof buf)) > 0){
+		if(write(fd, buf, n) != n){
+			fprint(2, "error writing temporary file\n");
+			wexits("write temp0");
+		}
+	}
+	seek(fd, 0, 0);
+	return fd;
+}
+
+/*
+ * spool standard input into a pipe.
+ * we've already ready the first in bytes into ibuf
+ */
+int
+stdinpipe(uchar *ibuf, int in)
+{
+	uchar buf[8192];
+	int n;
+	int p[2];
+	if(pipe(p) < 0){
+		fprint(2, "pipe fails: %r\n");	
+		wexits("pipe");
+	}
+
+	switch(rfork(RFPROC|RFFDG)){
+	case -1:
+		fprint(2, "fork fails: %r\n");
+		wexits("fork");
+	default:
+		close(p[1]);
+		return p[0];
+	case 0:
+		break;
+	}
+
+	close(p[0]);
+	write(p[1], ibuf, in);
+	while((n = read(stdinfd, buf, sizeof buf)) > 0)
+		write(p[1], buf, n);
+
+	_exits(0);
+	return -1;	/* not reached */
+}
diff --git a/src/cmd/page/view.c b/src/cmd/page/view.c
new file mode 100644
index 00000000..92aedeb9
--- /dev/null
+++ b/src/cmd/page/view.c
@@ -0,0 +1,1022 @@
+/*
+ * the actual viewer that handles screen stuff
+ */
+
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <cursor.h>
+#include <event.h>
+#include <bio.h>
+#include <plumb.h>
+#include <ctype.h>
+#include <keyboard.h>
+#include "page.h"
+
+Document *doc;
+Image *im;
+int page;
+int upside = 0;
+int showbottom = 0;		/* on the next showpage, move the image so the bottom is visible. */
+
+Rectangle ulrange;	/* the upper left corner of the image must be in this rectangle */
+Point ul;			/* the upper left corner of the image is at this point on the screen */
+
+Point pclip(Point, Rectangle);
+Rectangle mkrange(Rectangle screenr, Rectangle imr);
+void redraw(Image*);
+
+Cursor reading={
+	{-1, -1},
+	{0xff, 0x80, 0xff, 0x80, 0xff, 0x00, 0xfe, 0x00, 
+	 0xff, 0x00, 0xff, 0x80, 0xff, 0xc0, 0xef, 0xe0, 
+	 0xc7, 0xf0, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0xc0, 
+	 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, },
+	{0x00, 0x00, 0x7f, 0x00, 0x7e, 0x00, 0x7c, 0x00, 
+	 0x7e, 0x00, 0x7f, 0x00, 0x6f, 0x80, 0x47, 0xc0, 
+	 0x03, 0xe0, 0x01, 0xf0, 0x00, 0xe0, 0x00, 0x40, 
+	 0x00, 0x00, 0x01, 0xb6, 0x01, 0xb6, 0x00, 0x00, }
+};
+
+Cursor query = {
+	{-7,-7},
+	{0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe, 
+	 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8, 
+	 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0, 
+	 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, },
+	{0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c, 
+	 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0, 
+	 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80, 
+	 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
+};
+
+enum {
+	Left = 1,
+	Middle = 2,
+	Right = 4,
+
+	RMenu = 3,
+};
+
+void
+unhide(void)
+{
+	static int wctl = -1;
+
+	if(wctl < 0)
+		wctl = open("/dev/wctl", OWRITE);
+	if(wctl < 0)
+		return;
+
+	write(wctl, "unhide", 6);
+}
+
+int 
+max(int a, int b)
+{
+	return a > b ? a : b;
+}
+
+int 
+min(int a, int b)
+{
+	return a < b ? a : b;
+}
+
+
+char*
+menugen(int n)
+{
+	static char menustr[32];
+	char *p;
+	int len;
+
+	if(n == doc->npage)
+		return "exit";
+	if(n > doc->npage)
+		return nil;
+
+	if(reverse)
+		n = doc->npage-1-n;
+
+	p = doc->pagename(doc, n);
+	len = (sizeof menustr)-2;
+
+	if(strlen(p) > len && strrchr(p, '/'))
+		p = strrchr(p, '/')+1;
+	if(strlen(p) > len)
+		p = p+strlen(p)-len;
+
+	strcpy(menustr+1, p);
+	if(page == n)
+		menustr[0] = '>';
+	else
+		menustr[0] = ' ';
+	return menustr;
+}
+
+void
+showpage(int page, Menu *m)
+{
+	Image *tmp;
+
+	if(doc->fwdonly)
+		m->lasthit = 0;	/* this page */
+	else
+		m->lasthit = reverse ? doc->npage-1-page : page;
+	
+	esetcursor(&reading);
+	freeimage(im);
+	if((page < 0 || page >= doc->npage) && !doc->fwdonly){
+		im = nil;
+		return;
+	}
+	im = doc->drawpage(doc, page);
+	if(im == nil) {
+		if(doc->fwdonly)	/* this is how we know we're out of pages */
+			wexits(0);
+
+		im = xallocimage(display, Rect(0,0,50,50), GREY1, 1, DBlack);
+		if(im == nil) {
+			fprint(2, "out of memory: %r\n");
+			wexits("memory");
+		}
+		string(im, ZP, display->white, ZP, display->defaultfont, "?");
+	}else if(resizing){
+		resize(Dx(im->r), Dy(im->r));
+	}
+	if(im->r.min.x > 0 || im->r.min.y > 0) {
+		tmp = xallocimage(display, Rect(0, 0, Dx(im->r), Dy(im->r)), im->chan, 0, DNofill);
+		if(tmp == nil) {
+			fprint(2, "out of memory during showpage: %r\n");
+			wexits("memory");
+		}
+		drawop(tmp, tmp->r, im, nil, im->r.min, S);
+		freeimage(im);
+		im = tmp;
+	}
+
+	if(upside)
+		rot180(im);
+
+	esetcursor(nil);
+	if(showbottom){
+		ul.y = screen->r.max.y - Dy(im->r);
+		showbottom = 0;
+	}
+
+	redraw(screen);
+	flushimage(display, 1);
+}
+
+char*
+writebitmap(void)
+{
+	char basename[64];
+	char name[64+30];
+	static char result[200];
+	char *p, *q;
+	int fd;
+
+	if(im == nil)
+		return "no image";
+
+	memset(basename, 0, sizeof basename);
+	if(doc->docname)
+		strncpy(basename, doc->docname, sizeof(basename)-1);
+	else if((p = menugen(page)) && p[0] != '\0')
+		strncpy(basename, p+1, sizeof(basename)-1);
+
+	if(basename[0]) {
+		if(q = strrchr(basename, '/'))
+			q++;
+		else
+			q = basename;
+		if(p = strchr(q, '.'))
+			*p = 0;
+		
+		memset(name, 0, sizeof name);
+		snprint(name, sizeof(name)-1, "%s.%d.bit", q, page+1);
+		if(access(name, 0) >= 0) {
+			strcat(name, "XXXX");
+			mktemp(name);
+		}
+		if(access(name, 0) >= 0)
+			return "couldn't think of a name for bitmap";
+	} else {
+		strcpy(name, "bitXXXX");
+		mktemp(name);
+		if(access(name, 0) >= 0) 
+			return "couldn't think of a name for bitmap";
+	}
+
+	if((fd = create(name, OWRITE, 0666)) < 0) {
+		snprint(result, sizeof result, "cannot create %s: %r", name);
+		return result;
+	}
+
+	if(writeimage(fd, im, 0) < 0) {
+		snprint(result, sizeof result, "cannot writeimage: %r");
+		close(fd);
+		return result;
+	}
+	close(fd);
+
+	snprint(result, sizeof result, "wrote %s", name);
+	return result;
+}
+
+static void translate(Point);
+
+static int
+showdata(Plumbmsg *msg)
+{
+	char *s;
+
+	s = plumblookup(msg->attr, "action");
+	return s && strcmp(s, "showdata")==0;
+}
+
+/* correspond to entries in miditems[] below,
+ * changing one means you need to change
+ */
+enum{
+	Restore = 0,
+	Zin,
+	Fit,
+	Rot,
+	Upside,
+	Empty1,
+	Next,
+	Prev,
+	Zerox,
+	Empty2,
+	Reverse,
+	Del,
+	Write,
+	Empty3,
+	Exit,
+};
+ 
+void
+viewer(Document *dd)
+{
+	int i, fd, n, oldpage;
+	int nxt;
+	Menu menu, midmenu;
+	Mouse m;
+	Event e;
+	Point dxy, oxy, xy0;
+	Rectangle r;
+	Image *tmp;
+	static char *fwditems[] = { "this page", "next page", "exit", 0 };
+ 	static char *miditems[] = {
+ 		"orig size",
+ 		"zoom in",
+ 		"fit window",
+ 		"rotate 90",
+ 		"upside down",
+ 		"",
+ 		"next",
+ 		"prev",
+		"zerox",
+ 		"", 
+ 		"reverse",
+ 		"discard",
+ 		"write",
+ 		"", 
+ 		"quit", 
+ 		0 
+ 	};
+	char *s;
+	enum { Eplumb = 4 };
+	Plumbmsg *pm;
+
+	doc = dd;    /* save global for menuhit */
+	ul = screen->r.min;
+	einit(Emouse|Ekeyboard);
+	if(doc->addpage != nil)
+		eplumb(Eplumb, "image");
+
+	esetcursor(&reading);
+	r.min = ZP;
+
+	/*
+	 * im is a global pointer to the current image.
+	 * eventually, i think we will have a layer between
+	 * the display routines and the ps/pdf/whatever routines
+	 * to perhaps cache and handle images of different
+	 * sizes, etc.
+	 */
+	im = 0;
+	page = reverse ? doc->npage-1 : 0;
+
+	if(doc->fwdonly) {
+		menu.item = fwditems;
+		menu.gen = 0;
+		menu.lasthit = 0;
+	} else {
+		menu.item = 0;
+		menu.gen = menugen;
+		menu.lasthit = 0;
+	}
+
+	midmenu.item = miditems;
+	midmenu.gen = 0;
+	midmenu.lasthit = Next;
+
+	showpage(page, &menu);
+	esetcursor(nil);
+
+	nxt = 0;
+	for(;;) {
+		/*
+		 * throughout, if doc->fwdonly is set, we restrict the functionality
+		 * a fair amount.  we don't care about doc->npage anymore, and
+		 * all that can be done is select the next page.
+		 */
+		switch(eread(Emouse|Ekeyboard|Eplumb, &e)){
+		case Ekeyboard:
+			if(e.kbdc <= 0xFF && isdigit(e.kbdc)) {
+				nxt = nxt*10+e.kbdc-'0';
+				break;
+			} else if(e.kbdc != '\n')
+				nxt = 0;
+			switch(e.kbdc) {
+			case 'r':	/* reverse page order */
+				if(doc->fwdonly)
+					break;
+				reverse = !reverse;
+				menu.lasthit = doc->npage-1-menu.lasthit;
+
+				/*
+				 * the theory is that if we are reversing the
+				 * document order and are on the first or last
+				 * page then we're just starting and really want
+		 	 	 * to view the other end.  maybe the if
+				 * should be dropped and this should happen always.
+				 */
+				if(page == 0 || page == doc->npage-1) {
+					page = doc->npage-1-page;
+					showpage(page, &menu);
+				}
+				break;
+			case 'w':	/* write bitmap of current screen */
+				esetcursor(&reading);
+				s = writebitmap();
+				if(s)
+					string(screen, addpt(screen->r.min, Pt(5,5)), display->black, ZP,
+						display->defaultfont, s);
+				esetcursor(nil);
+				flushimage(display, 1);
+				break;
+			case 'd':	/* remove image from working set */
+				if(doc->rmpage && page < doc->npage) {
+					if(doc->rmpage(doc, page) >= 0) {
+						if(doc->npage < 0)
+							wexits(0);
+						if(page >= doc->npage)
+							page = doc->npage-1;
+						showpage(page, &menu);
+					}
+				}
+				break;
+			case 'q':
+			case 0x04: /* ctrl-d */
+				wexits(0);
+			case 'u':
+				if(im==nil)
+					break;
+				esetcursor(&reading);
+				rot180(im);
+				esetcursor(nil);
+				upside = !upside;
+				redraw(screen);
+				flushimage(display, 1);
+				break;
+			case '-':
+			case '\b':
+			case Kleft:
+				if(page > 0 && !doc->fwdonly) {
+					--page;
+					showpage(page, &menu);
+				}
+				break;
+			case '\n':
+				if(nxt) {
+					nxt--;
+					if(nxt >= 0 && nxt < doc->npage && !doc->fwdonly)
+						showpage(page=nxt, &menu);
+					nxt = 0;
+					break;
+				}
+				goto Gotonext;
+			case Kright:
+			case ' ':
+			Gotonext:
+				if(doc->npage && ++page >= doc->npage && !doc->fwdonly)
+					wexits(0);
+				showpage(page, &menu);
+				break;
+
+			/*
+			 * The upper y coordinate of the image is at ul.y in screen->r.
+			 * Panning up means moving the upper left corner down.  If the
+			 * upper left corner is currently visible, we need to go back a page.
+			 */
+			case Kup:
+				if(screen->r.min.y <= ul.y && ul.y < screen->r.max.y){
+					if(page > 0 && !doc->fwdonly){
+						--page;
+						showbottom = 1;
+						showpage(page, &menu);
+					}
+				} else {
+					i = Dy(screen->r)/2;
+					if(i > 10)
+						i -= 10;
+					if(i+ul.y > screen->r.min.y)
+						i = screen->r.min.y - ul.y;
+					translate(Pt(0, i));
+				}
+				break;
+
+			/*
+			 * If the lower y coordinate is on the screen, we go to the next page.
+			 * The lower y coordinate is at ul.y + Dy(im->r).
+			 */
+			case Kdown:
+				i = ul.y + Dy(im->r);
+				if(screen->r.min.y <= i && i <= screen->r.max.y){
+					ul.y = screen->r.min.y;
+					goto Gotonext;
+				} else {
+					i = -Dy(screen->r)/2;
+					if(i < -10)
+						i += 10;
+					if(i+ul.y+Dy(im->r) <= screen->r.max.y)
+						i = screen->r.max.y - Dy(im->r) - ul.y - 1;
+					translate(Pt(0, i));
+				}
+				break;
+			default:
+				esetcursor(&query);
+				sleep(1000);
+				esetcursor(nil);
+				break;	
+			}
+			break;
+
+		case Emouse:
+			m = e.mouse;
+			switch(m.buttons){
+			case Left:
+				oxy = m.xy;
+				xy0 = oxy;
+				do {
+					dxy = subpt(m.xy, oxy);
+					oxy = m.xy;	
+					translate(dxy);
+					m = emouse();
+				} while(m.buttons == Left);
+				if(m.buttons) {
+					dxy = subpt(xy0, oxy);
+					translate(dxy);
+				}
+				break;
+	
+			case Middle:
+				if(doc->npage == 0)
+					break;
+
+				n = emenuhit(Middle, &m, &midmenu);
+				if(n == -1)
+					break;
+				switch(n){
+				case Next: 	/* next */
+					if(reverse)
+						page--;
+					else
+						page++;
+					if(page < 0) {
+						if(reverse) return;
+						else page = 0;
+					}
+
+					if((page >= doc->npage) && !doc->fwdonly)
+						return;
+	
+					showpage(page, &menu);
+					nxt = 0;
+					break;
+				case Prev:	/* prev */
+					if(reverse)
+						page++;
+					else
+						page--;
+					if(page < 0) {
+						if(reverse) return;
+						else page = 0;
+					}
+
+					if((page >= doc->npage) && !doc->fwdonly && !reverse)
+						return;
+	
+					showpage(page, &menu);
+					nxt = 0;
+					break;
+				case Zerox:	/* prev */
+					zerox();
+					break;
+				case Zin:	/* zoom in */
+					{
+						double delta;
+						Rectangle r;
+
+						r = egetrect(Middle, &m);
+						if((rectclip(&r, rectaddpt(im->r, ul)) == 0) ||
+							Dx(r) == 0 || Dy(r) == 0)
+							break;
+						/* use the smaller side to expand */
+						if(Dx(r) < Dy(r))
+							delta = (double)Dx(im->r)/(double)Dx(r);
+						else
+							delta = (double)Dy(im->r)/(double)Dy(r);
+
+						esetcursor(&reading);
+						tmp = xallocimage(display, 
+								Rect(0, 0, (int)((double)Dx(im->r)*delta), (int)((double)Dy(im->r)*delta)), 
+								im->chan, 0, DBlack);
+						if(tmp == nil) {
+							fprint(2, "out of memory during zoom: %r\n");
+							wexits("memory");
+						}
+						resample(im, tmp);
+						freeimage(im);
+						im = tmp;
+						esetcursor(nil);
+						ul = screen->r.min;
+						redraw(screen);
+						flushimage(display, 1);
+						break;
+					}
+				case Fit:	/* fit */
+					{
+						double delta;
+						Rectangle r;
+						
+						delta = (double)Dx(screen->r)/(double)Dx(im->r);
+						if((double)Dy(im->r)*delta > Dy(screen->r))
+							delta = (double)Dy(screen->r)/(double)Dy(im->r);
+
+						r = Rect(0, 0, (int)((double)Dx(im->r)*delta), (int)((double)Dy(im->r)*delta));
+						esetcursor(&reading);
+						tmp = xallocimage(display, r, im->chan, 0, DBlack);
+						if(tmp == nil) {
+							fprint(2, "out of memory during fit: %r\n");
+							wexits("memory");
+						}
+						resample(im, tmp);
+						freeimage(im);
+						im = tmp;
+						esetcursor(nil);
+						ul = screen->r.min;
+						redraw(screen);
+						flushimage(display, 1);
+						break;
+					}
+				case Rot:	/* rotate 90 */
+					esetcursor(&reading);
+					im = rot90(im);
+					esetcursor(nil);
+					redraw(screen);
+					flushimage(display, 1);
+					break;
+				case Upside: 	/* upside-down */
+					if(im==nil)
+						break;
+					esetcursor(&reading);
+					rot180(im);
+					esetcursor(nil);
+					upside = !upside;
+					redraw(screen);
+					flushimage(display, 1);
+					break;
+				case Restore:	/* restore */
+					showpage(page, &menu);
+					break;
+				case Reverse:	/* reverse */
+					if(doc->fwdonly)
+						break;
+					reverse = !reverse;
+					menu.lasthit = doc->npage-1-menu.lasthit;
+	
+					if(page == 0 || page == doc->npage-1) {
+						page = doc->npage-1-page;
+						showpage(page, &menu);
+					}
+					break;
+				case Write: /* write */
+					esetcursor(&reading);
+					s = writebitmap();
+					if(s)
+						string(screen, addpt(screen->r.min, Pt(5,5)), display->black, ZP,
+							display->defaultfont, s);
+					esetcursor(nil);
+					flushimage(display, 1);
+					break;
+				case Del: /* delete */
+					if(doc->rmpage && page < doc->npage) {
+						if(doc->rmpage(doc, page) >= 0) {
+							if(doc->npage < 0)
+								wexits(0);
+							if(page >= doc->npage)
+								page = doc->npage-1;
+							showpage(page, &menu);
+						}
+					}
+					break;
+				case Exit:	/* exit */
+					return;
+				case Empty1:
+				case Empty2:
+				case Empty3:
+					break;
+
+				}; 
+
+	
+	
+			case Right:
+				if(doc->npage == 0)
+					break;
+
+				oldpage = page;
+				n = emenuhit(RMenu, &m, &menu);
+				if(n == -1)
+					break;
+	
+				if(doc->fwdonly) {
+					switch(n){
+					case 0:	/* this page */
+						break;
+					case 1:	/* next page */
+						showpage(++page, &menu);
+						break;
+					case 2:	/* exit */
+						return;
+					}
+					break;
+				}
+	
+				if(n == doc->npage)
+					return;
+				else
+					page = reverse ? doc->npage-1-n : n;
+	
+				if(oldpage != page)
+					showpage(page, &menu);
+				nxt = 0;
+				break;
+			}
+			break;
+
+		case Eplumb:
+			pm = e.v;
+			if(pm->ndata <= 0){
+				plumbfree(pm);
+				break;
+			}
+			if(showdata(pm)) {
+				s = estrdup("/tmp/pageplumbXXXXXXX");
+				fd = opentemp(s);
+				write(fd, pm->data, pm->ndata);
+				/* lose fd reference on purpose; the file is open ORCLOSE */
+			} else if(pm->data[0] == '/') {
+				s = estrdup(pm->data);
+			} else {
+				s = emalloc(strlen(pm->wdir)+1+pm->ndata+1);
+				sprint(s, "%s/%s", pm->wdir, pm->data);
+				cleanname(s);
+			}
+			if((i = doc->addpage(doc, s)) >= 0) {
+				page = i;
+				unhide();
+				showpage(page, &menu);
+			}
+			free(s);
+			plumbfree(pm);
+			break;
+		}
+	}
+}
+
+Image *gray;
+
+/*
+ * A draw operation that touches only the area contained in bot but not in top.
+ * mp and sp get aligned with bot.min.
+ */
+static void
+gendrawdiff(Image *dst, Rectangle bot, Rectangle top, 
+	Image *src, Point sp, Image *mask, Point mp, int op)
+{
+	Rectangle r;
+	Point origin;
+	Point delta;
+
+	USED(op);
+
+	if(Dx(bot)*Dy(bot) == 0)
+		return;
+
+	/* no points in bot - top */
+	if(rectinrect(bot, top))
+		return;
+
+	/* bot - top ≡ bot */
+	if(Dx(top)*Dy(top)==0 || rectXrect(bot, top)==0){
+		gendrawop(dst, bot, src, sp, mask, mp, op);
+		return;
+	}
+
+	origin = bot.min;
+	/* split bot into rectangles that don't intersect top */
+	/* left side */
+	if(bot.min.x < top.min.x){
+		r = Rect(bot.min.x, bot.min.y, top.min.x, bot.max.y);
+		delta = subpt(r.min, origin);
+		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
+		bot.min.x = top.min.x;
+	}
+
+	/* right side */
+	if(bot.max.x > top.max.x){
+		r = Rect(top.max.x, bot.min.y, bot.max.x, bot.max.y);
+		delta = subpt(r.min, origin);
+		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
+		bot.max.x = top.max.x;
+	}
+
+	/* top */
+	if(bot.min.y < top.min.y){
+		r = Rect(bot.min.x, bot.min.y, bot.max.x, top.min.y);
+		delta = subpt(r.min, origin);
+		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
+		bot.min.y = top.min.y;
+	}
+
+	/* bottom */
+	if(bot.max.y > top.max.y){
+		r = Rect(bot.min.x, top.max.y, bot.max.x, bot.max.y);
+		delta = subpt(r.min, origin);
+		gendrawop(dst, r, src, addpt(sp, delta), mask, addpt(mp, delta), op);
+		bot.max.y = top.max.y;
+	}
+}
+
+static void
+drawdiff(Image *dst, Rectangle bot, Rectangle top, Image *src, Image *mask, Point p, int op)
+{
+	gendrawdiff(dst, bot, top, src, p, mask, p, op);
+}
+
+/*
+ * Translate the image in the window by delta.
+ */
+static void
+translate(Point delta)
+{
+	Point u;
+	Rectangle r, or;
+
+	if(im == nil)
+		return;
+
+	u = pclip(addpt(ul, delta), ulrange);
+	delta = subpt(u, ul);
+	if(delta.x == 0 && delta.y == 0)
+		return;
+
+	/*
+	 * The upper left corner of the image is currently at ul.
+	 * We want to move it to u.
+	 */
+	or = rectaddpt(Rpt(ZP, Pt(Dx(im->r), Dy(im->r))), ul);
+	r = rectaddpt(or, delta);
+
+	drawop(screen, r, screen, nil, ul, S);
+	ul = u;
+
+	/* fill in gray where image used to be but isn't. */
+	drawdiff(screen, insetrect(or, -2), insetrect(r, -2), gray, nil, ZP, S);
+
+	/* fill in black border */
+	drawdiff(screen, insetrect(r, -2), r, display->black, nil, ZP, S);
+
+	/* fill in image where it used to be off the screen. */
+	if(rectclip(&or, screen->r))
+		drawdiff(screen, r, rectaddpt(or, delta), im, nil, im->r.min, S);
+	else
+		drawop(screen, r, im, nil, im->r.min, S);
+	flushimage(display, 1);
+}
+
+void
+redraw(Image *screen)
+{
+	Rectangle r;
+
+	if(im == nil)
+		return;
+
+	ulrange.max = screen->r.max;
+	ulrange.min = subpt(screen->r.min, Pt(Dx(im->r), Dy(im->r)));
+
+	ul = pclip(ul, ulrange);
+	drawop(screen, screen->r, im, nil, subpt(im->r.min, subpt(ul, screen->r.min)), S);
+
+	if(im->repl)
+		return;
+
+	/* fill in any outer edges */
+	/* black border */
+	r = rectaddpt(im->r, subpt(ul, im->r.min));
+	border(screen, r, -2, display->black, ZP);
+	r.min = subpt(r.min, Pt(2,2));
+	r.max = addpt(r.max, Pt(2,2));
+
+	/* gray for the rest */
+	if(gray == nil) {
+		gray = xallocimage(display, Rect(0,0,1,1), RGB24, 1, 0x888888FF);
+		if(gray == nil) {
+			fprint(2, "g out of memory: %r\n");
+			wexits("mem");
+		}
+	}
+	border(screen, r, -4000, gray, ZP);
+//	flushimage(display, 0);	
+}
+
+void
+eresized(int new)
+{
+	Rectangle r;
+	r = screen->r;
+	if(new && getwindow(display, Refnone) < 0)
+		fprint(2,"can't reattach to window");
+	ul = addpt(ul, subpt(screen->r.min, r.min));
+	redraw(screen);
+}
+
+/* clip p to be in r */
+Point
+pclip(Point p, Rectangle r)
+{
+	if(p.x < r.min.x)
+		p.x = r.min.x;
+	else if(p.x >= r.max.x)
+		p.x = r.max.x-1;
+
+	if(p.y < r.min.y)
+		p.y = r.min.y;
+	else if(p.y >= r.max.y)
+		p.y = r.max.y-1;
+
+	return p;
+}
+
+/*
+ * resize is perhaps a misnomer. 
+ * this really just grows the window to be at least dx across
+ * and dy high.  if the window hits the bottom or right edge,
+ * it is backed up until it hits the top or left edge.
+ */
+void
+resize(int dx, int dy)
+{
+	static Rectangle sr;
+	Rectangle r, or;
+
+	dx += 2*Borderwidth;
+	dy += 2*Borderwidth;
+	if(wctlfd < 0){
+		wctlfd = open("/dev/wctl", OWRITE);
+		if(wctlfd < 0)
+			return;
+	}
+
+	r = insetrect(screen->r, -Borderwidth);
+	if(Dx(r) >= dx && Dy(r) >= dy)
+		return;
+
+	if(Dx(sr)*Dy(sr) == 0)
+		sr = screenrect();
+
+	or = r;
+
+	r.max.x = max(r.min.x+dx, r.max.x);
+	r.max.y = max(r.min.y+dy, r.max.y);
+	if(r.max.x > sr.max.x){
+		if(Dx(r) > Dx(sr)){
+			r.min.x = 0;
+			r.max.x = sr.max.x;
+		}else
+			r = rectaddpt(r, Pt(sr.max.x-r.max.x, 0));
+	}
+	if(r.max.y > sr.max.y){
+		if(Dy(r) > Dy(sr)){
+			r.min.y = 0;
+			r.max.y = sr.max.y;
+		}else
+			r = rectaddpt(r, Pt(0, sr.max.y-r.max.y));
+	}
+
+	/*
+	 * Sometimes we can't actually grow the window big enough,
+	 * and resizing it to the same shape makes it flash.
+	 */
+	if(Dx(r) == Dx(or) && Dy(r) == Dy(or))
+		return;
+
+	fprint(wctlfd, "resize -minx %d -miny %d -maxx %d -maxy %d\n",
+		r.min.x, r.min.y, r.max.x, r.max.y);
+}
+
+/*
+ * If we allocimage after a resize but before flushing the draw buffer,
+ * we won't have seen the reshape event, and we won't have called
+ * getwindow, and allocimage will fail.  So we flushimage before every alloc.
+ */
+Image*
+xallocimage(Display *d, Rectangle r, ulong chan, int repl, ulong val)
+{
+	flushimage(display, 0);
+	return allocimage(d, r, chan, repl, val);
+}
+
+/* all code below this line should be in the library, but is stolen from colors instead */
+static char*
+rdenv(char *name)
+{
+	char *v;
+	int fd, size;
+
+	fd = open(name, OREAD);
+	if(fd < 0)
+		return 0;
+	size = seek(fd, 0, 2);
+	v = malloc(size+1);
+	if(v == 0){
+		fprint(2, "page: can't malloc: %r\n");
+		wexits("no mem");
+	}
+	seek(fd, 0, 0);
+	read(fd, v, size);
+	v[size] = 0;
+	close(fd);
+	return v;
+}
+
+Rectangle
+screenrect(void)
+{
+	int fd;
+	char buf[12*5];
+
+	fd = open("/dev/screen", OREAD);
+	if(fd == -1)
+		fd=open("/mnt/term/dev/screen", OREAD);
+	if(fd == -1){
+		fprint(2, "page: can't open /dev/screen: %r\n");
+		wexits("window read");
+	}
+	if(read(fd, buf, sizeof buf) != sizeof buf){
+		fprint(2, "page: can't read /dev/screen: %r\n");
+		wexits("screen read");
+	}
+	close(fd);
+	return Rect(atoi(buf+12), atoi(buf+24), atoi(buf+36), atoi(buf+48));
+}
+
+void
+zerox(void)
+{
+	int pfd[2];
+
+	pipe(pfd);
+	switch(rfork(RFFDG|RFPROC)) {
+		case -1:
+			wexits("cannot fork in zerox: %r");
+		case 0: 
+			dup(pfd[1], 0);
+			close(pfd[0]);
+			execl("/bin/page", "page", "-w", 0);
+			wexits("cannot exec in zerox: %r\n");
+		default:
+			close(pfd[1]);
+			writeimage(pfd[0], im, 0);
+			close(pfd[0]);
+			break;
+	}
+}