Rearrange source files.

8 files changed, 5059 insertions, 0 deletions

diff --git a/platform/x11/jstest_main.c b/platform/x11/jstest_main.c
new file mode 100644
index 00000000..2003ad55
--- /dev/null
+++ b/platform/x11/jstest_main.c
@@ -0,0 +1,424 @@
+#include "pdfapp.h"
+
+#include <ctype.h>
+
+/*
+	A useful bit of bash script to call this is:
+	for f in ../ghostpcl/tests_private/pdf/forms/v1.3/ *.pdf ; do g=${f%.*} ; echo $g ; win32/debug/mujstest-v8.exe -o $g-%d.png -p ../ghostpcl/ $g.mjs > $g.log 2>&1 ; done
+
+	Remove the space from "/ *.pdf" before running - can't leave that
+	in here, as it causes a warning about a possibly malformed comment.
+*/
+
+static pdfapp_t gapp;
+static int file_open = 0;
+static char filename[1024] = "";
+static char *scriptname;
+static char *output = NULL;
+static char *prefix = NULL;
+static int shotcount = 0;
+static int verbosity = 0;
+
+#define LONGLINE 4096
+
+static char getline_buffer[LONGLINE];
+
+void winwarn(pdfapp_t *app, char *msg)
+{
+	fprintf(stderr, "warning: %s\n", msg);
+}
+
+void winerror(pdfapp_t *app, char *msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(1);
+}
+
+void winalert(pdfapp_t *app, pdf_alert_event *alert)
+{
+	fprintf(stderr, "Alert %s: %s", alert->title, alert->message);
+	switch (alert->button_group_type)
+	{
+	case PDF_ALERT_BUTTON_GROUP_OK:
+	case PDF_ALERT_BUTTON_GROUP_OK_CANCEL:
+		alert->button_pressed = PDF_ALERT_BUTTON_OK;
+		break;
+	case PDF_ALERT_BUTTON_GROUP_YES_NO:
+	case PDF_ALERT_BUTTON_GROUP_YES_NO_CANCEL:
+		alert->button_pressed = PDF_ALERT_BUTTON_YES;
+		break;
+	}
+}
+
+void winadvancetimer(pdfapp_t *app, float duration)
+{
+}
+
+void winprint(pdfapp_t *app)
+{
+	fprintf(stderr, "The MuPDF library supports printing, but this application currently does not");
+}
+
+static char pd_password[256] = "";
+static char td_textinput[LONGLINE] = "";
+
+char *winpassword(pdfapp_t *app, char *filename)
+{
+	if (pd_password[0] == 0)
+		return NULL;
+	return pd_password;
+}
+
+char *wintextinput(pdfapp_t *app, char *inittext, int retry)
+{
+	if (retry)
+		return NULL;
+
+	if (td_textinput[0] != 0)
+		return td_textinput;
+	return inittext;
+}
+
+int winchoiceinput(pdfapp_t *app, int nopts, char *opts[], int *nvals, char *vals[])
+{
+	return 0;
+}
+
+void winhelp(pdfapp_t*app)
+{
+}
+
+void winclose(pdfapp_t *app)
+{
+	pdfapp_close(app);
+	exit(0);
+}
+
+int winsavequery(pdfapp_t *app)
+{
+	return DISCARD;
+}
+
+int wingetsavepath(pdfapp_t *app, char *buf, int len)
+{
+	return 0;
+}
+
+void winreplacefile(char *source, char *target)
+{
+}
+
+void wincursor(pdfapp_t *app, int curs)
+{
+}
+
+void wintitle(pdfapp_t *app, char *title)
+{
+}
+
+void windrawrect(pdfapp_t *app, int x0, int y0, int x1, int y1)
+{
+}
+
+void windrawstring(pdfapp_t *app, int x, int y, char *s)
+{
+}
+
+void winresize(pdfapp_t *app, int w, int h)
+{
+}
+
+void winrepaint(pdfapp_t *app)
+{
+}
+
+void winrepaintsearch(pdfapp_t *app)
+{
+}
+
+void winfullscreen(pdfapp_t *app, int state)
+{
+}
+
+/*
+ * Event handling
+ */
+
+void windocopy(pdfapp_t *app)
+{
+}
+
+void winreloadfile(pdfapp_t *app)
+{
+	pdfapp_close(app);
+	pdfapp_open(app, filename, 1);
+}
+
+void winopenuri(pdfapp_t *app, char *buf)
+{
+}
+
+static void
+usage(void)
+{
+	fprintf(stderr, "mujstest: Scriptable tester for mupdf + js\n");
+	fprintf(stderr, "\nSyntax: mujstest -o <filename> [ -p <prefix> ] [-v] <scriptfile>\n");
+	fprintf(stderr, "\n<filename> should sensibly be of the form file-%%d.png\n");
+	fprintf(stderr, "\n<prefix> is a path prefix to apply to filenames within the script\n");
+	fprintf(stderr, "\n-v\tverbose\n");
+	fprintf(stderr, "\nscriptfile contains a list of commands:\n");
+	fprintf(stderr, "\tPASSWORD <password>\tSet the password\n");
+	fprintf(stderr, "\tOPEN <filename>\tOpen a file\n");
+	fprintf(stderr, "\tGOTO <page>\tJump to a particular page\n");
+	fprintf(stderr, "\tSCREENSHOT\tSave a screenshot\n");
+	fprintf(stderr, "\tRESIZE <w> <h>\tResize the screen to a given size\n");
+	fprintf(stderr, "\tCLICK <x> <y> <btn>\tClick at a given position\n");
+	fprintf(stderr, "\tTEXT <string>\tSet a value to be entered\n");
+	exit(1);
+}
+
+static char *
+my_getline(FILE *file)
+{
+	int c;
+	char *d = getline_buffer;
+	int space = sizeof(getline_buffer)-1;
+
+	/* Skip over any prefix of whitespace */
+	do
+	{
+		c = fgetc(file);
+	}
+	while (isspace(c));
+
+	if (c < 0)
+		return NULL;
+
+	/* Read the line in */
+	do
+	{
+		*d++ = (char)c;
+		c = fgetc(file);
+	}
+	while (c >= 32 && space--);
+
+	/* If we ran out of space, skip the rest of the line */
+	if (space == 0)
+	{
+		while (c >= 32)
+			c = fgetc(file);
+	}
+
+	*d = 0;
+
+	return getline_buffer;
+}
+
+static int
+match(char **line, const char *match)
+{
+	char *s = *line;
+
+	if (s == NULL)
+		return 0;
+
+	while (isspace(*(unsigned char *)s))
+		s++;
+
+	while (*s == *match)
+	{
+		if (*s == 0)
+		{
+			*line = s;
+			return 1;
+		}
+		s++;
+		match++;
+	}
+
+	if (*match != 0)
+		return 0;
+
+	/* We matched! Skip over any whitespace */
+	while (isspace(*(unsigned char *)s))
+		s++;
+
+	*line = s;
+
+	/* Trim whitespace off the end of the line */
+	/* Run to the end of the line */
+	while (*s)
+		s++;
+
+	/* Run back until we find where we started, or non whitespace */
+	while (s != *line && isspace((unsigned char)s[-1]))
+		s--;
+
+	/* Remove the suffix of whitespace */
+	*s = 0;
+
+	return 1;
+}
+
+static void unescape_string(char *d, const char *s)
+{
+	char c;
+
+	while ((c = *s++) != 0)
+	{
+		if (c == '\\')
+		{
+			c = *s++;
+			switch(c)
+			{
+			case 'n':
+				c = '\n';
+				break;
+			case 'r':
+				c = '\r';
+				break;
+			case 't':
+				c = '\t';
+				break;
+			}
+		}
+		*d++ = c;
+	}
+	*d = 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+	fz_context *ctx;
+	FILE *script = NULL;
+	int c;
+
+	while ((c = fz_getopt(argc, argv, "o:p:v")) != -1)
+	{
+		switch(c)
+		{
+		case 'o': output = fz_optarg; break;
+		case 'p': prefix = fz_optarg; break;
+		case 'v': verbosity ^= 1; break;
+		default: usage(); break;
+		}
+	}
+
+	if (fz_optind == argc)
+		usage();
+
+	ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
+	if (!ctx)
+	{
+		fprintf(stderr, "cannot initialise context\n");
+		exit(1);
+	}
+	pdfapp_init(ctx, &gapp);
+	gapp.scrw = 640;
+	gapp.scrh = 480;
+	gapp.colorspace = fz_device_rgb(ctx);
+
+	fz_try(ctx)
+	{
+		while (fz_optind < argc)
+		{
+			scriptname = argv[fz_optind++];
+			script = fopen(scriptname, "rb");
+			if (script == NULL)
+				fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open script: %s", scriptname);
+
+			do
+			{
+				char *line = my_getline(script);
+				if (line == NULL)
+					continue;
+				if (verbosity)
+					fprintf(stderr, "'%s'\n", line);
+				if (match(&line, "%"))
+				{
+					/* Comment */
+				}
+				else if (match(&line, "PASSWORD"))
+				{
+					strcpy(pd_password, line);
+				}
+				else if (match(&line, "OPEN"))
+				{
+					char path[1024];
+					if (file_open)
+						pdfapp_close(&gapp);
+					strcpy(filename, line);
+					if (prefix)
+					{
+						sprintf(path, "%s%s", prefix, line);
+					}
+					else
+					{
+						strcpy(path, line);
+					}
+					pdfapp_open(&gapp, path, 0);
+					file_open = 1;
+				}
+				else if (match(&line, "GOTO"))
+				{
+					pdfapp_gotopage(&gapp, atoi(line)-1);
+				}
+				else if (match(&line, "SCREENSHOT"))
+				{
+					char text[1024];
+
+					sprintf(text, output, ++shotcount);
+					if (strstr(text, ".pgm") || strstr(text, ".ppm") || strstr(text, ".pnm"))
+						fz_write_pnm(ctx, gapp.image, text);
+					else
+						fz_write_png(ctx, gapp.image, text, 0);
+				}
+				else if (match(&line, "RESIZE"))
+				{
+					int w, h;
+					sscanf(line, "%d %d", &w, &h);
+					pdfapp_onresize(&gapp, w, h);
+				}
+				else if (match(&line, "CLICK"))
+				{
+					float x, y, b;
+					int n;
+					n = sscanf(line, "%f %f %f", &x, &y, &b);
+					if (n < 1)
+						x = 0.0f;
+					if (n < 2)
+						y = 0.0f;
+					if (n < 3)
+						b = 1;
+					/* state = 1 = transition down */
+					pdfapp_onmouse(&gapp, (int)x, (int)y, b, 0, 1);
+					/* state = -1 = transition up */
+					pdfapp_onmouse(&gapp, (int)x, (int)y, b, 0, -1);
+				}
+				else if (match(&line, "TEXT"))
+				{
+					unescape_string(td_textinput, line);
+				}
+				else
+				{
+					fprintf(stderr, "Unmatched: %s\n", line);
+				}
+			}
+			while (!feof(script));
+
+			fclose(script);
+		}
+	}
+	fz_catch(ctx)
+	{
+		fprintf(stderr, "error: cannot execute '%s'\n", scriptname);
+	}
+
+	if (file_open)
+		pdfapp_close(&gapp);
+
+	fz_free_context(ctx);
+
+	return 0;
+}
diff --git a/platform/x11/mupdf.ico b/platform/x11/mupdf.ico
new file mode 100644
index 00000000..80deb8ea
--- /dev/null
+++ b/platform/x11/mupdf.ico
diff --git a/platform/x11/pdfapp.c b/platform/x11/pdfapp.c
new file mode 100644
index 00000000..e76c6c7c
--- /dev/null
+++ b/platform/x11/pdfapp.c
@@ -0,0 +1,1545 @@
+#include "pdfapp.h"
+
+#include <ctype.h> /* for tolower() */
+
+#define ZOOMSTEP 1.142857
+#define BEYOND_THRESHHOLD 40
+#ifndef PATH_MAX
+#define PATH_MAX (1024)
+#endif
+
+#ifndef MAX
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+enum panning
+{
+	DONT_PAN = 0,
+	PAN_TO_TOP,
+	PAN_TO_BOTTOM
+};
+
+static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint, int transition);
+static void pdfapp_updatepage(pdfapp_t *app);
+
+static void pdfapp_warn(pdfapp_t *app, const char *fmt, ...)
+{
+	char buf[1024];
+	va_list ap;
+	va_start(ap, fmt);
+	vsnprintf(buf, sizeof(buf), fmt, ap);
+	va_end(ap);
+	buf[sizeof(buf)-1] = 0;
+	winwarn(app, buf);
+}
+
+static void pdfapp_error(pdfapp_t *app, char *msg)
+{
+	winerror(app, msg);
+}
+
+char *pdfapp_version(pdfapp_t *app)
+{
+	return
+		"MuPDF 1.2\n"
+		"Copyright 2006-2013 Artifex Software, Inc.\n";
+}
+
+char *pdfapp_usage(pdfapp_t *app)
+{
+	return
+		"L\t\t-- rotate left\n"
+		"R\t\t-- rotate right\n"
+		"h\t\t-- scroll left\n"
+		"j down\t\t-- scroll down\n"
+		"k up\t\t-- scroll up\n"
+		"l\t\t-- scroll right\n"
+		"+\t\t-- zoom in\n"
+		"-\t\t-- zoom out\n"
+		"W\t\t-- zoom to fit window width\n"
+		"H\t\t-- zoom to fit window height\n"
+		"w\t\t-- shrinkwrap\n"
+		"f\t\t-- fullscreen\n"
+		"r\t\t-- reload file\n"
+		". pgdn right spc\t-- next page\n"
+		", pgup left b bkspc\t-- previous page\n"
+		">\t\t-- next 10 pages\n"
+		"<\t\t-- back 10 pages\n"
+		"m\t\t-- mark page for snap back\n"
+		"t\t\t-- pop back to latest mark\n"
+		"1m\t\t-- mark page in register 1\n"
+		"1t\t\t-- go to page in register 1\n"
+		"G\t\t-- go to last page\n"
+		"123g\t\t-- go to page 123\n"
+		"/\t\t-- search forwards for text\n"
+		"?\t\t-- search backwards for text\n"
+		"n\t\t-- find next search result\n"
+		"N\t\t-- find previous search result\n"
+		"c\t\t-- toggle between color and grayscale\n"
+		"i\t\t-- toggle inverted color mode\n"
+		"q\t\t-- quit\n"
+	;
+}
+
+void pdfapp_init(fz_context *ctx, pdfapp_t *app)
+{
+	memset(app, 0, sizeof(pdfapp_t));
+	app->scrw = 640;
+	app->scrh = 480;
+	app->resolution = 72;
+	app->ctx = ctx;
+#ifdef _WIN32
+	app->colorspace = fz_device_bgr(ctx);
+#else
+	app->colorspace = fz_device_rgb(ctx);
+#endif
+}
+
+void pdfapp_invert(pdfapp_t *app, const fz_rect *rect)
+{
+	fz_irect b;
+	fz_invert_pixmap_rect(app->image, fz_round_rect(&b, rect));
+}
+
+static void event_cb(pdf_doc_event *event, void *data)
+{
+	pdfapp_t *app = (pdfapp_t *)data;
+
+	switch (event->type)
+	{
+	case PDF_DOCUMENT_EVENT_ALERT:
+		{
+			pdf_alert_event *alert = pdf_access_alert_event(event);
+			winalert(app, alert);
+		}
+		break;
+
+	case PDF_DOCUMENT_EVENT_PRINT:
+		winprint(app);
+		break;
+
+	case PDF_DOCUMENT_EVENT_EXEC_MENU_ITEM:
+		{
+			char *item = pdf_access_exec_menu_item_event(event);
+
+			if (!strcmp(item, "Print"))
+				winprint(app);
+			else
+				pdfapp_warn(app, "The document attempted to execute menu item: %s. (Not supported)", item);
+		}
+		break;
+
+	case PDF_DOCUMENT_EVENT_EXEC_DIALOG:
+		pdfapp_warn(app, "The document attempted to open a dialog box. (Not supported)");
+		break;
+
+	case PDF_DOCUMENT_EVENT_LAUNCH_URL:
+		{
+			pdf_launch_url_event *launch_url = pdf_access_launch_url_event(event);
+
+			pdfapp_warn(app, "The document attempted to open url: %s. (Not supported by app)", launch_url->url);
+		}
+		break;
+
+	case PDF_DOCUMENT_EVENT_MAIL_DOC:
+		{
+			pdf_mail_doc_event *mail_doc = pdf_access_mail_doc_event(event);
+
+			pdfapp_warn(app, "The document attmepted to mail the document%s%s%s%s%s%s%s%s (Not supported)",
+				mail_doc->to[0]?", To: ":"", mail_doc->to,
+				mail_doc->cc[0]?", Cc: ":"", mail_doc->cc,
+				mail_doc->bcc[0]?", Bcc: ":"", mail_doc->bcc,
+				mail_doc->subject[0]?", Subject: ":"", mail_doc->subject);
+		}
+		break;
+	}
+}
+
+void pdfapp_open(pdfapp_t *app, char *filename, int reload)
+{
+	fz_context *ctx = app->ctx;
+	char *password = "";
+
+	fz_try(ctx)
+	{
+		pdf_document *idoc;
+
+		app->doc = fz_open_document(ctx, filename);
+
+		idoc = pdf_specifics(app->doc);
+
+		if (idoc)
+			pdf_set_doc_event_callback(idoc, event_cb, app);
+
+		if (fz_needs_password(app->doc))
+		{
+			int okay = fz_authenticate_password(app->doc, password);
+			while (!okay)
+			{
+				password = winpassword(app, filename);
+				if (!password)
+					fz_throw(ctx, FZ_ERROR_GENERIC, "Needs a password");
+				okay = fz_authenticate_password(app->doc, password);
+				if (!okay)
+					pdfapp_warn(app, "Invalid password.");
+			}
+		}
+
+		app->docpath = fz_strdup(ctx, filename);
+		app->doctitle = filename;
+		if (strrchr(app->doctitle, '\\'))
+			app->doctitle = strrchr(app->doctitle, '\\') + 1;
+		if (strrchr(app->doctitle, '/'))
+			app->doctitle = strrchr(app->doctitle, '/') + 1;
+		app->doctitle = fz_strdup(ctx, app->doctitle);
+
+		app->pagecount = fz_count_pages(app->doc);
+		app->outline = fz_load_outline(app->doc);
+	}
+	fz_catch(ctx)
+	{
+		pdfapp_error(app, "cannot open document");
+	}
+
+	if (app->pageno < 1)
+		app->pageno = 1;
+	if (app->pageno > app->pagecount)
+		app->pageno = app->pagecount;
+	if (app->resolution < MINRES)
+		app->resolution = MINRES;
+	if (app->resolution > MAXRES)
+		app->resolution = MAXRES;
+
+	if (!reload)
+	{
+		app->shrinkwrap = 1;
+		app->rotate = 0;
+		app->panx = 0;
+		app->pany = 0;
+	}
+
+	pdfapp_showpage(app, 1, 1, 1, 0);
+}
+
+void pdfapp_close(pdfapp_t *app)
+{
+	fz_drop_display_list(app->ctx, app->page_list);
+	app->page_list = NULL;
+
+	fz_drop_display_list(app->ctx, app->annotations_list);
+	app->annotations_list = NULL;
+
+	fz_free_text_page(app->ctx, app->page_text);
+	app->page_text = NULL;
+
+	fz_free_text_sheet(app->ctx, app->page_sheet);
+	app->page_sheet = NULL;
+
+	fz_drop_link(app->ctx, app->page_links);
+	app->page_links = NULL;
+
+	fz_free(app->ctx, app->doctitle);
+	app->doctitle = NULL;
+
+	fz_free(app->ctx, app->docpath);
+	app->docpath = NULL;
+
+	fz_drop_pixmap(app->ctx, app->image);
+	app->image = NULL;
+
+	fz_drop_pixmap(app->ctx, app->new_image);
+	app->new_image = NULL;
+
+	fz_drop_pixmap(app->ctx, app->old_image);
+	app->old_image = NULL;
+
+	fz_free_outline(app->ctx, app->outline);
+	app->outline = NULL;
+
+	fz_free_page(app->doc, app->page);
+	app->page = NULL;
+
+	fz_close_document(app->doc);
+	app->doc = NULL;
+
+	fz_flush_warnings(app->ctx);
+}
+
+static int gen_tmp_file(char *buf, int len)
+{
+	int i;
+	char *name = strrchr(buf, '/');
+
+	if (name == NULL)
+		name = strrchr(buf, '\\');
+
+	if (name != NULL)
+		name++;
+	else
+		name = buf;
+
+	for (i = 0; i < 10000; i++)
+	{
+		FILE *f;
+		snprintf(name, buf+len-name, "tmp%04d", i);
+		f = fopen(buf, "r");
+		if (f == NULL)
+			return 1;
+		fclose(f);
+	}
+
+	return 0;
+}
+
+static int pdfapp_save(pdfapp_t *app)
+{
+	char buf[PATH_MAX];
+
+	if (wingetsavepath(app, buf, PATH_MAX))
+	{
+		fz_write_options opts;
+
+		opts.do_ascii = 1;
+		opts.do_expand = 0;
+		opts.do_garbage = 1;
+		opts.do_linear = 0;
+
+		if (strcmp(buf, app->docpath) != 0)
+		{
+			fz_write_document(app->doc, buf, &opts);
+			return 1;
+		}
+
+		if (gen_tmp_file(buf, PATH_MAX))
+		{
+			int written;
+
+			fz_try(app->ctx)
+			{
+				fz_write_document(app->doc, buf, &opts);
+				written = 1;
+			}
+			fz_catch(app->ctx)
+			{
+				written = 0;
+			}
+
+			if (written)
+			{
+				char buf2[PATH_MAX];
+				fz_strlcpy(buf2, app->docpath, PATH_MAX);
+				pdfapp_close(app);
+				winreplacefile(buf, buf2);
+				pdfapp_open(app, buf2, 1);
+
+				return written;
+			}
+		}
+	}
+
+	return 0;
+}
+
+int pdfapp_preclose(pdfapp_t *app)
+{
+	pdf_document *idoc = pdf_specifics(app->doc);
+
+	if (idoc && pdf_has_unsaved_changes(idoc))
+	{
+		switch (winsavequery(app))
+		{
+		case DISCARD:
+			return 1;
+
+		case CANCEL:
+			return 0;
+
+		case SAVE:
+			return pdfapp_save(app);
+		}
+	}
+
+	return 1;
+}
+
+static void pdfapp_viewctm(fz_matrix *mat, pdfapp_t *app)
+{
+	fz_pre_rotate(fz_scale(mat, app->resolution/72.0f, app->resolution/72.0f), app->rotate);
+}
+
+static void pdfapp_panview(pdfapp_t *app, int newx, int newy)
+{
+	int image_w = fz_pixmap_width(app->ctx, app->image);
+	int image_h = fz_pixmap_height(app->ctx, app->image);
+
+	if (newx > 0)
+		newx = 0;
+	if (newy > 0)
+		newy = 0;
+
+	if (newx + image_w < app->winw)
+		newx = app->winw - image_w;
+	if (newy + image_h < app->winh)
+		newy = app->winh - image_h;
+
+	if (app->winw >= image_w)
+		newx = (app->winw - image_w) / 2;
+	if (app->winh >= image_h)
+		newy = (app->winh - image_h) / 2;
+
+	if (newx != app->panx || newy != app->pany)
+		winrepaint(app);
+
+	app->panx = newx;
+	app->pany = newy;
+}
+
+static void pdfapp_loadpage(pdfapp_t *app)
+{
+	fz_device *mdev = NULL;
+	int errored = 0;
+	fz_cookie cookie = { 0 };
+
+	fz_var(mdev);
+
+	fz_drop_display_list(app->ctx, app->page_list);
+	fz_drop_display_list(app->ctx, app->annotations_list);
+	fz_free_text_page(app->ctx, app->page_text);
+	fz_free_text_sheet(app->ctx, app->page_sheet);
+	fz_drop_link(app->ctx, app->page_links);
+	fz_free_page(app->doc, app->page);
+
+	app->page_list = NULL;
+	app->annotations_list = NULL;
+	app->page_text = NULL;
+	app->page_sheet = NULL;
+	app->page_links = NULL;
+	app->page = NULL;
+	app->page_bbox.x0 = 0;
+	app->page_bbox.y0 = 0;
+	app->page_bbox.x1 = 100;
+	app->page_bbox.y1 = 100;
+
+	fz_try(app->ctx)
+	{
+		app->page = fz_load_page(app->doc, app->pageno - 1);
+
+		fz_bound_page(app->doc, app->page, &app->page_bbox);
+	}
+	fz_catch(app->ctx)
+	{
+		pdfapp_warn(app, "Cannot load page");
+		return;
+	}
+
+	fz_try(app->ctx)
+	{
+		fz_annot *annot;
+		/* Create display lists */
+		app->page_list = fz_new_display_list(app->ctx);
+		mdev = fz_new_list_device(app->ctx, app->page_list);
+		fz_run_page_contents(app->doc, app->page, mdev, &fz_identity, &cookie);
+		fz_free_device(mdev);
+		mdev = NULL;
+		app->annotations_list = fz_new_display_list(app->ctx);
+		mdev = fz_new_list_device(app->ctx, app->annotations_list);
+		for (annot = fz_first_annot(app->doc, app->page); annot; annot = fz_next_annot(app->doc, annot))
+			fz_run_annot(app->doc, app->page, annot, mdev, &fz_identity, &cookie);
+		if (cookie.errors)
+		{
+			pdfapp_warn(app, "Errors found on page");
+			errored = 1;
+		}
+	}
+	fz_always(app->ctx)
+	{
+		fz_free_device(mdev);
+	}
+	fz_catch(app->ctx)
+	{
+		pdfapp_warn(app, "Cannot load page");
+		errored = 1;
+	}
+
+	fz_try(app->ctx)
+	{
+		app->page_links = fz_load_links(app->doc, app->page);
+	}
+	fz_catch(app->ctx)
+	{
+		if (!errored)
+			pdfapp_warn(app, "Cannot load page");
+	}
+
+	app->errored = errored;
+}
+
+static void pdfapp_recreate_annotationslist(pdfapp_t *app)
+{
+	fz_device *mdev = NULL;
+	int errored = 0;
+	fz_cookie cookie = { 0 };
+
+	fz_var(mdev);
+
+	fz_drop_display_list(app->ctx, app->annotations_list);
+	app->annotations_list = NULL;
+
+	fz_try(app->ctx)
+	{
+		fz_annot *annot;
+		/* Create display list */
+		app->annotations_list = fz_new_display_list(app->ctx);
+		mdev = fz_new_list_device(app->ctx, app->annotations_list);
+		for (annot = fz_first_annot(app->doc, app->page); annot; annot = fz_next_annot(app->doc, annot))
+			fz_run_annot(app->doc, app->page, annot, mdev, &fz_identity, &cookie);
+		if (cookie.errors)
+		{
+			pdfapp_warn(app, "Errors found on page");
+			errored = 1;
+		}
+	}
+	fz_always(app->ctx)
+	{
+		fz_free_device(mdev);
+	}
+	fz_catch(app->ctx)
+	{
+		pdfapp_warn(app, "Cannot load page");
+		errored = 1;
+	}
+
+	app->errored = errored;
+}
+
+static void pdfapp_runpage(pdfapp_t *app, fz_device *dev, const fz_matrix *ctm, const fz_rect *rect, fz_cookie *cookie)
+{
+	fz_begin_page(dev, rect, ctm);
+	if (app->page_list)
+		fz_run_display_list(app->page_list, dev, ctm, rect, cookie);
+	if (app->annotations_list)
+		fz_run_display_list(app->annotations_list, dev, ctm, rect, cookie);
+	fz_end_page(dev);
+}
+
+#define MAX_TITLE 256
+
+static void pdfapp_updatepage(pdfapp_t *app)
+{
+	pdf_document *idoc = pdf_specifics(app->doc);
+	fz_device *idev;
+	fz_matrix ctm;
+	fz_annot *annot;
+
+	pdfapp_viewctm(&ctm, app);
+	pdf_update_page(idoc, (pdf_page *)app->page);
+	pdfapp_recreate_annotationslist(app);
+
+	while ((annot = (fz_annot *)pdf_poll_changed_annot(idoc, (pdf_page *)app->page)) != NULL)
+	{
+		fz_rect bounds;
+		fz_irect ibounds;
+		fz_transform_rect(fz_bound_annot(app->doc, annot, &bounds), &ctm);
+		fz_rect_from_irect(&bounds, fz_round_rect(&ibounds, &bounds));
+		fz_clear_pixmap_rect_with_value(app->ctx, app->image, 255, &ibounds);
+		idev = fz_new_draw_device_with_bbox(app->ctx, app->image, &ibounds);
+		pdfapp_runpage(app, idev, &ctm, &bounds, NULL);
+		fz_free_device(idev);
+	}
+
+	pdfapp_showpage(app, 0, 0, 1, 0);
+}
+
+static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint, int transition)
+{
+	char buf[MAX_TITLE];
+	fz_device *idev;
+	fz_device *tdev;
+	fz_colorspace *colorspace;
+	fz_matrix ctm;
+	fz_rect bounds;
+	fz_irect ibounds;
+	fz_cookie cookie = { 0 };
+
+	if (!app->nowaitcursor)
+		wincursor(app, WAIT);
+
+	if (!app->transitions_enabled || !app->presentation_mode)
+		transition = 0;
+
+	if (transition)
+	{
+		app->old_image = app->image;
+		app->image = NULL;
+	}
+
+	if (loadpage)
+	{
+		pdfapp_loadpage(app);
+
+		/* Zero search hit position */
+		app->hit_count = 0;
+
+		/* Extract text */
+		app->page_sheet = fz_new_text_sheet(app->ctx);
+		app->page_text = fz_new_text_page(app->ctx);
+
+		if (app->page_list || app->annotations_list)
+		{
+			tdev = fz_new_text_device(app->ctx, app->page_sheet, app->page_text);
+			pdfapp_runpage(app, tdev, &fz_identity, &fz_infinite_rect, &cookie);
+			fz_free_device(tdev);
+		}
+	}
+
+	if (drawpage)
+	{
+		char buf2[64];
+		int len;
+
+		sprintf(buf2, " - %d/%d (%d dpi)",
+				app->pageno, app->pagecount, app->resolution);
+		len = MAX_TITLE-strlen(buf2);
+		if ((int)strlen(app->doctitle) > len)
+		{
+			snprintf(buf, len-3, "%s", app->doctitle);
+			strcat(buf, "...");
+			strcat(buf, buf2);
+		}
+		else
+			sprintf(buf, "%s%s", app->doctitle, buf2);
+		wintitle(app, buf);
+
+		pdfapp_viewctm(&ctm, app);
+		bounds = app->page_bbox;
+		fz_round_rect(&ibounds, fz_transform_rect(&bounds, &ctm));
+		fz_rect_from_irect(&bounds, &ibounds);
+
+		/* Draw */
+		if (app->image)
+			fz_drop_pixmap(app->ctx, app->image);
+		if (app->grayscale)
+			colorspace = fz_device_gray(app->ctx);
+		else
+			colorspace = app->colorspace;
+		app->image = NULL;
+		app->image = fz_new_pixmap_with_bbox(app->ctx, colorspace, &ibounds);
+		fz_clear_pixmap_with_value(app->ctx, app->image, 255);
+		if (app->page_list || app->annotations_list)
+		{
+			idev = fz_new_draw_device(app->ctx, app->image);
+			pdfapp_runpage(app, idev, &ctm, &bounds, &cookie);
+			fz_free_device(idev);
+		}
+		if (app->invert)
+			fz_invert_pixmap(app->ctx, app->image);
+	}
+
+	if (transition)
+	{
+		fz_transition *new_trans;
+		app->new_image = app->image;
+		app->image = NULL;
+		app->image = fz_new_pixmap_with_bbox(app->ctx, colorspace, &ibounds);
+		app->duration = 0;
+		new_trans = fz_page_presentation(app->doc, app->page, &app->duration);
+		if (new_trans)
+			app->transition = *new_trans;
+		else
+		{
+			/* If no transition specified, use a default one */
+			memset(&app->transition, 0, sizeof(*new_trans));
+			app->transition.duration = 1.0;
+			app->transition.type = FZ_TRANSITION_WIPE;
+			app->transition.vertical = 0;
+			app->transition.direction = 0;
+		}
+		if (app->duration == 0)
+			app->duration = 5;
+		app->in_transit = fz_generate_transition(app->image, app->old_image, app->new_image, 0, &app->transition);
+		if (!app->in_transit)
+		{
+			if (app->duration != 0)
+				winadvancetimer(app, app->duration);
+		}
+		app->start_time = clock();
+	}
+
+	if (repaint)
+	{
+		pdfapp_panview(app, app->panx, app->pany);
+
+		if (app->shrinkwrap)
+		{
+			int w = fz_pixmap_width(app->ctx, app->image);
+			int h = fz_pixmap_height(app->ctx, app->image);
+			if (app->winw == w)
+				app->panx = 0;
+			if (app->winh == h)
+				app->pany = 0;
+			if (w > app->scrw * 90 / 100)
+				w = app->scrw * 90 / 100;
+			if (h > app->scrh * 90 / 100)
+				h = app->scrh * 90 / 100;
+			if (w != app->winw || h != app->winh)
+				winresize(app, w, h);
+		}
+
+		winrepaint(app);
+
+		wincursor(app, ARROW);
+	}
+
+	if (cookie.errors && app->errored == 0)
+	{
+		app->errored = 1;
+		pdfapp_warn(app, "Errors found on page. Page rendering may be incomplete.");
+	}
+
+	fz_flush_warnings(app->ctx);
+}
+
+static void pdfapp_gotouri(pdfapp_t *app, char *uri)
+{
+	winopenuri(app, uri);
+}
+
+void pdfapp_gotopage(pdfapp_t *app, int number)
+{
+	app->isediting = 0;
+	winrepaint(app);
+
+	if (app->histlen + 1 == 256)
+	{
+		memmove(app->hist, app->hist + 1, sizeof(int) * 255);
+		app->histlen --;
+	}
+	app->hist[app->histlen++] = app->pageno;
+	app->pageno = number + 1;
+	pdfapp_showpage(app, 1, 1, 1, 0);
+}
+
+void pdfapp_inverthit(pdfapp_t *app)
+{
+	fz_rect bbox;
+	fz_matrix ctm;
+	int i;
+
+	pdfapp_viewctm(&ctm, app);
+
+	for (i = 0; i < app->hit_count; i++)
+	{
+		bbox = app->hit_bbox[i];
+		pdfapp_invert(app, fz_transform_rect(&bbox, &ctm));
+	}
+}
+
+static void pdfapp_search_in_direction(pdfapp_t *app, enum panning *panto, int dir)
+{
+	int firstpage, page;
+
+	wincursor(app, WAIT);
+
+	firstpage = app->pageno;
+	if (app->searchpage == app->pageno)
+		page = app->pageno + dir;
+	else
+		page = app->pageno;
+
+	if (page < 1) page = app->pagecount;
+	if (page > app->pagecount) page = 1;
+
+	do
+	{
+		if (page != app->pageno)
+		{
+			app->pageno = page;
+			pdfapp_showpage(app, 1, 0, 0, 0);
+		}
+
+		app->hit_count = fz_search_text_page(app->ctx, app->page_text, app->search, app->hit_bbox, nelem(app->hit_bbox));
+		if (app->hit_count > 0)
+		{
+			*panto = dir == 1 ? PAN_TO_TOP : PAN_TO_BOTTOM;
+			app->searchpage = app->pageno;
+			wincursor(app, HAND);
+			winrepaint(app);
+			return;
+		}
+
+		page += dir;
+		if (page < 1) page = app->pagecount;
+		if (page > app->pagecount) page = 1;
+	} while (page != firstpage);
+
+	pdfapp_warn(app, "String '%s' not found.", app->search);
+
+	app->pageno = firstpage;
+	pdfapp_showpage(app, 1, 0, 0, 0);
+	wincursor(app, HAND);
+	winrepaint(app);
+}
+
+void pdfapp_onresize(pdfapp_t *app, int w, int h)
+{
+	if (app->winw != w || app->winh != h)
+	{
+		app->winw = w;
+		app->winh = h;
+		pdfapp_panview(app, app->panx, app->pany);
+		winrepaint(app);
+	}
+}
+
+void pdfapp_onkey(pdfapp_t *app, int c)
+{
+	int oldpage = app->pageno;
+	enum panning panto = PAN_TO_TOP;
+	int loadpage = 1;
+
+	if (app->isediting)
+	{
+		int n = strlen(app->search);
+		if (c < ' ')
+		{
+			if (c == '\b' && n > 0)
+			{
+				app->search[n - 1] = 0;
+				winrepaintsearch(app);
+			}
+			if (c == '\n' || c == '\r')
+			{
+				app->isediting = 0;
+				if (n > 0)
+				{
+					winrepaintsearch(app);
+
+					if (app->searchdir < 0)
+					{
+						if (app->pageno == 1)
+							app->pageno = app->pagecount;
+						else
+							app->pageno--;
+						pdfapp_showpage(app, 1, 1, 0, 0);
+					}
+
+					pdfapp_onkey(app, 'n');
+				}
+				else
+					winrepaint(app);
+			}
+			if (c == '\033')
+			{
+				app->isediting = 0;
+				winrepaint(app);
+			}
+		}
+		else
+		{
+			if (n + 2 < sizeof app->search)
+			{
+				app->search[n] = c;
+				app->search[n + 1] = 0;
+				winrepaintsearch(app);
+			}
+		}
+		return;
+	}
+
+	/*
+	 * Save numbers typed for later
+	 */
+
+	if (c >= '0' && c <= '9')
+	{
+		app->number[app->numberlen++] = c;
+		app->number[app->numberlen] = '\0';
+	}
+
+	switch (c)
+	{
+
+	case 'q':
+		winclose(app);
+		break;
+
+	/*
+	 * Zoom and rotate
+	 */
+
+	case '+':
+	case '=':
+		app->resolution *= ZOOMSTEP;
+		if (app->resolution > MAXRES)
+			app->resolution = MAXRES;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+	case '-':
+		app->resolution /= ZOOMSTEP;
+		if (app->resolution < MINRES)
+			app->resolution = MINRES;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+
+	case 'W':
+		app->resolution *= (double) app->winw / (double) fz_pixmap_width(app->ctx, app->image);
+		if (app->resolution > MAXRES)
+			app->resolution = MAXRES;
+		else if (app->resolution < MINRES)
+			app->resolution = MINRES;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+	case 'H':
+		app->resolution *= (double) app->winh / (double) fz_pixmap_height(app->ctx, app->image);
+		if (app->resolution > MAXRES)
+			app->resolution = MAXRES;
+		else if (app->resolution < MINRES)
+			app->resolution = MINRES;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+
+	case 'L':
+		app->rotate -= 90;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+	case 'R':
+		app->rotate += 90;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+
+	case 'c':
+		app->grayscale ^= 1;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+
+	case 'i':
+		app->invert ^= 1;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+
+#ifndef NDEBUG
+	case 'a':
+		app->rotate -= 15;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+	case 's':
+		app->rotate += 15;
+		pdfapp_showpage(app, 0, 1, 1, 0);
+		break;
+#endif
+
+	/*
+	 * Pan view, but don't need to repaint image
+	 */
+
+	case 'f':
+		app->shrinkwrap = 0;
+		winfullscreen(app, !app->fullscreen);
+		app->fullscreen = !app->fullscreen;
+		break;
+
+	case 'w':
+		if (app->fullscreen)
+		{
+			winfullscreen(app, 0);
+			app->fullscreen = 0;
+		}
+		app->shrinkwrap = 1;
+		app->panx = app->pany = 0;
+		pdfapp_showpage(app, 0, 0, 1, 0);
+		break;
+
+	case 'h':
+		app->panx += fz_pixmap_width(app->ctx, app->image) / 10;
+		pdfapp_showpage(app, 0, 0, 1, 0);
+		break;
+
+	case 'j':
+		app->pany -= fz_pixmap_height(app->ctx, app->image) / 10;
+		pdfapp_showpage(app, 0, 0, 1, 0);
+		break;
+
+	case 'k':
+		app->pany += fz_pixmap_height(app->ctx, app->image) / 10;
+		pdfapp_showpage(app, 0, 0, 1, 0);
+		break;
+
+	case 'l':
+		app->panx -= fz_pixmap_width(app->ctx, app->image) / 10;
+		pdfapp_showpage(app, 0, 0, 1, 0);
+		break;
+
+	/*
+	 * Page navigation
+	 */
+
+	case 'g':
+	case '\n':
+	case '\r':
+		if (app->numberlen > 0)
+			app->pageno = atoi(app->number);
+		else
+			app->pageno = 1;
+		break;
+
+	case 'G':
+		app->pageno = app->pagecount;
+		break;
+
+	case 'm':
+		if (app->numberlen > 0)
+		{
+			int idx = atoi(app->number);
+
+			if (idx >= 0 && idx < nelem(app->marks))
+				app->marks[idx] = app->pageno;
+		}
+		else
+		{
+			if (app->histlen + 1 == 256)
+			{
+				memmove(app->hist, app->hist + 1, sizeof(int) * 255);
+				app->histlen --;
+			}
+			app->hist[app->histlen++] = app->pageno;
+		}
+		break;
+
+	case 't':
+		if (app->numberlen > 0)
+		{
+			int idx = atoi(app->number);
+
+			if (idx >= 0 && idx < nelem(app->marks))
+				if (app->marks[idx] > 0)
+					app->pageno = app->marks[idx];
+		}
+		else if (app->histlen > 0)
+			app->pageno = app->hist[--app->histlen];
+		break;
+
+	case 'p':
+		app->presentation_mode = !app->presentation_mode;
+		break;
+
+	/*
+	 * Back and forth ...
+	 */
+
+	case ',':
+		panto = PAN_TO_BOTTOM;
+		if (app->numberlen > 0)
+			app->pageno -= atoi(app->number);
+		else
+			app->pageno--;
+		break;
+
+	case '.':
+		panto = PAN_TO_TOP;
+		if (app->numberlen > 0)
+			app->pageno += atoi(app->number);
+		else
+			app->pageno++;
+		break;
+
+	case '\b':
+	case 'b':
+		panto = DONT_PAN;
+		if (app->numberlen > 0)
+			app->pageno -= atoi(app->number);
+		else
+			app->pageno--;
+		break;
+
+	case ' ':
+		panto = DONT_PAN;
+		if (app->numberlen > 0)
+			app->pageno += atoi(app->number);
+		else
+			app->pageno++;
+		break;
+
+	case '<':
+		panto = PAN_TO_TOP;
+		app->pageno -= 10;
+		break;
+	case '>':
+		panto = PAN_TO_TOP;
+		app->pageno += 10;
+		break;
+
+	/*
+	 * Saving the file
+	 */
+	case 'S':
+		pdfapp_save(app);
+		break;
+
+	/*
+	 * Reloading the file...
+	 */
+
+	case 'r':
+		panto = DONT_PAN;
+		oldpage = -1;
+		winreloadfile(app);
+		break;
+
+	/*
+	 * Searching
+	 */
+
+	case '?':
+		app->isediting = 1;
+		app->searchdir = -1;
+		app->search[0] = 0;
+		app->hit_count = 0;
+		app->searchpage = -1;
+		winrepaintsearch(app);
+		break;
+
+	case '/':
+		app->isediting = 1;
+		app->searchdir = 1;
+		app->search[0] = 0;
+		app->hit_count = 0;
+		app->searchpage = -1;
+		winrepaintsearch(app);
+		break;
+
+	case 'n':
+		if (app->searchdir > 0)
+			pdfapp_search_in_direction(app, &panto, 1);
+		else
+			pdfapp_search_in_direction(app, &panto, -1);
+		loadpage = 0;
+		break;
+
+	case 'N':
+		if (app->searchdir > 0)
+			pdfapp_search_in_direction(app, &panto, -1);
+		else
+			pdfapp_search_in_direction(app, &panto, 1);
+		loadpage = 0;
+		break;
+
+	}
+
+	if (c < '0' || c > '9')
+		app->numberlen = 0;
+
+	if (app->pageno < 1)
+		app->pageno = 1;
+	if (app->pageno > app->pagecount)
+		app->pageno = app->pagecount;
+
+	if (app->pageno != oldpage)
+	{
+		switch (panto)
+		{
+		case PAN_TO_TOP:
+			app->pany = 0;
+			break;
+		case PAN_TO_BOTTOM:
+			app->pany = -2000;
+			break;
+		case DONT_PAN:
+			break;
+		}
+		pdfapp_showpage(app, loadpage, 1, 1, 1);
+	}
+}
+
+void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int state)
+{
+	fz_context *ctx = app->ctx;
+	fz_irect irect;
+	fz_link *link;
+	fz_matrix ctm;
+	fz_point p;
+	int processed = 0;
+
+	fz_pixmap_bbox(app->ctx, app->image, &irect);
+	p.x = x - app->panx + irect.x0;
+	p.y = y - app->pany + irect.y0;
+
+	pdfapp_viewctm(&ctm, app);
+	fz_invert_matrix(&ctm, &ctm);
+
+	fz_transform_point(&p, &ctm);
+
+	if (btn == 1 && (state == 1 || state == -1))
+	{
+		pdf_ui_event event;
+		pdf_document *idoc = pdf_specifics(app->doc);
+
+		event.etype = PDF_EVENT_TYPE_POINTER;
+		event.event.pointer.pt = p;
+		if (state == 1)
+			event.event.pointer.ptype = PDF_POINTER_DOWN;
+		else /* state == -1 */
+			event.event.pointer.ptype = PDF_POINTER_UP;
+
+		if (idoc && pdf_pass_event(idoc, (pdf_page *)app->page, &event))
+		{
+			pdf_widget *widget;
+
+			widget = pdf_focused_widget(idoc);
+
+			app->nowaitcursor = 1;
+			pdfapp_updatepage(app);
+
+			if (widget)
+			{
+				switch (pdf_widget_get_type(widget))
+				{
+				case PDF_WIDGET_TYPE_TEXT:
+					{
+						char *text = pdf_text_widget_text(idoc, widget);
+						char *current_text = text;
+						int retry = 0;
+
+						do
+						{
+							current_text = wintextinput(app, current_text, retry);
+							retry = 1;
+						}
+						while (current_text && !pdf_text_widget_set_text(idoc, widget, current_text));
+
+						fz_free(app->ctx, text);
+						pdfapp_updatepage(app);
+					}
+					break;
+
+				case PDF_WIDGET_TYPE_LISTBOX:
+				case PDF_WIDGET_TYPE_COMBOBOX:
+					{
+						int nopts;
+						int nvals;
+						char **opts = NULL;
+						char **vals = NULL;
+
+						fz_var(opts);
+						fz_var(vals);
+
+						fz_try(ctx)
+						{
+							nopts = pdf_choice_widget_options(idoc, widget, NULL);
+							opts = fz_malloc(ctx, nopts * sizeof(*opts));
+							(void)pdf_choice_widget_options(idoc, widget, opts);
+
+							nvals = pdf_choice_widget_value(idoc, widget, NULL);
+							vals = fz_malloc(ctx, MAX(nvals,nopts) * sizeof(*vals));
+							(void)pdf_choice_widget_value(idoc, widget, vals);
+
+							if (winchoiceinput(app, nopts, opts, &nvals, vals))
+							{
+								pdf_choice_widget_set_value(idoc, widget, nvals, vals);
+								pdfapp_updatepage(app);
+							}
+						}
+						fz_always(ctx)
+						{
+							fz_free(ctx, opts);
+							fz_free(ctx, vals);
+						}
+						fz_catch(ctx)
+						{
+							pdfapp_warn(app, "setting of choice failed");
+						}
+					}
+					break;
+
+				case PDF_WIDGET_TYPE_SIGNATURE:
+					{
+						char ebuf[256];
+
+						ebuf[0] = 0;
+						if (pdf_check_signature(ctx, idoc, widget, app->docpath, ebuf, sizeof(ebuf)))
+						{
+							winwarn(app, "Signature is valid");
+						}
+						else
+						{
+							if (ebuf[0] == 0)
+								winwarn(app, "Signature check failed for unknown reason");
+							else
+								winwarn(app, ebuf);
+						}
+					}
+					break;
+				}
+			}
+
+			app->nowaitcursor = 0;
+			processed = 1;
+		}
+	}
+
+	for (link = app->page_links; link; link = link->next)
+	{
+		if (p.x >= link->rect.x0 && p.x <= link->rect.x1)
+			if (p.y >= link->rect.y0 && p.y <= link->rect.y1)
+				break;
+	}
+
+	if (link)
+	{
+		wincursor(app, HAND);
+		if (btn == 1 && state == 1 && !processed)
+		{
+			if (link->dest.kind == FZ_LINK_URI)
+				pdfapp_gotouri(app, link->dest.ld.uri.uri);
+			else if (link->dest.kind == FZ_LINK_GOTO)
+				pdfapp_gotopage(app, link->dest.ld.gotor.page);
+			return;
+		}
+	}
+	else
+	{
+		fz_annot *annot;
+		for (annot = fz_first_annot(app->doc, app->page); annot; annot = fz_next_annot(app->doc, annot))
+		{
+			fz_rect rect;
+			fz_bound_annot(app->doc, annot, &rect);
+			if (x >= rect.x0 && x < rect.x1)
+				if (y >= rect.y0 && y < rect.y1)
+					break;
+		}
+		if (annot)
+			wincursor(app, CARET);
+		else
+			wincursor(app, ARROW);
+	}
+
+	if (state == 1 && !processed)
+	{
+		if (btn == 1 && !app->iscopying)
+		{
+			app->ispanning = 1;
+			app->selx = x;
+			app->sely = y;
+			app->beyondy = 0;
+		}
+		if (btn == 3 && !app->ispanning)
+		{
+			app->iscopying = 1;
+			app->selx = x;
+			app->sely = y;
+			app->selr.x0 = x;
+			app->selr.x1 = x;
+			app->selr.y0 = y;
+			app->selr.y1 = y;
+		}
+		if (btn == 4 || btn == 5) /* scroll wheel */
+		{
+			int dir = btn == 4 ? 1 : -1;
+			app->ispanning = app->iscopying = 0;
+			if (modifiers & (1<<2))
+			{
+				/* zoom in/out if ctrl is pressed */
+				if (dir > 0)
+					app->resolution *= ZOOMSTEP;
+				else
+					app->resolution /= ZOOMSTEP;
+				if (app->resolution > MAXRES)
+					app->resolution = MAXRES;
+				if (app->resolution < MINRES)
+					app->resolution = MINRES;
+				pdfapp_showpage(app, 0, 1, 1, 0);
+			}
+			else
+			{
+				/* scroll up/down, or left/right if
+				shift is pressed */
+				int isx = (modifiers & (1<<0));
+				int xstep = isx ? 20 * dir : 0;
+				int ystep = !isx ? 20 * dir : 0;
+				pdfapp_panview(app, app->panx + xstep, app->pany + ystep);
+			}
+		}
+	}
+
+	else if (state == -1)
+	{
+		if (app->iscopying)
+		{
+			app->iscopying = 0;
+			app->selr.x0 = fz_mini(app->selx, x) - app->panx + irect.x0;
+			app->selr.x1 = fz_maxi(app->selx, x) - app->panx + irect.x0;
+			app->selr.y0 = fz_mini(app->sely, y) - app->pany + irect.y0;
+			app->selr.y1 = fz_maxi(app->sely, y) - app->pany + irect.y0;
+			winrepaint(app);
+			if (app->selr.x0 < app->selr.x1 && app->selr.y0 < app->selr.y1)
+				windocopy(app);
+		}
+		app->ispanning = 0;
+	}
+
+	else if (app->ispanning)
+	{
+		int newx = app->panx + x - app->selx;
+		int newy = app->pany + y - app->sely;
+		/* Scrolling beyond limits implies flipping pages */
+		/* Are we requested to scroll beyond limits? */
+		if (newy + fz_pixmap_height(app->ctx, app->image) < app->winh || newy > 0)
+		{
+			/* Yes. We can assume that deltay != 0 */
+			int deltay = y - app->sely;
+			/* Check whether the panning has occurred in the
+			 * direction that we are already crossing the
+			 * limit it. If not, we can conclude that we
+			 * have switched ends of the page and will thus
+			 * start over counting.
+			 */
+			if( app->beyondy == 0 || (app->beyondy ^ deltay) >= 0 )
+			{
+				/* Updating how far we are beyond and
+				 * flipping pages if beyond threshold
+				 */
+				app->beyondy += deltay;
+				if (app->beyondy > BEYOND_THRESHHOLD)
+				{
+					if( app->pageno > 1 )
+					{
+						app->pageno--;
+						pdfapp_showpage(app, 1, 1, 1, 0);
+						newy = -fz_pixmap_height(app->ctx, app->image);
+					}
+					app->beyondy = 0;
+				}
+				else if (app->beyondy < -BEYOND_THRESHHOLD)
+				{
+					if( app->pageno < app->pagecount )
+					{
+						app->pageno++;
+						pdfapp_showpage(app, 1, 1, 1, 0);
+						newy = 0;
+					}
+					app->beyondy = 0;
+				}
+			}
+			else
+				app->beyondy = 0;
+		}
+		/* Although at this point we've already determined that
+		 * or that no scrolling will be performed in
+		 * y-direction, the x-direction has not yet been taken
+		 * care off. Therefore
+		 */
+		pdfapp_panview(app, newx, newy);
+
+		app->selx = x;
+		app->sely = y;
+	}
+
+	else if (app->iscopying)
+	{
+		app->selr.x0 = fz_mini(app->selx, x) - app->panx + irect.x0;
+		app->selr.x1 = fz_maxi(app->selx, x) - app->panx + irect.x0;
+		app->selr.y0 = fz_mini(app->sely, y) - app->pany + irect.y0;
+		app->selr.y1 = fz_maxi(app->sely, y) - app->pany + irect.y0;
+		winrepaint(app);
+	}
+
+}
+
+void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen)
+{
+	fz_rect hitbox;
+	fz_matrix ctm;
+	fz_text_page *page = app->page_text;
+	int c, i, p;
+	int seen = 0;
+	int block_num;
+
+	int x0 = app->selr.x0;
+	int x1 = app->selr.x1;
+	int y0 = app->selr.y0;
+	int y1 = app->selr.y1;
+
+	pdfapp_viewctm(&ctm, app);
+
+	p = 0;
+
+	for (block_num = 0; block_num < page->len; block_num++)
+	{
+		fz_text_line *line;
+		fz_text_block *block;
+		fz_text_span *span;
+
+		if (page->blocks[block_num].type != FZ_PAGE_BLOCK_TEXT)
+			continue;
+		block = page->blocks[block_num].u.text;
+
+		for (line = block->lines; line < block->lines + block->len; line++)
+		{
+			for (span = line->first_span; span; span = span->next)
+			{
+				if (seen)
+				{
+#ifdef _WIN32
+					if (p < ucslen - 1)
+						ucsbuf[p++] = '\r';
+#endif
+					if (p < ucslen - 1)
+						ucsbuf[p++] = '\n';
+				}
+
+				seen = 0;
+
+				for (i = 0; i < span->len; i++)
+				{
+					fz_text_char_bbox(&hitbox, span, i);
+					fz_transform_rect(&hitbox, &ctm);
+					c = span->text[i].c;
+					if (c < 32)
+						c = '?';
+					if (hitbox.x1 >= x0 && hitbox.x0 <= x1 && hitbox.y1 >= y0 && hitbox.y0 <= y1)
+					{
+						if (p < ucslen - 1)
+							ucsbuf[p++] = c;
+						seen = 1;
+					}
+				}
+
+				seen = (seen && span == line->last_span);
+			}
+		}
+	}
+
+	ucsbuf[p] = 0;
+}
+
+void pdfapp_postblit(pdfapp_t *app)
+{
+	clock_t time;
+	float seconds;
+	int llama;
+
+	app->transitions_enabled = 1;
+	if (!app->in_transit)
+		return;
+	time = clock();
+	seconds = (float)(time - app->start_time) / CLOCKS_PER_SEC;
+	llama = seconds * 256 / app->transition.duration;
+	if (llama >= 256)
+	{
+		/* Completed. */
+		fz_drop_pixmap(app->ctx, app->image);
+		app->image = app->new_image;
+		app->new_image = NULL;
+		fz_drop_pixmap(app->ctx, app->old_image);
+		app->old_image = NULL;
+		if (app->duration != 0)
+			winadvancetimer(app, app->duration);
+	}
+	else
+		fz_generate_transition(app->image, app->old_image, app->new_image, llama, &app->transition);
+	winrepaint(app);
+	if (llama >= 256)
+	{
+		/* Completed. */
+		app->in_transit = 0;
+	}
+}
diff --git a/platform/x11/pdfapp.h b/platform/x11/pdfapp.h
new file mode 100644
index 00000000..3e40e0c4
--- /dev/null
+++ b/platform/x11/pdfapp.h
@@ -0,0 +1,149 @@
+#ifndef PDFAPP_H
+#define PDFAPP_H
+
+#include "mupdf/fitz.h"
+#include "mupdf/pdf.h"
+
+/*
+ * Utility object for handling a pdf application / view
+ * Takes care of PDF loading and displaying and navigation,
+ * uses a number of callbacks to the GUI app.
+ */
+
+#define MINRES 54
+#define MAXRES 300
+
+typedef struct pdfapp_s pdfapp_t;
+
+enum { ARROW, HAND, WAIT, CARET };
+
+enum { DISCARD, SAVE, CANCEL };
+
+extern void winwarn(pdfapp_t*, char *s);
+extern void winerror(pdfapp_t*, char *s);
+extern void wintitle(pdfapp_t*, char *title);
+extern void winresize(pdfapp_t*, int w, int h);
+extern void winrepaint(pdfapp_t*);
+extern void winrepaintsearch(pdfapp_t*);
+extern char *winpassword(pdfapp_t*, char *filename);
+extern char *wintextinput(pdfapp_t*, char *inittext, int retry);
+extern int winchoiceinput(pdfapp_t*, int nopts, char *opts[], int *nvals, char *vals[]);
+extern void winopenuri(pdfapp_t*, char *s);
+extern void wincursor(pdfapp_t*, int curs);
+extern void windocopy(pdfapp_t*);
+extern void winreloadfile(pdfapp_t*);
+extern void windrawstring(pdfapp_t*, int x, int y, char *s);
+extern void winclose(pdfapp_t*);
+extern void winhelp(pdfapp_t*);
+extern void winfullscreen(pdfapp_t*, int state);
+extern int winsavequery(pdfapp_t*);
+extern int wingetsavepath(pdfapp_t*, char *buf, int len);
+extern void winalert(pdfapp_t *, pdf_alert_event *alert);
+extern void winprint(pdfapp_t *);
+extern void winadvancetimer(pdfapp_t *, float duration);
+extern void winreplacefile(char *source, char *target);
+
+struct pdfapp_s
+{
+	/* current document params */
+	fz_document *doc;
+	char *docpath;
+	char *doctitle;
+	fz_outline *outline;
+
+	int pagecount;
+
+	/* current view params */
+	int resolution;
+	int rotate;
+	fz_pixmap *image;
+	int grayscale;
+	fz_colorspace *colorspace;
+	int invert;
+
+	/* presentation mode */
+	int presentation_mode;
+	int transitions_enabled;
+	fz_pixmap *old_image;
+	fz_pixmap *new_image;
+	clock_t start_time;
+	int in_transit;
+	float duration;
+	fz_transition transition;
+
+	/* current page params */
+	int pageno;
+	fz_page *page;
+	fz_rect page_bbox;
+	fz_display_list *page_list;
+	fz_display_list *annotations_list;
+	fz_text_page *page_text;
+	fz_text_sheet *page_sheet;
+	fz_link *page_links;
+	int errored;
+
+	/* snapback history */
+	int hist[256];
+	int histlen;
+	int marks[10];
+
+	/* window system sizes */
+	int winw, winh;
+	int scrw, scrh;
+	int shrinkwrap;
+	int fullscreen;
+
+	/* event handling state */
+	char number[256];
+	int numberlen;
+
+	int ispanning;
+	int panx, pany;
+
+	int iscopying;
+	int selx, sely;
+	/* TODO - While sely keeps track of the relative change in
+	 * cursor position between two ticks/events, beyondy shall keep
+	 * track of the relative change in cursor position from the
+	 * point where the user hits a scrolling limit. This is ugly.
+	 * Used in pdfapp.c:pdfapp_onmouse.
+	 */
+	int beyondy;
+	fz_rect selr;
+
+	int nowaitcursor;
+
+	/* search state */
+	int isediting;
+	int searchdir;
+	char search[512];
+	int searchpage;
+	fz_rect hit_bbox[512];
+	int hit_count;
+
+	/* client context storage */
+	void *userdata;
+
+	fz_context *ctx;
+};
+
+void pdfapp_init(fz_context *ctx, pdfapp_t *app);
+void pdfapp_open(pdfapp_t *app, char *filename, int reload);
+void pdfapp_close(pdfapp_t *app);
+int pdfapp_preclose(pdfapp_t *app);
+
+char *pdfapp_version(pdfapp_t *app);
+char *pdfapp_usage(pdfapp_t *app);
+
+void pdfapp_onkey(pdfapp_t *app, int c);
+void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int state);
+void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen);
+void pdfapp_onresize(pdfapp_t *app, int w, int h);
+void pdfapp_gotopage(pdfapp_t *app, int number);
+
+void pdfapp_invert(pdfapp_t *app, const fz_rect *rect);
+void pdfapp_inverthit(pdfapp_t *app);
+
+void pdfapp_postblit(pdfapp_t *app);
+
+#endif
diff --git a/platform/x11/win_main.c b/platform/x11/win_main.c
new file mode 100644
index 00000000..bf765d6b
--- /dev/null
+++ b/platform/x11/win_main.c
@@ -0,0 +1,1163 @@
+#include "pdfapp.h"
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+#ifndef _UNICODE
+#define _UNICODE
+#endif
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <commdlg.h>
+#include <shellapi.h>
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL 0x020A
+#endif
+
+#define MIN(x,y) ((x) < (y) ? (x) : (y))
+
+#define ID_ABOUT	0x1000
+#define ID_DOCINFO	0x1001
+
+static HWND hwndframe = NULL;
+static HWND hwndview = NULL;
+static HDC hdc;
+static HBRUSH bgbrush;
+static HBRUSH shbrush;
+static BITMAPINFO *dibinf;
+static HCURSOR arrowcurs, handcurs, waitcurs, caretcurs;
+static LRESULT CALLBACK frameproc(HWND, UINT, WPARAM, LPARAM);
+static LRESULT CALLBACK viewproc(HWND, UINT, WPARAM, LPARAM);
+static int timer_pending = 0;
+
+static int justcopied = 0;
+
+static pdfapp_t gapp;
+
+#define PATH_MAX (1024)
+
+static wchar_t wbuf[PATH_MAX];
+static char filename[PATH_MAX];
+
+/*
+ * Create registry keys to associate MuPDF with PDF and XPS files.
+ */
+
+#define OPEN_KEY(parent, name, ptr) \
+	RegCreateKeyExA(parent, name, 0, 0, 0, KEY_WRITE, 0, &ptr, 0)
+
+#define SET_KEY(parent, name, value) \
+	RegSetValueExA(parent, name, 0, REG_SZ, (const BYTE *)(value), strlen(value) + 1)
+
+void install_app(char *argv0)
+{
+	char buf[512];
+	HKEY software, classes, mupdf, dotpdf, dotxps;
+	HKEY shell, open, command, supported_types;
+	HKEY pdf_progids, xps_progids;
+
+	OPEN_KEY(HKEY_CURRENT_USER, "Software", software);
+	OPEN_KEY(software, "Classes", classes);
+	OPEN_KEY(classes, ".pdf", dotpdf);
+	OPEN_KEY(dotpdf, "OpenWithProgids", pdf_progids);
+	OPEN_KEY(classes, ".xps", dotxps);
+	OPEN_KEY(dotxps, "OpenWithProgids", xps_progids);
+	OPEN_KEY(classes, "MuPDF", mupdf);
+	OPEN_KEY(mupdf, "SupportedTypes", supported_types);
+	OPEN_KEY(mupdf, "shell", shell);
+	OPEN_KEY(shell, "open", open);
+	OPEN_KEY(open, "command", command);
+
+	sprintf(buf, "\"%s\" \"%%1\"", argv0);
+
+	SET_KEY(open, "FriendlyAppName", "MuPDF");
+	SET_KEY(command, "", buf);
+	SET_KEY(supported_types, ".pdf", "");
+	SET_KEY(supported_types, ".xps", "");
+	SET_KEY(pdf_progids, "MuPDF", "");
+	SET_KEY(xps_progids, "MuPDF", "");
+
+	RegCloseKey(dotxps);
+	RegCloseKey(dotpdf);
+	RegCloseKey(mupdf);
+	RegCloseKey(classes);
+	RegCloseKey(software);
+}
+
+/*
+ * Dialog boxes
+ */
+
+void winwarn(pdfapp_t *app, char *msg)
+{
+	MessageBoxA(hwndframe, msg, "MuPDF: Warning", MB_ICONWARNING);
+}
+
+void winerror(pdfapp_t *app, char *msg)
+{
+	MessageBoxA(hwndframe, msg, "MuPDF: Error", MB_ICONERROR);
+	exit(1);
+}
+
+void winalert(pdfapp_t *app, pdf_alert_event *alert)
+{
+	int buttons = MB_OK;
+	int icon = MB_ICONWARNING;
+	int pressed = PDF_ALERT_BUTTON_NONE;
+
+	switch (alert->icon_type)
+	{
+	case PDF_ALERT_ICON_ERROR:
+		icon = MB_ICONERROR;
+		break;
+	case PDF_ALERT_ICON_WARNING:
+		icon = MB_ICONWARNING;
+		break;
+	case PDF_ALERT_ICON_QUESTION:
+		icon = MB_ICONQUESTION;
+		break;
+	case PDF_ALERT_ICON_STATUS:
+		icon = MB_ICONINFORMATION;
+		break;
+	}
+
+	switch (alert->button_group_type)
+	{
+	case PDF_ALERT_BUTTON_GROUP_OK:
+		buttons = MB_OK;
+		break;
+	case PDF_ALERT_BUTTON_GROUP_OK_CANCEL:
+		buttons = MB_OKCANCEL;
+		break;
+	case PDF_ALERT_BUTTON_GROUP_YES_NO:
+		buttons = MB_YESNO;
+		break;
+	case PDF_ALERT_BUTTON_GROUP_YES_NO_CANCEL:
+		buttons = MB_YESNOCANCEL;
+		break;
+	}
+
+	pressed = MessageBoxA(hwndframe, alert->message, alert->title, icon|buttons);
+
+	switch (pressed)
+	{
+	case IDOK:
+		alert->button_pressed = PDF_ALERT_BUTTON_OK;
+		break;
+	case IDCANCEL:
+		alert->button_pressed = PDF_ALERT_BUTTON_CANCEL;
+		break;
+	case IDNO:
+		alert->button_pressed = PDF_ALERT_BUTTON_NO;
+		break;
+	case IDYES:
+		alert->button_pressed = PDF_ALERT_BUTTON_YES;
+	}
+}
+
+void winprint(pdfapp_t *app)
+{
+	MessageBoxA(hwndframe, "The MuPDF library supports printing, but this application currently does not", "Print document", MB_ICONWARNING);
+}
+
+int winsavequery(pdfapp_t *app)
+{
+	switch(MessageBoxA(hwndframe, "File has unsaved changes. Do you want to save", "MuPDF", MB_YESNOCANCEL))
+	{
+	case IDYES: return SAVE;
+	case IDNO: return DISCARD;
+	default: return CANCEL;
+	}
+}
+
+int winfilename(wchar_t *buf, int len)
+{
+	OPENFILENAME ofn;
+	buf[0] = 0;
+	memset(&ofn, 0, sizeof(OPENFILENAME));
+	ofn.lStructSize = sizeof(OPENFILENAME);
+	ofn.hwndOwner = hwndframe;
+	ofn.lpstrFile = buf;
+	ofn.nMaxFile = len;
+	ofn.lpstrInitialDir = NULL;
+	ofn.lpstrTitle = L"MuPDF: Open PDF file";
+	ofn.lpstrFilter = L"Documents (*.pdf;*.xps;*.cbz;*.zip;*.png;*.jpg;*.tif)\0*.zip;*.cbz;*.xps;*.pdf;*.jpe;*.jpg;*.jpeg;*.jfif;*.tif;*.tiff\0PDF Files (*.pdf)\0*.pdf\0XPS Files (*.xps)\0*.xps\0CBZ Files (*.cbz;*.zip)\0*.zip;*.cbz\0Image Files (*.png;*.jpe;*.tif)\0*.png;*.jpg;*.jpe;*.jpeg;*.jfif;*.tif;*.tiff\0All Files\0*\0\0";
+	ofn.Flags = OFN_FILEMUSTEXIST|OFN_HIDEREADONLY;
+	return GetOpenFileNameW(&ofn);
+}
+
+int wingetsavepath(pdfapp_t *app, char *buf, int len)
+{
+	wchar_t twbuf[PATH_MAX];
+	OPENFILENAME ofn;
+
+	wcscpy(twbuf, wbuf);
+	memset(&ofn, 0, sizeof(OPENFILENAME));
+	ofn.lStructSize = sizeof(OPENFILENAME);
+	ofn.hwndOwner = hwndframe;
+	ofn.lpstrFile = twbuf;
+	ofn.nMaxFile = PATH_MAX;
+	ofn.lpstrInitialDir = NULL;
+	ofn.lpstrTitle = L"MuPDF: Save PDF file";
+	ofn.lpstrFilter = L"Documents (*.pdf;*.xps;*.cbz;*.zip;*.png;*.jpg;*.tif)\0*.zip;*.cbz;*.xps;*.pdf;*.jpe;*.jpg;*.jpeg;*.jfif;*.tif;*.tiff\0PDF Files (*.pdf)\0*.pdf\0XPS Files (*.xps)\0*.xps\0CBZ Files (*.cbz;*.zip)\0*.zip;*.cbz\0Image Files (*.png;*.jpe;*.tif)\0*.png;*.jpg;*.jpe;*.jpeg;*.jfif;*.tif;*.tiff\0All Files\0*\0\0";
+	ofn.Flags = OFN_HIDEREADONLY;
+	if (GetSaveFileName(&ofn))
+	{
+		int code = WideCharToMultiByte(CP_UTF8, 0, twbuf, -1, buf, MIN(PATH_MAX, len), NULL, NULL);
+		if (code == 0)
+		{
+			winerror(&gapp, "cannot convert filename to utf-8");
+			return 0;
+		}
+
+		wcscpy(wbuf, twbuf);
+		strcpy(filename, buf);
+		return 1;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+void winreplacefile(char *source, char *target)
+{
+	wchar_t wsource[PATH_MAX];
+	wchar_t wtarget[PATH_MAX];
+
+	int sz = MultiByteToWideChar(CP_UTF8, 0, source, -1, wsource, PATH_MAX);
+	if (sz == 0)
+	{
+		winerror(&gapp, "cannot convert filename to Unicode");
+		return;
+	}
+
+	sz = MultiByteToWideChar(CP_UTF8, 0, target, -1, wtarget, PATH_MAX);
+	if (sz == 0)
+	{
+		winerror(&gapp, "cannot convert filename to Unicode");
+		return;
+	}
+
+#if (_WIN32_WINNT >= 0x0500)
+	ReplaceFile(wtarget, wsource, NULL, REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL);
+#else
+	DeleteFile(wtarget);
+	MoveFile(wsource, wtarget);
+#endif
+}
+
+static char pd_filename[256] = "The file is encrypted.";
+static char pd_password[256] = "";
+static wchar_t pd_passwordw[256] = {0};
+static char td_textinput[1024] = "";
+static int td_retry = 0;
+static int cd_nopts;
+static int *cd_nvals;
+static char **cd_opts;
+static char **cd_vals;
+static int pd_okay = 0;
+
+INT CALLBACK
+dlogpassproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch(message)
+	{
+	case WM_INITDIALOG:
+		SetDlgItemTextA(hwnd, 4, pd_filename);
+		return TRUE;
+	case WM_COMMAND:
+		switch(wParam)
+		{
+		case 1:
+			pd_okay = 1;
+			GetDlgItemTextW(hwnd, 3, pd_passwordw, nelem(pd_passwordw));
+			EndDialog(hwnd, 1);
+			WideCharToMultiByte(CP_UTF8, 0, pd_passwordw, -1, pd_password, sizeof pd_password, NULL, NULL);
+			return TRUE;
+		case 2:
+			pd_okay = 0;
+			EndDialog(hwnd, 1);
+			return TRUE;
+		}
+		break;
+	}
+	return FALSE;
+}
+
+INT CALLBACK
+dlogtextproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch(message)
+	{
+	case WM_INITDIALOG:
+		SetDlgItemTextA(hwnd, 3, td_textinput);
+		if (!td_retry)
+			ShowWindow(GetDlgItem(hwnd, 4), SW_HIDE);
+		return TRUE;
+	case WM_COMMAND:
+		switch(wParam)
+		{
+		case 1:
+			pd_okay = 1;
+			GetDlgItemTextA(hwnd, 3, td_textinput, sizeof td_textinput);
+			EndDialog(hwnd, 1);
+			return TRUE;
+		case 2:
+			pd_okay = 0;
+			EndDialog(hwnd, 1);
+			return TRUE;
+		}
+		break;
+	case WM_CTLCOLORSTATIC:
+		if ((HWND)lParam == GetDlgItem(hwnd, 4))
+		{
+			SetTextColor((HDC)wParam, RGB(255,0,0));
+			SetBkMode((HDC)wParam, TRANSPARENT);
+
+			return (INT)GetStockObject(NULL_BRUSH);
+		}
+		break;
+	}
+	return FALSE;
+}
+
+INT CALLBACK
+dlogchoiceproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	HWND listbox;
+	int i;
+	int item;
+	int sel;
+	switch(message)
+	{
+	case WM_INITDIALOG:
+		listbox = GetDlgItem(hwnd, 3);
+		for (i = 0; i < cd_nopts; i++)
+			SendMessageA(listbox, LB_ADDSTRING, 0, (LPARAM)cd_opts[i]);
+
+		/* FIXME: handle multiple select */
+		if (*cd_nvals > 0)
+		{
+			item = SendMessageA(listbox, LB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)cd_vals[0]);
+			if (item != LB_ERR)
+				SendMessageA(listbox, LB_SETCURSEL, item, 0);
+		}
+		return TRUE;
+	case WM_COMMAND:
+		switch(wParam)
+		{
+		case 1:
+			listbox = GetDlgItem(hwnd, 3);
+			*cd_nvals = 0;
+			for (i = 0; i < cd_nopts; i++)
+			{
+				item = SendMessageA(listbox, LB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)cd_opts[i]);
+				sel = SendMessageA(listbox, LB_GETSEL, item, 0);
+				if (sel && sel != LB_ERR)
+					cd_vals[(*cd_nvals)++] = cd_opts[i];
+			}
+			pd_okay = 1;
+			EndDialog(hwnd, 1);
+			return TRUE;
+		case 2:
+			pd_okay = 0;
+			EndDialog(hwnd, 1);
+			return TRUE;
+		}
+		break;
+	}
+	return FALSE;
+}
+
+char *winpassword(pdfapp_t *app, char *filename)
+{
+	char buf[1024], *s;
+	int code;
+	strcpy(buf, filename);
+	s = buf;
+	if (strrchr(s, '\\')) s = strrchr(s, '\\') + 1;
+	if (strrchr(s, '/')) s = strrchr(s, '/') + 1;
+	if (strlen(s) > 32)
+		strcpy(s + 30, "...");
+	sprintf(pd_filename, "The file \"%s\" is encrypted.", s);
+	code = DialogBoxW(NULL, L"IDD_DLOGPASS", hwndframe, dlogpassproc);
+	if (code <= 0)
+		winerror(app, "cannot create password dialog");
+	if (pd_okay)
+		return pd_password;
+	return NULL;
+}
+
+char *wintextinput(pdfapp_t *app, char *inittext, int retry)
+{
+	int code;
+	td_retry = retry;
+	fz_strlcpy(td_textinput, inittext ? inittext : "", sizeof td_textinput);
+	code = DialogBoxW(NULL, L"IDD_DLOGTEXT", hwndframe, dlogtextproc);
+	if (code <= 0)
+		winerror(app, "cannot create text input dialog");
+	if (pd_okay)
+		return td_textinput;
+	return NULL;
+}
+
+int winchoiceinput(pdfapp_t *app, int nopts, char *opts[], int *nvals, char *vals[])
+{
+	int code;
+	cd_nopts = nopts;
+	cd_nvals = nvals;
+	cd_opts = opts;
+	cd_vals = vals;
+	code = DialogBoxW(NULL, L"IDD_DLOGLIST", hwndframe, dlogchoiceproc);
+	if (code <= 0)
+		winerror(app, "cannot create text input dialog");
+	return pd_okay;
+}
+
+INT CALLBACK
+dloginfoproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	char buf[256];
+	fz_document *doc = gapp.doc;
+
+	switch(message)
+	{
+	case WM_INITDIALOG:
+
+		SetDlgItemTextW(hwnd, 0x10, wbuf);
+
+		if (fz_meta(doc, FZ_META_FORMAT_INFO, buf, 256) < 0)
+		{
+			SetDlgItemTextA(hwnd, 0x11, "Unknown");
+			SetDlgItemTextA(hwnd, 0x12, "None");
+			SetDlgItemTextA(hwnd, 0x13, "n/a");
+			return TRUE;
+		}
+
+		SetDlgItemTextA(hwnd, 0x11, buf);
+
+		if (fz_meta(doc, FZ_META_CRYPT_INFO, buf, 256) == 0)
+		{
+			SetDlgItemTextA(hwnd, 0x12, buf);
+		}
+		else
+		{
+			SetDlgItemTextA(hwnd, 0x12, "None");
+		}
+		buf[0] = 0;
+		if (fz_meta(doc, FZ_META_HAS_PERMISSION, NULL, FZ_PERMISSION_PRINT) == 0)
+			strcat(buf, "print, ");
+		if (fz_meta(doc, FZ_META_HAS_PERMISSION, NULL, FZ_PERMISSION_CHANGE) == 0)
+			strcat(buf, "modify, ");
+		if (fz_meta(doc, FZ_META_HAS_PERMISSION, NULL, FZ_PERMISSION_COPY) == 0)
+			strcat(buf, "copy, ");
+		if (fz_meta(doc, FZ_META_HAS_PERMISSION, NULL, FZ_PERMISSION_NOTES) == 0)
+			strcat(buf, "annotate, ");
+		if (strlen(buf) > 2)
+			buf[strlen(buf)-2] = 0;
+		else
+			strcpy(buf, "None");
+		SetDlgItemTextA(hwnd, 0x13, buf);
+
+#define SETUTF8(ID, STRING) \
+		{ \
+			*(char **)buf = STRING; \
+			if (fz_meta(doc, FZ_META_INFO, buf, 256) <= 0) \
+				buf[0] = 0; \
+			SetDlgItemTextA(hwnd, ID, buf); \
+		}
+
+		SETUTF8(0x20, "Title");
+		SETUTF8(0x21, "Author");
+		SETUTF8(0x22, "Subject");
+		SETUTF8(0x23, "Keywords");
+		SETUTF8(0x24, "Creator");
+		SETUTF8(0x25, "Producer");
+		SETUTF8(0x26, "CreationDate");
+		SETUTF8(0x27, "ModDate");
+		return TRUE;
+
+	case WM_COMMAND:
+		EndDialog(hwnd, 1);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+void info()
+{
+	int code = DialogBoxW(NULL, L"IDD_DLOGINFO", hwndframe, dloginfoproc);
+	if (code <= 0)
+		winerror(&gapp, "cannot create info dialog");
+}
+
+INT CALLBACK
+dlogaboutproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch(message)
+	{
+	case WM_INITDIALOG:
+		SetDlgItemTextA(hwnd, 2, pdfapp_version(&gapp));
+		SetDlgItemTextA(hwnd, 3, pdfapp_usage(&gapp));
+		return TRUE;
+	case WM_COMMAND:
+		EndDialog(hwnd, 1);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+void winhelp(pdfapp_t*app)
+{
+	int code = DialogBoxW(NULL, L"IDD_DLOGABOUT", hwndframe, dlogaboutproc);
+	if (code <= 0)
+		winerror(&gapp, "cannot create help dialog");
+}
+
+/*
+ * Main window
+ */
+
+void winopen()
+{
+	WNDCLASS wc;
+	HMENU menu;
+	RECT r;
+	ATOM a;
+
+	/* Create and register window frame class */
+	memset(&wc, 0, sizeof(wc));
+	wc.style = 0;
+	wc.lpfnWndProc = frameproc;
+	wc.cbClsExtra = 0;
+	wc.cbWndExtra = 0;
+	wc.hInstance = GetModuleHandle(NULL);
+	wc.hIcon = LoadIconA(wc.hInstance, "IDI_ICONAPP");
+	wc.hCursor = NULL; //LoadCursor(NULL, IDC_ARROW);
+	wc.hbrBackground = NULL;
+	wc.lpszMenuName = NULL;
+	wc.lpszClassName = L"FrameWindow";
+	a = RegisterClassW(&wc);
+	if (!a)
+		winerror(&gapp, "cannot register frame window class");
+
+	/* Create and register window view class */
+	memset(&wc, 0, sizeof(wc));
+	wc.style = CS_HREDRAW | CS_VREDRAW;
+	wc.lpfnWndProc = viewproc;
+	wc.cbClsExtra = 0;
+	wc.cbWndExtra = 0;
+	wc.hInstance = GetModuleHandle(NULL);
+	wc.hIcon = NULL;
+	wc.hCursor = NULL;
+	wc.hbrBackground = NULL;
+	wc.lpszMenuName = NULL;
+	wc.lpszClassName = L"ViewWindow";
+	a = RegisterClassW(&wc);
+	if (!a)
+		winerror(&gapp, "cannot register view window class");
+
+	/* Get screen size */
+	SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
+	gapp.scrw = r.right - r.left;
+	gapp.scrh = r.bottom - r.top;
+
+	/* Create cursors */
+	arrowcurs = LoadCursor(NULL, IDC_ARROW);
+	handcurs = LoadCursor(NULL, IDC_HAND);
+	waitcurs = LoadCursor(NULL, IDC_WAIT);
+	caretcurs = LoadCursor(NULL, IDC_IBEAM);
+
+	/* And a background color */
+	bgbrush = CreateSolidBrush(RGB(0x70,0x70,0x70));
+	shbrush = CreateSolidBrush(RGB(0x40,0x40,0x40));
+
+	/* Init DIB info for buffer */
+	dibinf = malloc(sizeof(BITMAPINFO) + 12);
+	assert(dibinf);
+	dibinf->bmiHeader.biSize = sizeof(dibinf->bmiHeader);
+	dibinf->bmiHeader.biPlanes = 1;
+	dibinf->bmiHeader.biBitCount = 32;
+	dibinf->bmiHeader.biCompression = BI_RGB;
+	dibinf->bmiHeader.biXPelsPerMeter = 2834;
+	dibinf->bmiHeader.biYPelsPerMeter = 2834;
+	dibinf->bmiHeader.biClrUsed = 0;
+	dibinf->bmiHeader.biClrImportant = 0;
+	dibinf->bmiHeader.biClrUsed = 0;
+
+	/* Create window */
+	hwndframe = CreateWindowW(L"FrameWindow", // window class name
+	NULL, // window caption
+	WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
+	CW_USEDEFAULT, CW_USEDEFAULT, // initial position
+	300, // initial x size
+	300, // initial y size
+	0, // parent window handle
+	0, // window menu handle
+	0, // program instance handle
+	0); // creation parameters
+	if (!hwndframe)
+		winerror(&gapp, "cannot create frame");
+
+	hwndview = CreateWindowW(L"ViewWindow", // window class name
+	NULL,
+	WS_VISIBLE | WS_CHILD,
+	CW_USEDEFAULT, CW_USEDEFAULT,
+	CW_USEDEFAULT, CW_USEDEFAULT,
+	hwndframe, 0, 0, 0);
+	if (!hwndview)
+		winerror(&gapp, "cannot create view");
+
+	hdc = NULL;
+
+	SetWindowTextW(hwndframe, L"MuPDF");
+
+	menu = GetSystemMenu(hwndframe, 0);
+	AppendMenuW(menu, MF_SEPARATOR, 0, NULL);
+	AppendMenuW(menu, MF_STRING, ID_ABOUT, L"About MuPDF...");
+	AppendMenuW(menu, MF_STRING, ID_DOCINFO, L"Document Properties...");
+
+	SetCursor(arrowcurs);
+}
+
+void winclose(pdfapp_t *app)
+{
+	if (pdfapp_preclose(app))
+	{
+		pdfapp_close(app);
+		exit(0);
+	}
+}
+
+void wincursor(pdfapp_t *app, int curs)
+{
+	if (curs == ARROW)
+		SetCursor(arrowcurs);
+	if (curs == HAND)
+		SetCursor(handcurs);
+	if (curs == WAIT)
+		SetCursor(waitcurs);
+	if (curs == CARET)
+		SetCursor(caretcurs);
+}
+
+void wintitle(pdfapp_t *app, char *title)
+{
+	wchar_t wide[256], *dp;
+	char *sp;
+	int rune;
+
+	dp = wide;
+	sp = title;
+	while (*sp && dp < wide + 255)
+	{
+		sp += fz_chartorune(&rune, sp);
+		*dp++ = rune;
+	}
+	*dp = 0;
+
+	SetWindowTextW(hwndframe, wide);
+}
+
+void windrawrect(pdfapp_t *app, int x0, int y0, int x1, int y1)
+{
+	RECT r;
+	r.left = x0;
+	r.top = y0;
+	r.right = x1;
+	r.bottom = y1;
+	FillRect(hdc, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));
+}
+
+void windrawstring(pdfapp_t *app, int x, int y, char *s)
+{
+	HFONT font = (HFONT)GetStockObject(ANSI_FIXED_FONT);
+	SelectObject(hdc, font);
+	TextOutA(hdc, x, y - 12, s, strlen(s));
+}
+
+void winblitsearch()
+{
+	if (gapp.isediting)
+	{
+		char buf[sizeof(gapp.search) + 50];
+		sprintf(buf, "Search: %s", gapp.search);
+		windrawrect(&gapp, 0, 0, gapp.winw, 30);
+		windrawstring(&gapp, 10, 20, buf);
+	}
+}
+
+void winblit()
+{
+	int image_w = fz_pixmap_width(gapp.ctx, gapp.image);
+	int image_h = fz_pixmap_height(gapp.ctx, gapp.image);
+	int image_n = fz_pixmap_components(gapp.ctx, gapp.image);
+	unsigned char *samples = fz_pixmap_samples(gapp.ctx, gapp.image);
+	int x0 = gapp.panx;
+	int y0 = gapp.pany;
+	int x1 = gapp.panx + image_w;
+	int y1 = gapp.pany + image_h;
+	RECT r;
+
+	if (gapp.image)
+	{
+		if (gapp.iscopying || justcopied)
+		{
+			pdfapp_invert(&gapp, &gapp.selr);
+			justcopied = 1;
+		}
+
+		pdfapp_inverthit(&gapp);
+
+		dibinf->bmiHeader.biWidth = image_w;
+		dibinf->bmiHeader.biHeight = -image_h;
+		dibinf->bmiHeader.biSizeImage = image_h * 4;
+
+		if (image_n == 2)
+		{
+			int i = image_w * image_h;
+			unsigned char *color = malloc(i*4);
+			unsigned char *s = samples;
+			unsigned char *d = color;
+			for (; i > 0 ; i--)
+			{
+				d[2] = d[1] = d[0] = *s++;
+				d[3] = *s++;
+				d += 4;
+			}
+			SetDIBitsToDevice(hdc,
+				gapp.panx, gapp.pany, image_w, image_h,
+				0, 0, 0, image_h, color,
+				dibinf, DIB_RGB_COLORS);
+			free(color);
+		}
+		if (image_n == 4)
+		{
+			SetDIBitsToDevice(hdc,
+				gapp.panx, gapp.pany, image_w, image_h,
+				0, 0, 0, image_h, samples,
+				dibinf, DIB_RGB_COLORS);
+		}
+
+		pdfapp_inverthit(&gapp);
+
+		if (gapp.iscopying || justcopied)
+		{
+			pdfapp_invert(&gapp, &gapp.selr);
+			justcopied = 1;
+		}
+	}
+
+	/* Grey background */
+	r.top = 0; r.bottom = gapp.winh;
+	r.left = 0; r.right = x0;
+	FillRect(hdc, &r, bgbrush);
+	r.left = x1; r.right = gapp.winw;
+	FillRect(hdc, &r, bgbrush);
+	r.left = 0; r.right = gapp.winw;
+	r.top = 0; r.bottom = y0;
+	FillRect(hdc, &r, bgbrush);
+	r.top = y1; r.bottom = gapp.winh;
+	FillRect(hdc, &r, bgbrush);
+
+	/* Drop shadow */
+	r.left = x0 + 2;
+	r.right = x1 + 2;
+	r.top = y1;
+	r.bottom = y1 + 2;
+	FillRect(hdc, &r, shbrush);
+	r.left = x1;
+	r.right = x1 + 2;
+	r.top = y0 + 2;
+	r.bottom = y1;
+	FillRect(hdc, &r, shbrush);
+
+	winblitsearch();
+}
+
+void winresize(pdfapp_t *app, int w, int h)
+{
+	ShowWindow(hwndframe, SW_SHOWDEFAULT);
+	w += GetSystemMetrics(SM_CXFRAME) * 2;
+	h += GetSystemMetrics(SM_CYFRAME) * 2;
+	h += GetSystemMetrics(SM_CYCAPTION);
+	SetWindowPos(hwndframe, 0, 0, 0, w, h, SWP_NOZORDER | SWP_NOMOVE);
+}
+
+void winrepaint(pdfapp_t *app)
+{
+	InvalidateRect(hwndview, NULL, 0);
+}
+
+void winrepaintsearch(pdfapp_t *app)
+{
+	// TODO: invalidate only search area and
+	// call only search redraw routine.
+	InvalidateRect(hwndview, NULL, 0);
+}
+
+void winfullscreen(pdfapp_t *app, int state)
+{
+	static WINDOWPLACEMENT savedplace;
+	static int isfullscreen = 0;
+	if (state && !isfullscreen)
+	{
+		GetWindowPlacement(hwndframe, &savedplace);
+		SetWindowLong(hwndframe, GWL_STYLE, WS_POPUP | WS_VISIBLE);
+		SetWindowPos(hwndframe, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED);
+		ShowWindow(hwndframe, SW_SHOWMAXIMIZED);
+		isfullscreen = 1;
+	}
+	if (!state && isfullscreen)
+	{
+		SetWindowLong(hwndframe, GWL_STYLE, WS_OVERLAPPEDWINDOW);
+		SetWindowPos(hwndframe, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED);
+		SetWindowPlacement(hwndframe, &savedplace);
+		isfullscreen = 0;
+	}
+}
+
+/*
+ * Event handling
+ */
+
+void windocopy(pdfapp_t *app)
+{
+	HGLOBAL handle;
+	unsigned short *ucsbuf;
+
+	if (!OpenClipboard(hwndframe))
+		return;
+	EmptyClipboard();
+
+	handle = GlobalAlloc(GMEM_MOVEABLE, 4096 * sizeof(unsigned short));
+	if (!handle)
+	{
+		CloseClipboard();
+		return;
+	}
+
+	ucsbuf = GlobalLock(handle);
+	pdfapp_oncopy(&gapp, ucsbuf, 4096);
+	GlobalUnlock(handle);
+
+	SetClipboardData(CF_UNICODETEXT, handle);
+	CloseClipboard();
+
+	justcopied = 1;	/* keep inversion around for a while... */
+}
+
+void winreloadfile(pdfapp_t *app)
+{
+	pdfapp_close(app);
+	pdfapp_open(app, filename, 1);
+}
+
+void winopenuri(pdfapp_t *app, char *buf)
+{
+	ShellExecuteA(hwndframe, "open", buf, 0, 0, SW_SHOWNORMAL);
+}
+
+#define OUR_TIMER_ID 1
+
+void winadvancetimer(pdfapp_t *app, float delay)
+{
+	timer_pending = 1;
+	SetTimer(hwndview, OUR_TIMER_ID, (unsigned int)(1000*delay), NULL);
+}
+
+static void killtimer(pdfapp_t *app)
+{
+	timer_pending = 0;
+}
+
+void handlekey(int c)
+{
+	if (timer_pending)
+		killtimer(&gapp);
+
+	if (GetCapture() == hwndview)
+		return;
+
+	if (justcopied)
+	{
+		justcopied = 0;
+		winrepaint(&gapp);
+	}
+
+	/* translate VK into ASCII equivalents */
+	if (c > 256)
+	{
+		switch (c - 256)
+		{
+		case VK_F1: c = '?'; break;
+		case VK_ESCAPE: c = '\033'; break;
+		case VK_DOWN: c = 'j'; break;
+		case VK_UP: c = 'k'; break;
+		case VK_LEFT: c = 'b'; break;
+		case VK_RIGHT: c = ' '; break;
+		case VK_PRIOR: c = ','; break;
+		case VK_NEXT: c = '.'; break;
+		}
+	}
+
+	pdfapp_onkey(&gapp, c);
+	winrepaint(&gapp);
+}
+
+void handlemouse(int x, int y, int btn, int state)
+{
+	if (state != 0 && timer_pending)
+		killtimer(&gapp);
+
+	if (state != 0 && justcopied)
+	{
+		justcopied = 0;
+		winrepaint(&gapp);
+	}
+
+	if (state == 1)
+		SetCapture(hwndview);
+	if (state == -1)
+		ReleaseCapture();
+
+	pdfapp_onmouse(&gapp, x, y, btn, 0, state);
+}
+
+LRESULT CALLBACK
+frameproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	switch(message)
+	{
+	case WM_SETFOCUS:
+		PostMessage(hwnd, WM_APP+5, 0, 0);
+		return 0;
+	case WM_APP+5:
+		SetFocus(hwndview);
+		return 0;
+
+	case WM_DESTROY:
+		PostQuitMessage(0);
+		return 0;
+
+	case WM_SYSCOMMAND:
+		if (wParam == ID_ABOUT)
+		{
+			winhelp(&gapp);
+			return 0;
+		}
+		if (wParam == ID_DOCINFO)
+		{
+			info();
+			return 0;
+		}
+		if (wParam == SC_MAXIMIZE)
+			gapp.shrinkwrap = 0;
+		break;
+
+	case WM_SIZE:
+	{
+		// More generally, you should use GetEffectiveClientRect
+		// if you have a toolbar etc.
+		RECT rect;
+		GetClientRect(hwnd, &rect);
+		MoveWindow(hwndview, rect.left, rect.top,
+		rect.right-rect.left, rect.bottom-rect.top, TRUE);
+		return 0;
+	}
+
+	case WM_SIZING:
+		gapp.shrinkwrap = 0;
+		break;
+
+	case WM_NOTIFY:
+	case WM_COMMAND:
+		return SendMessage(hwndview, message, wParam, lParam);
+
+	case WM_CLOSE:
+		if (!pdfapp_preclose(&gapp))
+			return 0;
+	}
+
+	return DefWindowProc(hwnd, message, wParam, lParam);
+}
+
+LRESULT CALLBACK
+viewproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	static int oldx = 0;
+	static int oldy = 0;
+	int x = (signed short) LOWORD(lParam);
+	int y = (signed short) HIWORD(lParam);
+
+	switch (message)
+	{
+	case WM_SIZE:
+		if (wParam == SIZE_MINIMIZED)
+			return 0;
+		if (wParam == SIZE_MAXIMIZED)
+			gapp.shrinkwrap = 0;
+		pdfapp_onresize(&gapp, LOWORD(lParam), HIWORD(lParam));
+		break;
+
+	/* Paint events are low priority and automagically catenated
+	 * so we don't need to do any fancy waiting to defer repainting.
+	 */
+	case WM_PAINT:
+	{
+		//puts("WM_PAINT");
+		PAINTSTRUCT ps;
+		hdc = BeginPaint(hwnd, &ps);
+		winblit();
+		hdc = NULL;
+		EndPaint(hwnd, &ps);
+		pdfapp_postblit(&gapp);
+		return 0;
+	}
+
+	case WM_ERASEBKGND:
+		return 1; // well, we don't need to erase to redraw cleanly
+
+	/* Mouse events */
+
+	case WM_LBUTTONDOWN:
+		SetFocus(hwndview);
+		oldx = x; oldy = y;
+		handlemouse(x, y, 1, 1);
+		return 0;
+	case WM_MBUTTONDOWN:
+		SetFocus(hwndview);
+		oldx = x; oldy = y;
+		handlemouse(x, y, 2, 1);
+		return 0;
+	case WM_RBUTTONDOWN:
+		SetFocus(hwndview);
+		oldx = x; oldy = y;
+		handlemouse(x, y, 3, 1);
+		return 0;
+
+	case WM_LBUTTONUP:
+		oldx = x; oldy = y;
+		handlemouse(x, y, 1, -1);
+		return 0;
+	case WM_MBUTTONUP:
+		oldx = x; oldy = y;
+		handlemouse(x, y, 2, -1);
+		return 0;
+	case WM_RBUTTONUP:
+		oldx = x; oldy = y;
+		handlemouse(x, y, 3, -1);
+		return 0;
+
+	case WM_MOUSEMOVE:
+		oldx = x; oldy = y;
+		handlemouse(x, y, 0, 0);
+		return 0;
+
+	/* Mouse wheel */
+
+	case WM_MOUSEWHEEL:
+		if ((signed short)HIWORD(wParam) > 0)
+			handlekey(LOWORD(wParam) & MK_SHIFT ? '+' : 'k');
+		else
+			handlekey(LOWORD(wParam) & MK_SHIFT ? '-' : 'j');
+		return 0;
+
+	/* Timer */
+	case WM_TIMER:
+		if (wParam == OUR_TIMER_ID && timer_pending && gapp.presentation_mode)
+		{
+			timer_pending = 0;
+			handlekey(VK_RIGHT + 256);
+			handlemouse(oldx, oldy, 0, 0); /* update cursor */
+			return 0;
+		}
+		break;
+
+	/* Keyboard events */
+
+	case WM_KEYDOWN:
+		/* only handle special keys */
+		switch (wParam)
+		{
+		case VK_F1:
+		case VK_LEFT:
+		case VK_UP:
+		case VK_PRIOR:
+		case VK_RIGHT:
+		case VK_DOWN:
+		case VK_NEXT:
+		case VK_ESCAPE:
+			handlekey(wParam + 256);
+			handlemouse(oldx, oldy, 0, 0);	/* update cursor */
+			return 0;
+		}
+		return 1;
+
+	/* unicode encoded chars, including escape, backspace etc... */
+	case WM_CHAR:
+		if (wParam < 256)
+		{
+			handlekey(wParam);
+			handlemouse(oldx, oldy, 0, 0);	/* update cursor */
+		}
+		return 0;
+	}
+
+	fflush(stdout);
+
+	/* Pass on unhandled events to Windows */
+	return DefWindowProc(hwnd, message, wParam, lParam);
+}
+
+int WINAPI
+WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
+{
+	int argc;
+	LPWSTR *argv = CommandLineToArgvW(GetCommandLineW(), &argc);
+	char argv0[256];
+	MSG msg;
+	int code;
+	fz_context *ctx;
+
+	ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
+	if (!ctx)
+	{
+		fprintf(stderr, "cannot initialise context\n");
+		exit(1);
+	}
+	pdfapp_init(ctx, &gapp);
+
+	GetModuleFileNameA(NULL, argv0, sizeof argv0);
+	install_app(argv0);
+
+	winopen();
+
+	if (argc == 2)
+	{
+		wcscpy(wbuf, argv[1]);
+	}
+	else
+	{
+		if (!winfilename(wbuf, nelem(wbuf)))
+			exit(0);
+	}
+
+	code = WideCharToMultiByte(CP_UTF8, 0, wbuf, -1, filename, sizeof filename, NULL, NULL);
+	if (code == 0)
+		winerror(&gapp, "cannot convert filename to utf-8");
+
+	pdfapp_open(&gapp, filename, 0);
+
+	while (GetMessage(&msg, NULL, 0, 0))
+	{
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	}
+
+	pdfapp_close(&gapp);
+
+	return 0;
+}
diff --git a/platform/x11/win_res.rc b/platform/x11/win_res.rc
new file mode 100644
index 00000000..fbf6915c
--- /dev/null
+++ b/platform/x11/win_res.rc
@@ -0,0 +1,82 @@
+IDI_ICONAPP ICON "mupdf.ico"
+
+IDD_DLOGPASS DIALOG 50, 50, 204, 60
+//STYLE DS_MODALFRAME | WS_POPUP
+STYLE 128 | 0x80000000
+CAPTION " MuPDF: Password "
+FONT 8, "MS Shell Dlg"
+BEGIN
+	EDITTEXT			3, 57, 20, 140, 12, 32
+	DEFPUSHBUTTON "Okay",		1, 90, 40, 50, 14, 0x50010001
+	PUSHBUTTON "Cancel",		2, 147, 40, 50, 14, 0x50010000
+	LTEXT "The file is encrypted.", 4, 10, 7, 180, 10, 0x00000
+	LTEXT "Password:",		5, 17, 22, 40, 10, 0x00000
+END
+
+IDD_DLOGINFO DIALOG 50, 50, 300, 145
+STYLE 128 | 0x80000000
+CAPTION " Document Properties "
+FONT 8, "MS Shell Dlg"
+BEGIN
+	DEFPUSHBUTTON "Okay",	1, 300-10-50, 145-7-14, 50, 14, 0x50010001
+
+	LTEXT "File:",		-1, 10, 10, 50, 10, 0
+	LTEXT "Format:",	-1, 10, 20, 50, 10, 0
+	LTEXT "Encryption:",	-1, 10, 30, 50, 10, 0
+	LTEXT "Permissions:",	-1, 10, 40, 50, 10, 0
+
+	LTEXT "<file",		0x10, 60, 10, 230, 10, 0
+	LTEXT "<version",	0x11, 60, 20, 230, 10, 0
+	LTEXT "<encryption",	0x12, 60, 30, 230, 10, 0
+	LTEXT "<permissions",	0x13, 60, 40, 230, 10, 0
+
+	LTEXT "Title:",		-1, 10, 55, 50, 10, 0
+	LTEXT "Author:",	-1, 10, 65, 50, 10, 0
+	LTEXT "Subject:",	-1, 10, 75, 50, 10, 0
+	LTEXT "Keywords:",	-1, 10, 85, 50, 10, 0
+	LTEXT "Creator:",	-1, 10, 95, 50, 10, 0
+	LTEXT "Producer:",	-1, 10, 105, 50, 10, 0
+	LTEXT "Created:",	-1, 10, 115, 50, 10, 0
+	LTEXT "Modified:",	-1, 10, 125, 50, 10, 0
+
+	LTEXT "",		0x20, 60, 55, 230, 10, 0
+	LTEXT "",		0x21, 60, 65, 230, 10, 0
+	LTEXT "",		0x22, 60, 75, 230, 10, 0
+	LTEXT "",		0x23, 60, 85, 230, 10, 0
+	LTEXT "",		0x24, 60, 95, 230, 10, 0
+	LTEXT "",		0x25, 60, 105, 230, 10, 0
+	LTEXT "",		0x26, 60, 115, 100, 10, 0
+	LTEXT "",		0x27, 60, 125, 100, 10, 0
+END
+
+IDD_DLOGTEXT DIALOG 50, 50, 204, 85
+STYLE 128 | 0x80000000
+CAPTION " MuPDF: fill out form"
+FONT 8, "MS Shell Dlg"
+BEGIN
+	EDITTEXT		3,8,7,183,50,0x1004
+	DEFPUSHBUTTON	"Okay",1,89,64,50,14
+	PUSHBUTTON		"Cancel",2,147,64,50,14
+	LTEXT			"** Invalid value **",4,11,65,62,8
+END
+
+IDD_DLOGLIST DIALOG 50, 50, 204, 85
+STYLE 128 | 0x80000000
+CAPTION " MuPDF: select an item"
+FONT 8, "MS Shell Dlg"
+BEGIN
+	LISTBOX			3,8,7,183,50,0x210102
+	DEFPUSHBUTTON	"Okay",1,89,64,50,14
+	PUSHBUTTON		"Cancel",2,147,64,50,14
+END
+
+IDD_DLOGABOUT DIALOG 50, 50, 200, 300
+STYLE 128 | 0x80000000
+CAPTION " About MuPDF "
+FONT 8, "MS Shell Dlg"
+BEGIN
+	DEFPUSHBUTTON "Okay",	 1, 200-10-50, 300-7-14, 50, 14, 0x50010001
+	LTEXT "<copyright>",	 2, 10, 10, 180, 20, 0
+	LTEXT "<usage>",	 3, 10, 35, 180, 240, 0
+END
+
diff --git a/platform/x11/x11_image.c b/platform/x11/x11_image.c
new file mode 100644
index 00000000..4f2db2e8
--- /dev/null
+++ b/platform/x11/x11_image.c
@@ -0,0 +1,703 @@
+/*
+ * Blit RGBA images to X with X(Shm)Images
+ */
+
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 1
+#endif
+
+#ifndef _XOPEN_SOURCE
+# define _XOPEN_SOURCE 1
+#endif
+
+#define noSHOWINFO
+
+#include "mupdf/fitz.h"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <X11/extensions/XShm.h>
+
+extern int ffs(int);
+
+static int is_big_endian(void)
+{
+	static const int one = 1;
+	return *(char*)&one == 0;
+}
+
+typedef void (*ximage_convert_func_t)
+(
+	const unsigned char *src,
+	int srcstride,
+	unsigned char *dst,
+	int dststride,
+	int w,
+	int h
+	);
+
+#define POOLSIZE 4
+#define WIDTH 256
+#define HEIGHT 256
+
+enum {
+	ARGB8888,
+	BGRA8888,
+	RGBA8888,
+	ABGR8888,
+	RGB888,
+	BGR888,
+	RGB565,
+	RGB565_BR,
+	RGB555,
+	RGB555_BR,
+	BGR233,
+	UNKNOWN
+};
+
+#ifdef SHOWINFO
+static char *modename[] = {
+	"ARGB8888",
+	"BGRA8888",
+	"RGBA8888",
+	"ABGR8888",
+	"RGB888",
+	"BGR888",
+	"RGB565",
+	"RGB565_BR",
+	"RGB555",
+	"RGB555_BR",
+	"BGR233",
+	"UNKNOWN"
+};
+#endif
+
+extern ximage_convert_func_t ximage_convert_funcs[];
+
+static struct
+{
+	Display *display;
+	int screen;
+	XVisualInfo visual;
+	Colormap colormap;
+
+	int bitsperpixel;
+	int mode;
+
+	XColor rgbcube[256];
+
+	ximage_convert_func_t convert_func;
+
+	int useshm;
+	int shmcode;
+	XImage *pool[POOLSIZE];
+	/* MUST exist during the lifetime of the shared ximage according to the
+	xc/doc/hardcopy/Xext/mit-shm.PS.gz */
+	XShmSegmentInfo shminfo[POOLSIZE];
+	int lastused;
+} info;
+
+static XImage *
+createximage(Display *dpy, Visual *vis, XShmSegmentInfo *xsi, int depth, int w, int h)
+{
+	XImage *img;
+	Status status;
+
+	if (!XShmQueryExtension(dpy))
+		goto fallback;
+	if (!info.useshm)
+		goto fallback;
+
+	img = XShmCreateImage(dpy, vis, depth, ZPixmap, NULL, xsi, w, h);
+	if (!img)
+	{
+		fprintf(stderr, "warn: could not XShmCreateImage\n");
+		goto fallback;
+	}
+
+	xsi->shmid = shmget(IPC_PRIVATE,
+		img->bytes_per_line * img->height,
+		IPC_CREAT | 0777);
+	if (xsi->shmid < 0)
+	{
+		XDestroyImage(img);
+		fprintf(stderr, "warn: could not shmget\n");
+		goto fallback;
+	}
+
+	img->data = xsi->shmaddr = shmat(xsi->shmid, NULL, 0);
+	if (img->data == (char*)-1)
+	{
+		XDestroyImage(img);
+		fprintf(stderr, "warn: could not shmat\n");
+		goto fallback;
+	}
+
+	xsi->readOnly = False;
+	status = XShmAttach(dpy, xsi);
+	if (!status)
+	{
+		shmdt(xsi->shmaddr);
+		XDestroyImage(img);
+		fprintf(stderr, "warn: could not XShmAttach\n");
+		goto fallback;
+	}
+
+	XSync(dpy, False);
+
+	shmctl(xsi->shmid, IPC_RMID, NULL);
+
+	return img;
+
+fallback:
+	info.useshm = 0;
+
+	img = XCreateImage(dpy, vis, depth, ZPixmap, 0, NULL, w, h, 32, 0);
+	if (!img)
+	{
+		fprintf(stderr, "fail: could not XCreateImage");
+		abort();
+	}
+
+	img->data = malloc(h * img->bytes_per_line);
+	if (!img->data)
+	{
+		fprintf(stderr, "fail: could not malloc");
+		abort();
+	}
+
+	return img;
+}
+
+static void
+make_colormap(void)
+{
+	if (info.visual.class == PseudoColor && info.visual.depth == 8)
+	{
+		int i, r, g, b;
+		i = 0;
+		for (b = 0; b < 4; b++) {
+			for (g = 0; g < 8; g++) {
+				for (r = 0; r < 8; r++) {
+					info.rgbcube[i].pixel = i;
+					info.rgbcube[i].red = (r * 36) << 8;
+					info.rgbcube[i].green = (g * 36) << 8;
+					info.rgbcube[i].blue = (b * 85) << 8;
+					info.rgbcube[i].flags =
+					DoRed | DoGreen | DoBlue;
+					i++;
+				}
+			}
+		}
+		info.colormap = XCreateColormap(info.display,
+			RootWindow(info.display, info.screen),
+			info.visual.visual,
+			AllocAll);
+		XStoreColors(info.display, info.colormap, info.rgbcube, 256);
+		return;
+	}
+	else if (info.visual.class == TrueColor)
+	{
+		info.colormap = 0;
+		return;
+	}
+	fprintf(stderr, "Cannot handle visual class %d with depth: %d\n",
+		info.visual.class, info.visual.depth);
+	return;
+}
+
+static void
+select_mode(void)
+{
+
+	int byteorder;
+	int byterev;
+	unsigned long rm, gm, bm;
+	unsigned long rs, gs, bs;
+
+	byteorder = ImageByteOrder(info.display);
+	if (is_big_endian())
+		byterev = byteorder != MSBFirst;
+	else
+		byterev = byteorder != LSBFirst;
+
+	rm = info.visual.red_mask;
+	gm = info.visual.green_mask;
+	bm = info.visual.blue_mask;
+
+	rs = ffs(rm) - 1;
+	gs = ffs(gm) - 1;
+	bs = ffs(bm) - 1;
+
+#ifdef SHOWINFO
+	printf("ximage: mode %d/%d %08lx %08lx %08lx (%ld,%ld,%ld) %s%s\n",
+		info.visual.depth,
+		info.bitsperpixel,
+		rm, gm, bm, rs, gs, bs,
+		byteorder == MSBFirst ? "msb" : "lsb",
+		byterev ? " <swap>":"");
+#endif
+
+	info.mode = UNKNOWN;
+	if (info.bitsperpixel == 8) {
+		/* Either PseudoColor with BGR233 colormap, or TrueColor */
+		info.mode = BGR233;
+	}
+	else if (info.bitsperpixel == 16) {
+		if (rm == 0xF800 && gm == 0x07E0 && bm == 0x001F)
+			info.mode = !byterev ? RGB565 : RGB565_BR;
+		if (rm == 0x7C00 && gm == 0x03E0 && bm == 0x001F)
+			info.mode = !byterev ? RGB555 : RGB555_BR;
+	}
+	else if (info.bitsperpixel == 24) {
+		if (rs == 0 && gs == 8 && bs == 16)
+			info.mode = byteorder == MSBFirst ? RGB888 : BGR888;
+		if (rs == 16 && gs == 8 && bs == 0)
+			info.mode = byteorder == MSBFirst ? BGR888 : RGB888;
+	}
+	else if (info.bitsperpixel == 32) {
+		if (rs == 0 && gs == 8 && bs == 16)
+			info.mode = byteorder == MSBFirst ? ABGR8888 : RGBA8888;
+		if (rs == 8 && gs == 16 && bs == 24)
+			info.mode = byteorder == MSBFirst ? BGRA8888 : ARGB8888;
+		if (rs == 16 && gs == 8 && bs == 0)
+			info.mode = byteorder == MSBFirst ? ARGB8888 : BGRA8888;
+		if (rs == 24 && gs == 16 && bs == 8)
+			info.mode = byteorder == MSBFirst ? RGBA8888 : ABGR8888;
+	}
+
+#ifdef SHOWINFO
+	printf("ximage: RGBA8888 to %s\n", modename[info.mode]);
+#endif
+
+	/* select conversion function */
+	info.convert_func = ximage_convert_funcs[info.mode];
+}
+
+static int
+create_pool(void)
+{
+	int i;
+
+	info.lastused = 0;
+
+	for (i = 0; i < POOLSIZE; i++) {
+		info.pool[i] = NULL;
+	}
+
+	for (i = 0; i < POOLSIZE; i++) {
+		info.pool[i] = createximage(info.display,
+			info.visual.visual, &info.shminfo[i], info.visual.depth,
+			WIDTH, HEIGHT);
+		if (!info.pool[i]) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+static XImage *
+next_pool_image(void)
+{
+	if (info.lastused + 1 >= POOLSIZE) {
+		if (info.useshm)
+			XSync(info.display, False);
+		else
+			XFlush(info.display);
+		info.lastused = 0;
+	}
+	return info.pool[info.lastused ++];
+}
+
+static int
+ximage_error_handler(Display *display, XErrorEvent *event)
+{
+	/* Turn off shared memory images if we get an error from the MIT-SHM extension */
+	if (event->request_code == info.shmcode)
+	{
+		char buf[80];
+		XGetErrorText(display, event->error_code, buf, sizeof buf);
+		fprintf(stderr, "ximage: disabling shared memory extension: %s\n", buf);
+		info.useshm = 0;
+		return 0;
+	}
+
+	XSetErrorHandler(NULL);
+	return (XSetErrorHandler(ximage_error_handler))(display, event);
+}
+
+int
+ximage_init(Display *display, int screen, Visual *visual)
+{
+	XVisualInfo template;
+	XVisualInfo *visuals;
+	int nvisuals;
+	XPixmapFormatValues *formats;
+	int nformats;
+	int ok;
+	int i;
+	int major;
+	int event;
+	int error;
+
+	info.display = display;
+	info.screen = screen;
+	info.colormap = 0;
+
+	/* Get XVisualInfo for this visual */
+	template.visualid = XVisualIDFromVisual(visual);
+	visuals = XGetVisualInfo(display, VisualIDMask, &template, &nvisuals);
+	if (nvisuals != 1) {
+		fprintf(stderr, "Visual not found!\n");
+		XFree(visuals);
+		return 0;
+	}
+	memcpy(&info.visual, visuals, sizeof (XVisualInfo));
+	XFree(visuals);
+
+	/* Get appropriate PixmapFormat for this visual */
+	formats = XListPixmapFormats(info.display, &nformats);
+	for (i = 0; i < nformats; i++) {
+		if (formats[i].depth == info.visual.depth) {
+			info.bitsperpixel = formats[i].bits_per_pixel;
+			break;
+		}
+	}
+	XFree(formats);
+	if (i == nformats) {
+		fprintf(stderr, "PixmapFormat not found!\n");
+		return 0;
+	}
+
+	/* extract mode */
+	select_mode();
+
+	/* prepare colormap */
+	make_colormap();
+
+	/* identify code for MIT-SHM extension */
+	if (XQueryExtension(display, "MIT-SHM", &major, &event, &error) &&
+		XShmQueryExtension(display))
+		info.shmcode = major;
+
+	/* intercept errors looking for SHM code */
+	XSetErrorHandler(ximage_error_handler);
+
+	/* prepare pool of XImages */
+	info.useshm = 1;
+	ok = create_pool();
+	if (!ok)
+		return 0;
+
+#ifdef SHOWINFO
+	printf("ximage: %sPutImage\n", info.useshm ? "XShm" : "X");
+#endif
+
+	return 1;
+}
+
+int
+ximage_get_depth(void)
+{
+	return info.visual.depth;
+}
+
+Visual *
+ximage_get_visual(void)
+{
+	return info.visual.visual;
+}
+
+Colormap
+ximage_get_colormap(void)
+{
+	return info.colormap;
+}
+
+void
+ximage_blit(Drawable d, GC gc,
+	int dstx, int dsty,
+	unsigned char *srcdata,
+	int srcx, int srcy,
+	int srcw, int srch,
+	int srcstride)
+{
+	XImage *image;
+	int ax, ay;
+	int w, h;
+	unsigned char *srcptr;
+
+	for (ay = 0; ay < srch; ay += HEIGHT)
+	{
+		h = fz_mini(srch - ay, HEIGHT);
+		for (ax = 0; ax < srcw; ax += WIDTH)
+		{
+			w = fz_mini(srcw - ax, WIDTH);
+
+			image = next_pool_image();
+
+			srcptr = srcdata +
+			(ay + srcy) * srcstride +
+			(ax + srcx) * 4;
+
+			info.convert_func(srcptr, srcstride,
+				(unsigned char *) image->data,
+				image->bytes_per_line, w, h);
+
+			if (info.useshm)
+			{
+				XShmPutImage(info.display, d, gc, image,
+					0, 0, dstx + ax, dsty + ay,
+					w, h, False);
+			}
+			else
+			{
+				XPutImage(info.display, d, gc, image,
+					0, 0,
+					dstx + ax,
+					dsty + ay,
+					w, h);
+			}
+		}
+	}
+}
+
+/*
+ * Primitive conversion functions
+ */
+
+#ifndef restrict
+#ifndef _C99
+#ifdef __GNUC__
+#define restrict __restrict__
+#else
+#define restrict
+#endif
+#endif
+#endif
+
+#define PARAMS \
+	const unsigned char * restrict src, \
+	int srcstride, \
+	unsigned char * restrict dst, \
+	int dststride, \
+	int w, \
+	int h
+
+/*
+ * Convert byte:RGBA8888 to various formats
+ */
+
+static void
+ximage_convert_argb8888(PARAMS)
+{
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x ++) {
+			dst[x * 4 + 0] = src[x * 4 + 3]; /* a */
+			dst[x * 4 + 1] = src[x * 4 + 0]; /* r */
+			dst[x * 4 + 2] = src[x * 4 + 1]; /* g */
+			dst[x * 4 + 3] = src[x * 4 + 2]; /* b */
+		}
+		dst += dststride;
+		src += srcstride;
+	}
+}
+
+static void
+ximage_convert_bgra8888(PARAMS)
+{
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			dst[x * 4 + 0] = src[x * 4 + 2];
+			dst[x * 4 + 1] = src[x * 4 + 1];
+			dst[x * 4 + 2] = src[x * 4 + 0];
+			dst[x * 4 + 3] = src[x * 4 + 3];
+		}
+		dst += dststride;
+		src += srcstride;
+	}
+}
+
+static void
+ximage_convert_abgr8888(PARAMS)
+{
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			dst[x * 4 + 0] = src[x * 4 + 3];
+			dst[x * 4 + 1] = src[x * 4 + 2];
+			dst[x * 4 + 2] = src[x * 4 + 1];
+			dst[x * 4 + 3] = src[x * 4 + 0];
+		}
+		dst += dststride;
+		src += srcstride;
+	}
+}
+
+static void
+ximage_convert_rgba8888(PARAMS)
+{
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			((unsigned *)dst)[x] = ((unsigned *)src)[x];
+		}
+		dst += dststride;
+		src += srcstride;
+	}
+}
+
+static void
+ximage_convert_bgr888(PARAMS)
+{
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			dst[3*x + 0] = src[4*x + 2];
+			dst[3*x + 1] = src[4*x + 1];
+			dst[3*x + 2] = src[4*x + 0];
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+static void
+ximage_convert_rgb888(PARAMS)
+{
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			dst[3*x + 0] = src[4*x + 0];
+			dst[3*x + 1] = src[4*x + 1];
+			dst[3*x + 2] = src[4*x + 2];
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+static void
+ximage_convert_rgb565(PARAMS)
+{
+	unsigned char r, g, b;
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			r = src[4*x + 0];
+			g = src[4*x + 1];
+			b = src[4*x + 2];
+			((unsigned short *)dst)[x] =
+			((r & 0xF8) << 8) |
+			((g & 0xFC) << 3) |
+			(b >> 3);
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+static void
+ximage_convert_rgb565_br(PARAMS)
+{
+	unsigned char r, g, b;
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			r = src[4*x + 0];
+			g = src[4*x + 1];
+			b = src[4*x + 2];
+			/* final word is:
+			g4 g3 g2 b7 b6 b5 b4 b3 : r7 r6 r5 r4 r3 g7 g6 g5
+			*/
+			((unsigned short *)dst)[x] =
+			(r & 0xF8) |
+			((g & 0xE0) >> 5) |
+			((g & 0x1C) << 11) |
+			((b & 0xF8) << 5);
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+static void
+ximage_convert_rgb555(PARAMS)
+{
+	unsigned char r, g, b;
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			r = src[4*x + 0];
+			g = src[4*x + 1];
+			b = src[4*x + 2];
+			((unsigned short *)dst)[x] =
+			((r & 0xF8) << 7) |
+			((g & 0xF8) << 2) |
+			(b >> 3);
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+static void
+ximage_convert_rgb555_br(PARAMS)
+{
+	unsigned char r, g, b;
+	int x, y;
+	for (y = 0; y < h; y++) {
+		for (x = 0; x < w; x++) {
+			r = src[4*x + 0];
+			g = src[4*x + 1];
+			b = src[4*x + 2];
+			/* final word is:
+			g5 g4 g3 b7 b6 b5 b4 b3 : 0 r7 r6 r5 r4 r3 g7 g6
+			*/
+			((unsigned short *)dst)[x] =
+			((r & 0xF8) >> 1) |
+			((g & 0xC0) >> 6) |
+			((g & 0x38) << 10) |
+			((b & 0xF8) << 5);
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+static void
+ximage_convert_bgr233(PARAMS)
+{
+	unsigned char r, g, b;
+	int x,y;
+	for(y = 0; y < h; y++) {
+		for(x = 0; x < w; x++) {
+			r = src[4*x + 0];
+			g = src[4*x + 1];
+			b = src[4*x + 2];
+			/* format: b7 b6 g7 g6 g5 r7 r6 r5 */
+			dst[x] = (b&0xC0) | ((g>>2)&0x38) | ((r>>5)&0x7);
+		}
+		src += srcstride;
+		dst += dststride;
+	}
+}
+
+ximage_convert_func_t ximage_convert_funcs[] = {
+	ximage_convert_argb8888,
+	ximage_convert_bgra8888,
+	ximage_convert_rgba8888,
+	ximage_convert_abgr8888,
+	ximage_convert_rgb888,
+	ximage_convert_bgr888,
+	ximage_convert_rgb565,
+	ximage_convert_rgb565_br,
+	ximage_convert_rgb555,
+	ximage_convert_rgb555_br,
+	ximage_convert_bgr233,
+};
diff --git a/platform/x11/x11_main.c b/platform/x11/x11_main.c
new file mode 100644
index 00000000..481adce1
--- /dev/null
+++ b/platform/x11/x11_main.c
@@ -0,0 +1,993 @@
+#include "pdfapp.h"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/cursorfont.h>
+#include <X11/keysym.h>
+
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+
+#define mupdf_icon_bitmap_16_width 16
+#define mupdf_icon_bitmap_16_height 16
+static unsigned char mupdf_icon_bitmap_16_bits[] = {
+	0x00, 0x00, 0x00, 0x1e, 0x00, 0x2b, 0x80, 0x55, 0x8c, 0x62, 0x8c, 0x51,
+	0x9c, 0x61, 0x1c, 0x35, 0x3c, 0x1f, 0x3c, 0x0f, 0xfc, 0x0f, 0xec, 0x0d,
+	0xec, 0x0d, 0xcc, 0x0c, 0xcc, 0x0c, 0x00, 0x00 };
+
+#define mupdf_icon_bitmap_16_mask_width 16
+#define mupdf_icon_bitmap_16_mask_height 16
+static unsigned char mupdf_icon_bitmap_16_mask_bits[] = {
+	0x00, 0x1e, 0x00, 0x3f, 0x80, 0x7f, 0xce, 0xff, 0xde, 0xff, 0xde, 0xff,
+	0xfe, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f,
+	0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xce, 0x1c };
+
+#ifndef timeradd
+#define timeradd(a, b, result) \
+	do { \
+		(result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
+		(result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
+		if ((result)->tv_usec >= 1000000) \
+		{ \
+			++(result)->tv_sec; \
+			(result)->tv_usec -= 1000000; \
+		} \
+	} while (0)
+#endif
+
+#ifndef timersub
+#define timersub(a, b, result) \
+	do { \
+		(result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+		(result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+		if ((result)->tv_usec < 0) { \
+			--(result)->tv_sec; \
+			(result)->tv_usec += 1000000; \
+		} \
+	} while (0)
+#endif
+
+extern int ximage_init(Display *display, int screen, Visual *visual);
+extern int ximage_get_depth(void);
+extern Visual *ximage_get_visual(void);
+extern Colormap ximage_get_colormap(void);
+extern void ximage_blit(Drawable d, GC gc, int dstx, int dsty,
+	unsigned char *srcdata,
+	int srcx, int srcy, int srcw, int srch, int srcstride);
+
+void windrawstringxor(pdfapp_t *app, int x, int y, char *s);
+void cleanup(pdfapp_t *app);
+
+static Display *xdpy;
+static Atom XA_CLIPBOARD;
+static Atom XA_TARGETS;
+static Atom XA_TIMESTAMP;
+static Atom XA_UTF8_STRING;
+static Atom WM_DELETE_WINDOW;
+static Atom NET_WM_STATE;
+static Atom NET_WM_STATE_FULLSCREEN;
+static int x11fd;
+static int xscr;
+static Window xwin;
+static Pixmap xicon, xmask;
+static GC xgc;
+static XEvent xevt;
+static int mapped = 0;
+static Cursor xcarrow, xchand, xcwait, xccaret;
+static int justcopied = 0;
+static int dirty = 0;
+static int transition_dirty = 0;
+static int dirtysearch = 0;
+static char *password = "";
+static XColor xbgcolor;
+static XColor xshcolor;
+static int reqw = 0;
+static int reqh = 0;
+static char copylatin1[1024 * 16] = "";
+static char copyutf8[1024 * 48] = "";
+static Time copytime;
+static char *filename;
+
+static pdfapp_t gapp;
+static int closing = 0;
+static int reloading = 0;
+static int showingpage = 0;
+
+static int advance_scheduled = 0;
+static struct timeval tmo_advance;
+
+/*
+ * Dialog boxes
+ */
+
+void winerror(pdfapp_t *app, char *msg)
+{
+	fprintf(stderr, "mupdf: error: %s\n", msg);
+	cleanup(app);
+	exit(1);
+}
+
+void winwarn(pdfapp_t *app, char *msg)
+{
+	fprintf(stderr, "mupdf: warning: %s\n", msg);
+}
+
+void winalert(pdfapp_t *app, pdf_alert_event *alert)
+{
+	fprintf(stderr, "Alert %s: %s", alert->title, alert->message);
+	switch (alert->button_group_type)
+	{
+	case PDF_ALERT_BUTTON_GROUP_OK:
+	case PDF_ALERT_BUTTON_GROUP_OK_CANCEL:
+		alert->button_pressed = PDF_ALERT_BUTTON_OK;
+		break;
+	case PDF_ALERT_BUTTON_GROUP_YES_NO:
+	case PDF_ALERT_BUTTON_GROUP_YES_NO_CANCEL:
+		alert->button_pressed = PDF_ALERT_BUTTON_YES;
+		break;
+	}
+}
+
+void winprint(pdfapp_t *app)
+{
+	fprintf(stderr, "The MuPDF library supports printing, but this application currently does not");
+}
+
+char *winpassword(pdfapp_t *app, char *filename)
+{
+	char *r = password;
+	password = NULL;
+	return r;
+}
+
+char *wintextinput(pdfapp_t *app, char *inittext, int retry)
+{
+	static char buf[256];
+
+	if (retry)
+		return NULL;
+
+	printf("> [%s] ", inittext);
+	fgets(buf, sizeof buf, stdin);
+	return buf;
+}
+
+int winchoiceinput(pdfapp_t *app, int nopts, char *opts[], int *nvals, char *vals[])
+{
+	/* FIXME: temporary dummy implementation */
+	return 0;
+}
+
+/*
+ * X11 magic
+ */
+
+static void winopen(void)
+{
+	XWMHints *wmhints;
+	XClassHint *classhint;
+
+	xdpy = XOpenDisplay(NULL);
+	if (!xdpy)
+		fz_throw(gapp.ctx, FZ_ERROR_GENERIC, "cannot open display");
+
+	XA_CLIPBOARD = XInternAtom(xdpy, "CLIPBOARD", False);
+	XA_TARGETS = XInternAtom(xdpy, "TARGETS", False);
+	XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False);
+	XA_UTF8_STRING = XInternAtom(xdpy, "UTF8_STRING", False);
+	WM_DELETE_WINDOW = XInternAtom(xdpy, "WM_DELETE_WINDOW", False);
+	NET_WM_STATE = XInternAtom(xdpy, "_NET_WM_STATE", False);
+	NET_WM_STATE_FULLSCREEN = XInternAtom(xdpy, "_NET_WM_STATE_FULLSCREEN", False);
+
+	xscr = DefaultScreen(xdpy);
+
+	ximage_init(xdpy, xscr, DefaultVisual(xdpy, xscr));
+
+	xcarrow = XCreateFontCursor(xdpy, XC_left_ptr);
+	xchand = XCreateFontCursor(xdpy, XC_hand2);
+	xcwait = XCreateFontCursor(xdpy, XC_watch);
+	xccaret = XCreateFontCursor(xdpy, XC_xterm);
+
+	xbgcolor.red = 0x7000;
+	xbgcolor.green = 0x7000;
+	xbgcolor.blue = 0x7000;
+
+	xshcolor.red = 0x4000;
+	xshcolor.green = 0x4000;
+	xshcolor.blue = 0x4000;
+
+	XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xbgcolor);
+	XAllocColor(xdpy, DefaultColormap(xdpy, xscr), &xshcolor);
+
+	xwin = XCreateWindow(xdpy, DefaultRootWindow(xdpy),
+		10, 10, 200, 100, 0,
+		ximage_get_depth(),
+		InputOutput,
+		ximage_get_visual(),
+		0,
+		NULL);
+	if (xwin == None)
+		fz_throw(gapp.ctx, FZ_ERROR_GENERIC, "cannot create window");
+
+	XSetWindowColormap(xdpy, xwin, ximage_get_colormap());
+	XSelectInput(xdpy, xwin,
+		StructureNotifyMask | ExposureMask | KeyPressMask |
+		PointerMotionMask | ButtonPressMask | ButtonReleaseMask);
+
+	mapped = 0;
+
+	xgc = XCreateGC(xdpy, xwin, 0, NULL);
+
+	XDefineCursor(xdpy, xwin, xcarrow);
+
+	wmhints = XAllocWMHints();
+	if (wmhints)
+	{
+		wmhints->flags = IconPixmapHint | IconMaskHint;
+		xicon = XCreateBitmapFromData(xdpy, xwin,
+			(char*)mupdf_icon_bitmap_16_bits,
+			mupdf_icon_bitmap_16_width,
+			mupdf_icon_bitmap_16_height);
+		xmask = XCreateBitmapFromData(xdpy, xwin,
+			(char*)mupdf_icon_bitmap_16_mask_bits,
+			mupdf_icon_bitmap_16_mask_width,
+			mupdf_icon_bitmap_16_mask_height);
+		if (xicon && xmask)
+		{
+			wmhints->icon_pixmap = xicon;
+			wmhints->icon_mask = xmask;
+			XSetWMHints(xdpy, xwin, wmhints);
+		}
+		XFree(wmhints);
+	}
+
+	classhint = XAllocClassHint();
+	if (classhint)
+	{
+		classhint->res_name = "mupdf";
+		classhint->res_class = "MuPDF";
+		XSetClassHint(xdpy, xwin, classhint);
+		XFree(classhint);
+	}
+
+	XSetWMProtocols(xdpy, xwin, &WM_DELETE_WINDOW, 1);
+
+	x11fd = ConnectionNumber(xdpy);
+}
+
+void winclose(pdfapp_t *app)
+{
+	closing = 1;
+}
+
+int winsavequery(pdfapp_t *app)
+{
+	/* FIXME: temporary dummy implementation */
+	return DISCARD;
+}
+
+int wingetsavepath(pdfapp_t *app, char *buf, int len)
+{
+	/* FIXME: temporary dummy implementation */
+	return 0;
+}
+
+void winreplacefile(char *source, char *target)
+{
+	rename(source, target);
+}
+
+void cleanup(pdfapp_t *app)
+{
+	fz_context *ctx = app->ctx;
+
+	pdfapp_close(app);
+
+	XDestroyWindow(xdpy, xwin);
+
+	XFreePixmap(xdpy, xicon);
+
+	XFreeCursor(xdpy, xccaret);
+	XFreeCursor(xdpy, xcwait);
+	XFreeCursor(xdpy, xchand);
+	XFreeCursor(xdpy, xcarrow);
+
+	XFreeGC(xdpy, xgc);
+
+	XCloseDisplay(xdpy);
+
+	fz_free_context(ctx);
+}
+
+static int winresolution()
+{
+	return DisplayWidth(xdpy, xscr) * 25.4 /
+		DisplayWidthMM(xdpy, xscr) + 0.5;
+}
+
+void wincursor(pdfapp_t *app, int curs)
+{
+	if (curs == ARROW)
+		XDefineCursor(xdpy, xwin, xcarrow);
+	if (curs == HAND)
+		XDefineCursor(xdpy, xwin, xchand);
+	if (curs == WAIT)
+		XDefineCursor(xdpy, xwin, xcwait);
+	if (curs == CARET)
+		XDefineCursor(xdpy, xwin, xccaret);
+	XFlush(xdpy);
+}
+
+void wintitle(pdfapp_t *app, char *s)
+{
+	XStoreName(xdpy, xwin, s);
+#ifdef X_HAVE_UTF8_STRING
+	Xutf8SetWMProperties(xdpy, xwin, s, s, NULL, 0, NULL, NULL, NULL);
+#else
+	XmbSetWMProperties(xdpy, xwin, s, s, NULL, 0, NULL, NULL, NULL);
+#endif
+}
+
+void winhelp(pdfapp_t *app)
+{
+	fprintf(stderr, "%s\n%s", pdfapp_version(app), pdfapp_usage(app));
+}
+
+void winresize(pdfapp_t *app, int w, int h)
+{
+	int image_w = fz_pixmap_width(gapp.ctx, gapp.image);
+	int image_h = fz_pixmap_height(gapp.ctx, gapp.image);
+	XWindowChanges values;
+	int mask, width, height;
+
+	mask = CWWidth | CWHeight;
+	values.width = w;
+	values.height = h;
+	XConfigureWindow(xdpy, xwin, mask, &values);
+
+	reqw = w;
+	reqh = h;
+
+	if (!mapped)
+	{
+		gapp.winw = w;
+		gapp.winh = h;
+		width = -1;
+		height = -1;
+
+		XMapWindow(xdpy, xwin);
+		XFlush(xdpy);
+
+		while (1)
+		{
+			XNextEvent(xdpy, &xevt);
+			if (xevt.type == ConfigureNotify)
+			{
+				width = xevt.xconfigure.width;
+				height = xevt.xconfigure.height;
+			}
+			if (xevt.type == MapNotify)
+				break;
+		}
+
+		XSetForeground(xdpy, xgc, WhitePixel(xdpy, xscr));
+		XFillRectangle(xdpy, xwin, xgc, 0, 0, image_w, image_h);
+		XFlush(xdpy);
+
+		if (width != reqw || height != reqh)
+		{
+			gapp.shrinkwrap = 0;
+			dirty = 1;
+			pdfapp_onresize(&gapp, width, height);
+		}
+
+		mapped = 1;
+	}
+}
+
+void winfullscreen(pdfapp_t *app, int state)
+{
+	XEvent xev;
+	xev.xclient.type = ClientMessage;
+	xev.xclient.serial = 0;
+	xev.xclient.send_event = True;
+	xev.xclient.window = xwin;
+	xev.xclient.message_type = NET_WM_STATE;
+	xev.xclient.format = 32;
+	xev.xclient.data.l[0] = state;
+	xev.xclient.data.l[1] = NET_WM_STATE_FULLSCREEN;
+	xev.xclient.data.l[2] = 0;
+	XSendEvent(xdpy, DefaultRootWindow(xdpy), False,
+		SubstructureRedirectMask | SubstructureNotifyMask,
+		&xev);
+}
+
+static void fillrect(int x, int y, int w, int h)
+{
+	if (w > 0 && h > 0)
+		XFillRectangle(xdpy, xwin, xgc, x, y, w, h);
+}
+
+static void winblitsearch(pdfapp_t *app)
+{
+	if (gapp.isediting)
+	{
+		char buf[sizeof(gapp.search) + 50];
+		sprintf(buf, "Search: %s", gapp.search);
+		XSetForeground(xdpy, xgc, WhitePixel(xdpy, xscr));
+		fillrect(0, 0, gapp.winw, 30);
+		windrawstring(&gapp, 10, 20, buf);
+	}
+}
+
+static void winblit(pdfapp_t *app)
+{
+	int image_w = fz_pixmap_width(gapp.ctx, gapp.image);
+	int image_h = fz_pixmap_height(gapp.ctx, gapp.image);
+	int image_n = fz_pixmap_components(gapp.ctx, gapp.image);
+	unsigned char *image_samples = fz_pixmap_samples(gapp.ctx, gapp.image);
+	int x0 = gapp.panx;
+	int y0 = gapp.pany;
+	int x1 = gapp.panx + image_w;
+	int y1 = gapp.pany + image_h;
+
+	XSetForeground(xdpy, xgc, xbgcolor.pixel);
+	fillrect(0, 0, x0, gapp.winh);
+	fillrect(x1, 0, gapp.winw - x1, gapp.winh);
+	fillrect(0, 0, gapp.winw, y0);
+	fillrect(0, y1, gapp.winw, gapp.winh - y1);
+
+	XSetForeground(xdpy, xgc, xshcolor.pixel);
+	fillrect(x0+2, y1, image_w, 2);
+	fillrect(x1, y0+2, 2, image_h);
+
+	if (gapp.iscopying || justcopied)
+	{
+		pdfapp_invert(&gapp, &gapp.selr);
+		justcopied = 1;
+	}
+
+	pdfapp_inverthit(&gapp);
+
+	if (image_n == 4)
+		ximage_blit(xwin, xgc,
+			x0, y0,
+			image_samples,
+			0, 0,
+			image_w,
+			image_h,
+			image_w * image_n);
+	else if (image_n == 2)
+	{
+		int i = image_w*image_h;
+		unsigned char *color = malloc(i*4);
+		if (color)
+		{
+			unsigned char *s = image_samples;
+			unsigned char *d = color;
+			for (; i > 0 ; i--)
+			{
+				d[2] = d[1] = d[0] = *s++;
+				d[3] = *s++;
+				d += 4;
+			}
+			ximage_blit(xwin, xgc,
+				x0, y0,
+				color,
+				0, 0,
+				image_w,
+				image_h,
+				image_w * 4);
+			free(color);
+		}
+	}
+
+	pdfapp_inverthit(&gapp);
+
+	if (gapp.iscopying || justcopied)
+	{
+		pdfapp_invert(&gapp, &gapp.selr);
+		justcopied = 1;
+	}
+
+	winblitsearch(app);
+
+	if (showingpage)
+	{
+		char buf[42];
+		snprintf(buf, sizeof buf, "Page %d/%d", gapp.pageno, gapp.pagecount);
+		windrawstringxor(&gapp, 10, 20, buf);
+	}
+}
+
+void winrepaint(pdfapp_t *app)
+{
+	dirty = 1;
+	if (app->in_transit)
+		transition_dirty = 1;
+}
+
+void winrepaintsearch(pdfapp_t *app)
+{
+	dirtysearch = 1;
+}
+
+void winadvancetimer(pdfapp_t *app, float duration)
+{
+	struct timeval now;
+
+	gettimeofday(&now, NULL);
+	memset(&tmo_advance, 0, sizeof(tmo_advance));
+	tmo_advance.tv_sec = (int)duration;
+	tmo_advance.tv_usec = 1000000 * (duration - tmo_advance.tv_sec);
+	timeradd(&tmo_advance, &now, &tmo_advance);
+	advance_scheduled = 1;
+}
+
+void windrawstringxor(pdfapp_t *app, int x, int y, char *s)
+{
+	int prevfunction;
+	XGCValues xgcv;
+
+	XGetGCValues(xdpy, xgc, GCFunction, &xgcv);
+	prevfunction = xgcv.function;
+	xgcv.function = GXxor;
+	XChangeGC(xdpy, xgc, GCFunction, &xgcv);
+
+	XSetForeground(xdpy, xgc, WhitePixel(xdpy, DefaultScreen(xdpy)));
+
+	XDrawString(xdpy, xwin, xgc, x, y, s, strlen(s));
+	XFlush(xdpy);
+
+	XGetGCValues(xdpy, xgc, GCFunction, &xgcv);
+	xgcv.function = prevfunction;
+	XChangeGC(xdpy, xgc, GCFunction, &xgcv);
+}
+
+void windrawstring(pdfapp_t *app, int x, int y, char *s)
+{
+	XSetForeground(xdpy, xgc, BlackPixel(xdpy, DefaultScreen(xdpy)));
+	XDrawString(xdpy, xwin, xgc, x, y, s, strlen(s));
+}
+
+void docopy(pdfapp_t *app, Atom copy_target)
+{
+	unsigned short copyucs2[16 * 1024];
+	char *latin1 = copylatin1;
+	char *utf8 = copyutf8;
+	unsigned short *ucs2;
+	int ucs;
+
+	pdfapp_oncopy(&gapp, copyucs2, 16 * 1024);
+
+	for (ucs2 = copyucs2; ucs2[0] != 0; ucs2++)
+	{
+		ucs = ucs2[0];
+
+		utf8 += fz_runetochar(utf8, ucs);
+
+		if (ucs < 256)
+			*latin1++ = ucs;
+		else
+			*latin1++ = '?';
+	}
+
+	*utf8 = 0;
+	*latin1 = 0;
+
+	XSetSelectionOwner(xdpy, copy_target, xwin, copytime);
+
+	justcopied = 1;
+}
+
+void windocopy(pdfapp_t *app)
+{
+	docopy(app, XA_PRIMARY);
+}
+
+void onselreq(Window requestor, Atom selection, Atom target, Atom property, Time time)
+{
+	XEvent nevt;
+
+	advance_scheduled = 0;
+
+	if (property == None)
+		property = target;
+
+	nevt.xselection.type = SelectionNotify;
+	nevt.xselection.send_event = True;
+	nevt.xselection.display = xdpy;
+	nevt.xselection.requestor = requestor;
+	nevt.xselection.selection = selection;
+	nevt.xselection.target = target;
+	nevt.xselection.property = property;
+	nevt.xselection.time = time;
+
+	if (target == XA_TARGETS)
+	{
+		Atom atomlist[4];
+		atomlist[0] = XA_TARGETS;
+		atomlist[1] = XA_TIMESTAMP;
+		atomlist[2] = XA_STRING;
+		atomlist[3] = XA_UTF8_STRING;
+		XChangeProperty(xdpy, requestor, property, target,
+			32, PropModeReplace,
+			(unsigned char *)atomlist, sizeof(atomlist)/sizeof(Atom));
+	}
+
+	else if (target == XA_STRING)
+	{
+		XChangeProperty(xdpy, requestor, property, target,
+			8, PropModeReplace,
+			(unsigned char *)copylatin1, strlen(copylatin1));
+	}
+
+	else if (target == XA_UTF8_STRING)
+	{
+		XChangeProperty(xdpy, requestor, property, target,
+			8, PropModeReplace,
+			(unsigned char *)copyutf8, strlen(copyutf8));
+	}
+
+	else
+	{
+		nevt.xselection.property = None;
+	}
+
+	XSendEvent(xdpy, requestor, False, 0, &nevt);
+}
+
+void winreloadfile(pdfapp_t *app)
+{
+	pdfapp_close(app);
+	pdfapp_open(app, filename, 1);
+}
+
+void winopenuri(pdfapp_t *app, char *buf)
+{
+	char *browser = getenv("BROWSER");
+	if (!browser)
+	{
+#ifdef __APPLE__
+		browser = "open";
+#else
+		browser = "xdg-open";
+#endif
+	}
+	if (fork() == 0)
+	{
+		execlp(browser, browser, buf, (char*)0);
+		fprintf(stderr, "cannot exec '%s'\n", browser);
+		exit(0);
+	}
+}
+
+static void onkey(int c)
+{
+	advance_scheduled = 0;
+
+	if (justcopied)
+	{
+		justcopied = 0;
+		winrepaint(&gapp);
+	}
+
+	if (!gapp.isediting && c == 'P')
+	{
+		showingpage = 1;
+		winrepaint(&gapp);
+		return;
+	}
+
+	pdfapp_onkey(&gapp, c);
+}
+
+static void onmouse(int x, int y, int btn, int modifiers, int state)
+{
+	if (state != 0)
+		advance_scheduled = 0;
+
+	if (state != 0 && justcopied)
+	{
+		justcopied = 0;
+		winrepaint(&gapp);
+	}
+
+	pdfapp_onmouse(&gapp, x, y, btn, modifiers, state);
+}
+
+static void signal_handler(int signal)
+{
+	if (signal == SIGHUP)
+		reloading = 1;
+}
+
+static void usage(void)
+{
+	fprintf(stderr, "usage: mupdf [options] file.pdf [page]\n");
+	fprintf(stderr, "\t-b -\tset anti-aliasing quality in bits (0=off, 8=best)\n");
+	fprintf(stderr, "\t-p -\tpassword\n");
+	fprintf(stderr, "\t-r -\tresolution\n");
+	exit(1);
+}
+
+int main(int argc, char **argv)
+{
+	int c;
+	int len;
+	char buf[128];
+	KeySym keysym;
+	int oldx = 0;
+	int oldy = 0;
+	int resolution = -1;
+	int pageno = 1;
+	fd_set fds;
+	int width = -1;
+	int height = -1;
+	fz_context *ctx;
+	struct timeval tmo_at;
+	struct timeval now;
+	struct timeval tmo;
+	struct timeval *timeout;
+	struct timeval tmo_advance_delay;
+
+	ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
+	if (!ctx)
+	{
+		fprintf(stderr, "cannot initialise context\n");
+		exit(1);
+	}
+
+	while ((c = fz_getopt(argc, argv, "p:r:b:")) != -1)
+	{
+		switch (c)
+		{
+		case 'p': password = fz_optarg; break;
+		case 'r': resolution = atoi(fz_optarg); break;
+		case 'b': fz_set_aa_level(ctx, atoi(fz_optarg)); break;
+		default: usage();
+		}
+	}
+
+	if (argc - fz_optind == 0)
+		usage();
+
+	filename = argv[fz_optind++];
+
+	if (argc - fz_optind == 1)
+		pageno = atoi(argv[fz_optind++]);
+
+	pdfapp_init(ctx, &gapp);
+
+	winopen();
+
+	if (resolution == -1)
+		resolution = winresolution();
+	if (resolution < MINRES)
+		resolution = MINRES;
+	if (resolution > MAXRES)
+		resolution = MAXRES;
+
+	gapp.transitions_enabled = 1;
+	gapp.scrw = DisplayWidth(xdpy, xscr);
+	gapp.scrh = DisplayHeight(xdpy, xscr);
+	gapp.resolution = resolution;
+	gapp.pageno = pageno;
+
+	pdfapp_open(&gapp, filename, 0);
+
+	FD_ZERO(&fds);
+
+	signal(SIGHUP, signal_handler);
+
+	tmo_at.tv_sec = 0;
+	tmo_at.tv_usec = 0;
+
+	while (!closing)
+	{
+		while (!closing && XPending(xdpy) && !transition_dirty)
+		{
+			XNextEvent(xdpy, &xevt);
+
+			switch (xevt.type)
+			{
+			case Expose:
+				dirty = 1;
+				break;
+
+			case ConfigureNotify:
+				if (gapp.image)
+				{
+					if (xevt.xconfigure.width != reqw ||
+						xevt.xconfigure.height != reqh)
+						gapp.shrinkwrap = 0;
+				}
+				width = xevt.xconfigure.width;
+				height = xevt.xconfigure.height;
+
+				break;
+
+			case KeyPress:
+				len = XLookupString(&xevt.xkey, buf, sizeof buf, &keysym, NULL);
+
+				if (!gapp.isediting)
+					switch (keysym)
+					{
+					case XK_Escape:
+						len = 1; buf[0] = '\033';
+						break;
+
+					case XK_Up:
+						len = 1; buf[0] = 'k';
+						break;
+					case XK_Down:
+						len = 1; buf[0] = 'j';
+						break;
+
+					case XK_Left:
+						len = 1; buf[0] = 'b';
+						break;
+					case XK_Right:
+						len = 1; buf[0] = ' ';
+						break;
+
+					case XK_Page_Up:
+						len = 1; buf[0] = ',';
+						break;
+					case XK_Page_Down:
+						len = 1; buf[0] = '.';
+						break;
+					}
+				if (xevt.xkey.state & ControlMask && keysym == XK_c)
+					docopy(&gapp, XA_CLIPBOARD);
+				else if (len)
+					onkey(buf[0]);
+
+				onmouse(oldx, oldy, 0, 0, 0);
+
+				break;
+
+			case MotionNotify:
+				oldx = xevt.xmotion.x;
+				oldy = xevt.xmotion.y;
+				onmouse(xevt.xmotion.x, xevt.xmotion.y, 0, xevt.xmotion.state, 0);
+				break;
+
+			case ButtonPress:
+				onmouse(xevt.xbutton.x, xevt.xbutton.y, xevt.xbutton.button, xevt.xbutton.state, 1);
+				break;
+
+			case ButtonRelease:
+				copytime = xevt.xbutton.time;
+				onmouse(xevt.xbutton.x, xevt.xbutton.y, xevt.xbutton.button, xevt.xbutton.state, -1);
+				break;
+
+			case SelectionRequest:
+				onselreq(xevt.xselectionrequest.requestor,
+					xevt.xselectionrequest.selection,
+					xevt.xselectionrequest.target,
+					xevt.xselectionrequest.property,
+					xevt.xselectionrequest.time);
+				break;
+
+			case ClientMessage:
+				if (xevt.xclient.format == 32 && xevt.xclient.data.l[0] == WM_DELETE_WINDOW)
+					closing = 1;
+				break;
+			}
+		}
+
+		if (closing)
+			continue;
+
+		if (width != -1 || height != -1)
+		{
+			pdfapp_onresize(&gapp, width, height);
+			width = -1;
+			height = -1;
+		}
+
+		if (dirty || dirtysearch)
+		{
+			if (dirty)
+				winblit(&gapp);
+			else if (dirtysearch)
+				winblitsearch(&gapp);
+			dirty = 0;
+			transition_dirty = 0;
+			dirtysearch = 0;
+			pdfapp_postblit(&gapp);
+		}
+
+		if (showingpage && !tmo_at.tv_sec && !tmo_at.tv_usec)
+		{
+			tmo.tv_sec = 2;
+			tmo.tv_usec = 0;
+
+			gettimeofday(&now, NULL);
+			timeradd(&now, &tmo, &tmo_at);
+		}
+
+		if (XPending(xdpy) || transition_dirty)
+			continue;
+
+		timeout = NULL;
+
+		if (tmo_at.tv_sec || tmo_at.tv_usec)
+		{
+			gettimeofday(&now, NULL);
+			timersub(&tmo_at, &now, &tmo);
+			if (tmo.tv_sec <= 0)
+			{
+				tmo_at.tv_sec = 0;
+				tmo_at.tv_usec = 0;
+				timeout = NULL;
+				showingpage = 0;
+				winrepaint(&gapp);
+			}
+			else
+				timeout = &tmo;
+		}
+
+		if (advance_scheduled)
+		{
+			gettimeofday(&now, NULL);
+			timersub(&tmo_advance, &now, &tmo_advance_delay);
+			if (tmo_advance_delay.tv_sec <= 0)
+			{
+				/* Too late already */
+				onkey(' ');
+				onmouse(oldx, oldy, 0, 0, 0);
+				advance_scheduled = 0;
+			}
+			else if (timeout == NULL)
+			{
+				timeout = &tmo_advance_delay;
+			}
+			else
+			{
+				struct timeval tmp;
+				timersub(&tmo_advance_delay, timeout, &tmp);
+				if (tmp.tv_sec < 0)
+				{
+					timeout = &tmo_advance_delay;
+				}
+			}
+		}
+
+		FD_SET(x11fd, &fds);
+		if (select(x11fd + 1, &fds, NULL, NULL, timeout) < 0)
+		{
+			if (reloading)
+			{
+				winreloadfile(&gapp);
+				reloading = 0;
+			}
+		}
+		if (!FD_ISSET(x11fd, &fds))
+		{
+			if (timeout == &tmo_advance_delay)
+			{
+				onkey(' ');
+				onmouse(oldx, oldy, 0, 0, 0);
+				advance_scheduled = 0;
+			}
+			else
+			{
+				tmo_at.tv_sec = 0;
+				tmo_at.tv_usec = 0;
+				timeout = NULL;
+				showingpage = 0;
+				winrepaint(&gapp);
+			}
+		}
+	}
+
+	cleanup(&gapp);
+
+	return 0;
+}