wdvi

xdvi.c (26096B)

---

 /*========================================================================*\
 
 Copyright (c) 1990-2013  Paul Vojta
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to
 deal in the Software without restriction, including without limitation the
 rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL PAUL VOJTA OR ANY OTHER AUTHOR OF OR CONTRIBUTOR TO
 THIS SOFTWARE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 IN THE SOFTWARE.
 
 NOTE:
 	xdvi is based on prior work as noted in the modification history, below.
 
 \*========================================================================*/
 
 /*
  * DVI previewer for X.
  *
  * Eric Cooper, CMU, September 1985.
  *
  * Code derived from dvi-imagen.c.
  *
  * Modification history:
  * 1/1986	Modified for X.10	--Bob Scheifler, MIT LCS.
  * 7/1988	Modified for X.11	--Mark Eichin, MIT
  * 12/1988	Added 'R' option, toolkit, magnifying glass
  *					--Paul Vojta, UC Berkeley.
  * 2/1989	Added tpic support	--Jeffrey Lee, U of Toronto
  * 4/1989	Modified for System V	--Donald Richardson, Clarkson Univ.
  * 3/1990	Added VMS support	--Scott Allendorf, U of Iowa
  * 7/1990	Added reflection mode	--Michael Pak, Hebrew U of Jerusalem
  * 1/1992	Added greyscale code	--Till Brychcy, Techn. Univ. Muenchen
  *					  and Lee Hetherington, MIT
  * 4/1994	Added DPS support, bounding box
  *					--Ricardo Telichevesky
  *					  and Luis Miguel Silveira, MIT RLE.
  * 1/2001	Added source specials	--including ideas from Stefan Ulrich,
  *					  U Munich
  *
  *	Compilation options:
  *	WORDS_BIGENDIAN	store bitmaps internally with most significant bit first
  *	BMTYPE	store bitmaps in unsigned BMTYPE
  *	BMBYTES	sizeof(unsigned BMTYPE)
  *	ALTFONT	default for -altfont option
  *	SHRINK	default for -s option (shrink factor)
  *	MFMODE	default for -mfmode option
  *	A4	use European size paper, and change default dimension to cm
  */
 
 #include <ctype.h>	/* isdigit() */
 #include <err.h>
 #include <stdarg.h>
 #include <stdlib.h>	/* exit(), atoi() */
 
 #include <X11/cursorfont.h>	/* XC_cross */
 #include <X11/Shell.h>		/* XtNiconX */
 #include <X11/IntrinsicI.h>
 #include <X11/IntrinsicP.h>
 #include <X11/Xaw/Viewport.h>
 #include <X11/Xaw/AsciiText.h>
 
 #include "default.h"	/* default_dvi, default_dvi_len */
 #include "dvi-init.h"	/* init_dvi_file(), init_page() */
 #include "dvi-draw.h"	/* prescan() */
 #include "events.h"	/* compile_action(), ... */
 #include "font-open.h"	/* init_font_open() */
 #include "util.h"	/* xmalloc() */
 #include "version.h"
 #include "xdvi.h"
 #include "xdvi.icon"
 
 #define	ALTFONT		"cmr10"
 #define	SHRINK		3
 #define	BDPI		600
 #define	MFMODE		"cx:600"
 
 #if A4
 #define	DEFAULT_PAPER		"a4"
 #else
 #define	DEFAULT_PAPER		"letter"
 #endif
 
 
 struct WindowRec mane	= {(Window) 0, 1, 0, 0, 0, 0, MAXDIM, 0, MAXDIM, 0};
 struct WindowRec alt	= {(Window) 0, 1, 0, 0, 0, 0, MAXDIM, 0, MAXDIM, 0};
 /*	currwin is temporary storage except for within redraw() */
 struct WindowRec currwin= {(Window) 0, 1, 0, 0, 0, 0, MAXDIM, 0, MAXDIM, 0};
 
 /*
  *	Data for options processing
  */
 
 static	XrmOptionDescRec	options[] = {
 	{"-s",		".shrinkFactor", XrmoptionSepArg,	NULL},
 	{"-nocolor",	".color",	XrmoptionNoArg,		"off"},
 	{"+nocolor",	".color",	XrmoptionNoArg,		"on"},
 	{"-gamma",	".gamma",	XrmoptionSepArg,	NULL},
 	{"-p",		".pixelsPerInch", XrmoptionSepArg,	NULL},
 	{"-altfont",	".altFont",	XrmoptionSepArg,	NULL},
 	{"-mfmode",	".mfMode",	XrmoptionSepArg,	NULL},
 	{"-l",		".listFonts",	XrmoptionNoArg,		"on"},
 	{"+l",		".listFonts",	XrmoptionNoArg,		"off"},
 	{"-fg",		".foreground",	XrmoptionSepArg,	NULL},
 	{"-foreground",	".foreground",	XrmoptionSepArg,	NULL},
 	{"-bg",		".background",	XrmoptionSepArg,	NULL},
 	{"-background",	".background",	XrmoptionSepArg,	NULL},
 	{"-copy",	".copy",	XrmoptionNoArg,		"on"},
 	{"+copy",	".copy",	XrmoptionNoArg,		"off"},
 	{"-thorough",	".thorough",	XrmoptionNoArg,		"on"},
 	{"+thorough",	".thorough",	XrmoptionNoArg,		"off"},
 	{"-debug",	".debugLevel",	XrmoptionSepArg,	NULL},
 	{"-v",		".version",	XrmoptionNoArg,		"on"},
 };
 
 static	const char	base_translations[] = ""
 	"^<Key>c:quit()\n"	/* Control keys first */
 	"^<Key>d:quit()\n"
 	"^<Key>m:forward-page()\n"
 	"^<Key>j:forward-page()\n"
 	"^<Key>l:forward-page(0)\n"
 	"^<Key>h:back-page()\n"
 	"^<Key>p:print()\n"
 	"a<Key>p:show-display-attributes()\n"
 	"\"q\":quit()\n"
 	"\"d\":down()\n"
 	"\"f\":show-links()\n"
 	"\"n\":forward-page()\n"
 	"\" \":down-or-next()\n"
 	"<Key>Return:addr-go()\n"
 	"\"p\":back-page()\n"
 	"\"b\":back-page()\n"
 	"<Key>Delete:up-or-previous()\n"
 	"<Key>BackSpace:up-or-previous()\n"
 	"\"P\":declare-page-number()\n"
 	"\"g\":goto-page()\n"
 	"\"\\^\":home()\n"
 	"\"c\":center()\n"
 	"\"l\":left()\n"
 	"\"r\":right()\n"
 	"\"u\":up()\n"
 	"\"s\":set-shrink-factor()\n"
 	"\"S\":set-density()\n"
 	"<Key>Home:home()\n"
 	"<Key>Left:left()\n"
 	"<Key>Up:up()\n"
 	"<Key>Right:right()\n"
 	"<Key>Down:down()\n"
 	"<Key>Prior:back-page()\n"
 	"<Key>Next:forward-page()\n"
 	"\"C\":set-color()\n"
 	"<Key>Escape:discard-number()\n"	/* Esc */
 	"s<Btn1Down>:drag(|)\n"
 	"s<Btn2Down>:drag(+)\n"
 	"s<Btn3Down>:drag(-)\n"
 	"<Btn1Down>:magnifier(*1)\n"
 	"<Btn2Down>:magnifier(*2)\n"
 	"<Btn3Down>:magnifier(*3)\n";
 
 #define	offset(field)	XtOffsetOf(struct _resource, field)
 
 static	XtResource	application_resources[] = {
 {"shrinkFactor", "ShrinkFactor", XtRInt, sizeof(int),
   offset(shrinkfactor), XtRImmediate, (XtPointer) SHRINK},
 {"mainTranslations", "MainTranslations", XtRString, sizeof(char *),
   offset(main_translations), XtRString, NULL},
 {"wheelTranslations", "WheelTranslations", XtRString, sizeof(char *),
   offset(wheel_translations), XtRString, "<Btn4Down>:wheel(-1.)\n\
     <Btn5Down>:wheel(1.)\n<Btn6Down>:hwheel(-1.)\n<Btn7Down>:hwheel(1.)"},
 {"gamma", "Gamma", XtRFloat, sizeof(float),
   offset(_gamma), XtRString, "1"},
 {"pixelsPerInch", "PixelsPerInch", XtRInt, sizeof(int),
   offset(_pixels_per_inch), XtRImmediate, (XtPointer) BDPI},
 {"altFont", "AltFont", XtRString, sizeof(char *),
   offset(_alt_font), XtRString,  ALTFONT},
 {"mfMode", "MfMode", XtRString, sizeof(char *),
   offset(mfmode), XtRString, MFMODE},
 {"listFonts", "ListFonts", XtRBoolean, sizeof(Boolean),
   offset(_list_fonts), XtRString, "false"},
 {"reverseVideo", "ReverseVideo", XtRBoolean, sizeof(Boolean),
   offset(reverse), XtRString, "false"},
 {"copy", "Copy", XtRBoolean, sizeof(Boolean),
   offset(copy), XtRString, "false"},
 {"thorough", "Thorough", XtRBoolean, sizeof(Boolean),
   offset(thorough), XtRString, "false"},
 {"debugLevel", "DebugLevel", XtRString, sizeof(char *),
   offset(debug_arg), XtRString, NULL},
 {"version", "Version", XtRBoolean, sizeof(Boolean),
   offset(version_flag), XtRString, "false"},
 {"color", "Color", XtRBoolean, sizeof(Boolean),
   offset(_use_color), XtRString, "true"},
 };
 
 static	XtResource	app_pixel_resources[] = {	/* get these later */
 {"foreground", "Foreground", XtRPixel, sizeof(Pixel),
   offset(_fore_Pixel), XtRString, XtDefaultForeground},
 {"background", "Background", XtRPixel, sizeof(Pixel),
   offset(_back_Pixel), XtRString, XtDefaultBackground},
 };
 #undef	offset
 
 
 static	XtGeometryResult
 QueryGeometry(Widget w, XtWidgetGeometry *constraints, XtWidgetGeometry *reply)
 {
 	reply->request_mode = CWWidth | CWHeight;
 	reply->width = page_w;
 	reply->height = page_h;
 	return XtGeometryAlmost;
 }
 
 static	WidgetClassRec	drawingWidgetClass = {
     /* superclass         */    &widgetClassRec,
     /* class_name         */    "Draw",
     /* widget_size        */    sizeof(WidgetRec),
     /* class_initialize   */    NULL,
     /* class_part_initialize*/  NULL,
     /* class_inited       */    FALSE,
     /* initialize         */    NULL,
     /* initialize_hook    */    NULL,
     /* realize            */    XtInheritRealize,
     /* actions            */    NULL,
     /* num_actions        */    0,
     /* resources          */    NULL,
     /* num_resources      */    0,
     /* xrm_class          */    NULLQUARK,
     /* compress_motion    */    FALSE,
     /* compress_exposure  */    TRUE,
     /* compress_enterleave*/    FALSE,
     /* visible_interest   */    FALSE,
     /* destroy            */    NULL,
     /* resize             */    XtInheritResize,
     /* expose             */    XtInheritExpose,
     /* set_values         */    NULL,
     /* set_values_hook    */    NULL,
     /* set_values_almost  */    XtInheritSetValuesAlmost,
     /* get_values_hook    */    NULL,
     /* accept_focus       */    XtInheritAcceptFocus,
     /* version            */    XtVersion,
     /* callback_offsets   */    NULL,
     /* tm_table           */    XtInheritTranslations,
     /* query_geometry       */  QueryGeometry,
     /* display_accelerator  */  XtInheritDisplayAccelerator,
     /* extension            */  NULL
 };
 
 static void
 usage(const char *message, ...)
 {
 	va_list	args;
 
 	va_start(args, message);
 	vwarnx(message, args);
 	va_end(args);
 
 	fprintf(stderr, "\nUsage: wdvi ");
 	fprintf(stderr,
 	"[-s <shrink>] [-nocolor] [-gamma <g>] [-p <pixels>] [-altfont <font>]\n"
 	"\t[-mfmode <mode-def>] [-l] [-rv]\n"
 	"\t[-display <host:display>]\n"
 	"\t[-fg <color>] [-bg <color>] [-bd <color>]\n"
 	"\t[-geometry <geometry>] [-font <font>] [-copy] [-thorough]\n"
 	"\t[-debug <bitmask>] [-v] url\n");
 
 	exit(1);
 }
 
 
 /**
  **	Main program starts here.
  **/
 
 struct modifierinf {
 	int		len;
 	const char	*name;
 	Modifiers	mask;
 	KeySym		keysym;
 };
 
 /* Allowed modifiers, sorted by length and then lexicographically.  */
 
 static	struct modifierinf	modifiers[] = {
 	{1,	"a",		0,		XK_Alt_L},
 	{1,	"c",		ControlMask,	0},
 	{1,	"h",		0,		XK_Hyper_L},
 	{1,	"l",		LockMask,	0},
 	{1,	"m",		0,		XK_Meta_L},
 	{1,	"s",		ShiftMask,	0},
 	{2,	"su",		0,		XK_Super_L},
 	{3,	"Alt",		0,		XK_Alt_L},
 	{4,	"Ctrl",		ControlMask,	0},
 	{4,	"Lock",		LockMask,	0},
 	{4,	"Meta",		0,		XK_Meta_L},
 	{4,	"Mod1",		Mod1Mask,	0},
 	{4,	"Mod2",		Mod2Mask,	0},
 	{4,	"Mod3",		Mod3Mask,	0},
 	{4,	"Mod4",		Mod4Mask,	0},
 	{4,	"Mod5",		Mod5Mask,	0},
 	{5,	"Hyper",	0,		XK_Hyper_L},
 	{5,	"Shift",	ShiftMask,	0},
 	{5,	"Super",	0,		XK_Super_L},
 	{7,	"Button1",	Button1Mask,	0},
 	{7,	"Button2",	Button2Mask,	0},
 	{7,	"Button3",	Button3Mask,	0},
 	{7,	"Button4",	Button4Mask,	0},
 	{7,	"Button5",	Button5Mask,	0},
 };
 
 #define	MODSCTRLINDEX	1	/* index of "c" in the above array */
 #define	MODSMETAINDEX	4	/* index of "m" */
 
 
 static Bool
 compile_modifiers(const char **pp, struct wheel_acts *wactp)
 {
 	const char		*p = *pp;
 	const char		*p1;
 	LateBindingsPtr		latep = NULL;
 	int			nlate;
 
 	while (*p == ' ' || *p == '\t') ++p;
 
 	p1 = p;
 	while ((*p1 | ('a' ^ 'A')) >= 'a' && (*p1 | ('a' ^ 'A')) <= 'z')
 	    ++p1;
 
 	if (p1 - p == 3 && memcmp(p, "Any", 3) == 0) {
 	    wactp->mask = wactp->value = 0;
 	    p = p1;
 	    while (*p == ' ' || *p == '\t') ++p;
 	    if (*p != '<')
 		return False;
 	}
 	else if (p1 - p == 4 && memcmp(p, "None", 4) == 0) {
 	    wactp->mask = ~0;
 	    wactp->value = 0;
 	    p = p1;
 	    while (*p == ' ' || *p == '\t') ++p;
 	    if (*p != '<')
 		return False;
 	}
 	else {
 	    if (*p == '!') {
 		do {
 		    ++p;
 		} while (*p == ' ' || *p == '\t');
 	    }
 
 	    for (;;) {
 		Bool	negated = False;
 		struct modifierinf *mp;
 
 		if (*p == '<')
 		    break;
 
 		if (*p == '~') {
 		    negated = True;
 		    ++p;
 		}
 
 		if (*p == '^') {
 		    mp = &modifiers[MODSCTRLINDEX];
 		    ++p;
 		}
 		else if (*p == '$') {
 		    mp = &modifiers[MODSMETAINDEX];
 		    ++p;
 		}
 		else {
 		    int min, max;
 
 		    p1 = p;
 		    while (((*p | ('a' ^ 'A')) >= 'a'
 		      && (*p | ('a' ^ 'A')) <= 'z')
 		      || (*p >= '0' && *p <= '9'))
 			++p;
 
 		    /* do binary search */
 		    min = -1;
 		    max = XtNumber(modifiers);
 		    for (;;) {
 			int i, diff;
 
 			i = (min + max) / 2;
 			if (i == min)
 			    return False;	/* if not found */
 			mp = &modifiers[i];
 
 			diff = (p - p1) - mp->len;
 			if (diff == 0)
 			    diff = memcmp(p1, mp->name, p - p1);
 
 			if (diff == 0)
 			    break;
 			if (diff > 0) min = i;
 			else max = i;
 		    }
 		}
 		if (mp->mask) {
 		    wactp->mask |= mp->mask;
 		    if (!negated) wactp->value |= mp->mask;
 		}
 		else {
 		    LateBindingsPtr lp1;
 
 		    if (latep == NULL) {
 			nlate = 3;
 			latep = xmalloc(3 * sizeof(LateBindings));
 			latep->ref_count = 1;
 		    }
 		    else {
 			nlate += 2;
 			latep = xrealloc(latep, nlate * sizeof(LateBindings));
 		    }
 		    lp1 = &latep[nlate - 3];
 		    lp1->knot = lp1[1].knot = negated;
 		    lp1->pair = True;
 		    lp1->keysym = mp->keysym;
 		    ++lp1;
 		    lp1->pair = False;
 		    lp1->ref_count = 0;
 		    lp1->keysym = mp->keysym + 1;
 		    ++lp1;
 		    lp1->knot = lp1->pair = False;
 		    lp1->ref_count = 0;
 		    lp1->keysym = 0;
 		}
 
 		while (*p == ' ' || *p == '\t') ++p;
 	    }
 	}
 
 	wactp->late_bindings = latep;
 	*pp = p;
 
 	return True;
 }
 
 static Bool
 compile_evtype(const char **pp, unsigned int *buttonp)
 {
 	const char		*p = *pp;
 	const char		*p0;
 
 	++p;	/* already assumed to be '<' */
 	while (*p == ' ' || *p == '\t') ++p;
 
 	p0 = p;
 	while (((*p | ('a' ^ 'A')) >= 'a' && (*p | ('a' ^ 'A')) <= 'z')
 	  && p - p0 < 3)
 	    ++p;
 
 	if (p - p0 != 3 || memcmp(p0, "Btn", 3) != 0)
 	    return False;
 
 	if (*p >= '1' && *p <= '9') {
 	    unsigned int n = *p - '0';
 
 	    while (*++p >= '0' && *p <= '9')
 		n = n * 10 + (*p - '0');
 
 	    *buttonp = n;
 	}
 
 	p0 = p;
 	while (((*p | ('a' ^ 'A')) >= 'a' && (*p | ('a' ^ 'A')) <= 'z'))
 	    ++p;
 
 	if (p - p0 != 4 || memcmp(p0, "Down", 4) != 0)
 	    return False;
 
 	while (*p == ' ' || *p == '\t') ++p;
 
 	if (*p++ != '>')
 	    return False;
 
 	while (*p == ' ' || *p == '\t') ++p;
 
 	if (*p++ != ':')
 	    return False;
 
 	*pp = p;
 
 	return True;
 }
 
 static void
 compile_wheel_actions(void)
 {
 	struct wheel_acts	**wactpp;
 	struct wheel_acts	*wactp;
 	const char		*p = resource.wheel_translations;
 	const char		*p_end = p + strlen(p);
 	struct wheel_acts	wact;
 
 	wactpp = &wheel_actions;
 
 	for (;;) {
 	    while (*p == ' ' || *p == '\t') ++p;
 
 	    if (*p == '\n') continue;
 	    if (*p == '\0') break;
 
 	    wact.mask = wact.value = 0;
 	    wact.button = 0;
 
 	    if (!compile_modifiers(&p, &wact)
 	      || !compile_evtype(&p, &wact.button))
 		warnx("syntax error in wheel translations");
 	    else if (compile_action(p, &wact.action) || wact.action != NULL) {
 		wactp = xmalloc(sizeof(struct wheel_acts));
 		*wactp = wact;
 
 		*wactpp = wactp;
 		wactpp = &wactp->next;
 	    }
 
 	    p = memchr(p, '\n', p_end - p);
 	    if (p == NULL) break;
 	    ++p;
 	}
 
 	*wactpp = NULL;
 }
 
 static void
 set_default_winsize(void)
 {
 	Dimension	 addr_bwidth;
 	Dimension	 bwidth;
 	Dimension	 screen_w, screen_h;
 	XtWidgetGeometry addr_reply;
 	XtWidgetGeometry constraints;
 	XtWidgetGeometry reply;
 	int		 i;
 	int		 addr_height;
 
 	XtQueryGeometry(addr_widget, NULL, &addr_reply);
 	XtVaGetValues(addr_widget, XtNborderWidth, &addr_bwidth, NULL);
 	addr_height = addr_reply.height + 2 * addr_bwidth;
 
 	/*
 	 * The total screen_{w,h} is what is left over after the address bar
 	 * and borders have been taken into account.
 	 */
 	XtVaGetValues(top_level, XtNborderWidth, &bwidth, NULL);
 	screen_w = WidthOfScreen(SCRN) - 2 * bwidth;
 	screen_h = HeightOfScreen(SCRN) - 2 * bwidth - addr_height;
 
 	Arg set_wh_args[] = {
 		{XtNwidth,	(XtArgVal) 0},
 		{XtNheight,	(XtArgVal) 0},
 	};
 	for (;;) {	/* actually, at most two passes */
 		constraints.request_mode = reply.request_mode = 0;
 		constraints.width = page_w;
 		if (page_w > screen_w) {
 			constraints.request_mode = CWWidth;
 			constraints.width = screen_w;
 		}
 		constraints.height = page_h;
 		if (page_h > screen_h) {
 			constraints.request_mode |= CWHeight;
 			constraints.height = screen_h;
 		}
 		if (constraints.request_mode != 0
 		    && constraints.request_mode != (CWWidth | CWHeight))
 			XtQueryGeometry(vport_widget, &constraints, &reply);
 		if (!(reply.request_mode & CWWidth))
 			reply.width = constraints.width;
 		if (reply.width >= screen_w)
 			reply.width = screen_w;
 		if (!(reply.request_mode & CWHeight))
 			reply.height = constraints.height;
 		if (reply.height >= screen_h)
 			reply.height = screen_h;
 
 		/* now reply.{width,height} contain max. usable window size */
 
 		if (shrink_factor != 0)
 			break;
 
 		shrink_factor = ROUNDUP(unshrunk_page_w, reply.width - 2);
 		i = ROUNDUP(unshrunk_page_h, reply.height - 2);
 		if (i >= shrink_factor)
 			shrink_factor = i;
 		if (shrink_factor > 1)
 			bak_shrink = shrink_factor;
 		mane.shrinkfactor = shrink_factor;
 		init_page();
 		set_wh_args[0].value = (XtArgVal) page_w;
 		set_wh_args[1].value = (XtArgVal) page_h;
 		XtSetValues(draw_widget, set_wh_args, XtNumber(set_wh_args));
 	}
 	set_wh_args[0].value = reply.width;
 	set_wh_args[1].value = reply.height + addr_height;
 	XtSetValues(top_level, set_wh_args, XtNumber(set_wh_args));
 
 	set_wh_args[0].value = reply.width - (2 * addr_bwidth);
 	XtSetValues(addr_widget, set_wh_args, 1);
 }
 
 /*
  *	main program
  */
 
 int
 main(int argc, char *argv[])
 {
 	const char	*url = NULL;
 	const char	*arg;
 	XrmDatabase	db;
 	int		i;
 
 
 	/*
 	 *	Step 1:  Process command-line options and resources.
 	 */
 
 	top_level = XtInitialize("wdvi", "XDvi", options, XtNumber(options),
 		&argc, argv);
 	XtAddActions(Actions, num_actions);
 
 	while (--argc > 0) {
 		arg = *++argv;
 
 		if (arg[0] == '-')
 			usage("Unknown option '%s'.", arg);
 		if (url != NULL)
 			usage("More than one url specified", arg);
 		else
 			url = arg;
 	}
 
 	DISP = XtDisplay(top_level);
 	SCRN = XtScreen(top_level);
 
 	db = XtScreenDatabase(SCRN);
 
 	/* It's easier to do this than track creations and deletions of the
 	       scrollbars.  */
 	XrmPutStringResource(&db, "XDvi.file.form.vport.vertical.translations",
 	    "#override<Btn4Down>:file-scroll(-w)\n<Btn5Down>:file-scroll(w)");
 	XrmPutStringResource(&db, "XDvi.file.form.vport.horizontal.translations",
 	    "#override<Btn4Down>:file-scroll(-w)\n<Btn5Down>:file-scroll(w)");
 
 	XtGetApplicationResources(top_level, &resource, application_resources,
 		XtNumber(application_resources), (ArgList) NULL, 0);
 	shrink_factor = resource.shrinkfactor;
 
 	if (resource.version_flag)
 		errx(0, "version %s", VERSION);
 
 	if (resource.debug_arg != NULL)
 		debug = isdigit(*resource.debug_arg) ? atoi(resource.debug_arg)
 		: DBG_ALL;
 
 	char *atom_names[]	= { "WM_DELETE_WINDOW", "WM_PROTOCOLS" };
 	if (!XInternAtoms(DISP, atom_names, XtNumber(atom_names), False, atoms))
 		errx(1, "XInternAtoms failed.");
 
 	if (debug & DBG_CLIENT) {
 	    for (i = 0; i < XtNumber(atom_names); ++i)
 		printf("Atom(%s) = %lu\n", atom_names[i], atoms[i]);
 	}
 
 	if (DefaultDepthOfScreen(SCRN) < 24)
 		errx(1, "X depth < 24 is not supported.");
 	if (DefaultVisualOfScreen(SCRN)->class != TrueColor)
 		errx(1, "X visual not 'TrueColor' is not supported.");
 
 	/*
 	 * The default document is always available and simplifies startup
 	 * by giving inital window sizes and no error popups.
 	 */
 	if ((dvi_file = fmemopen(default_dvi, default_dvi_len, "r")) == NULL)
 		err(1, "fmemopen");
 	dvi_name = "default.dvi";
 	ev_flags |= EV_NEWDOC;
 	read_events(EV_GE_NEWDOC);
 	ev_flags &= ~EV_NEWDOC;
 
 	if (resource.mfmode != NULL) {
 	    char *p;
 
 	    p = rindex(resource.mfmode, ':');
 	    if (p != NULL) {
 		unsigned int	len;
 		char		*p1;
 
 		++p;
 		len = p - resource.mfmode;
 		p1 = xmalloc(len);
 		bcopy(resource.mfmode, p1, len - 1);
 		p1[len - 1] = '\0';
 		resource.mfmode = p1;
 		pixels_per_inch = atoi(p);
 	    }
 	}
 	if (shrink_factor < 0 || shrink_factor > 10)
 		usage("Invalid shrink factor: %d.", shrink_factor);
 	if (pixels_per_inch <= 0)
 		usage("Invalid dpi value: %d.", pixels_per_inch);
 
 	if (shrink_factor > 1) {
 		bak_shrink = shrink_factor;
 		mane.shrinkfactor = shrink_factor;	/* otherwise it's 1 */
 	}
 
 	/* 1 inch */
 	offset_x = pixels_per_inch;
 	offset_y = pixels_per_inch;
 
 	unshrunk_paper_w = 8.5 * pixels_per_inch;
 	unshrunk_paper_h = 11 * pixels_per_inch;
 
 	/*
 	 *	Step 2:  Settle colormap issues.  This should be done before
 	 *	other widgets are created, so that they get the right
 	 *	pixel values.  (The top-level widget won't have the right
 	 *	values, but I don't think that makes any difference.)
 	 */
 
 	XtGetApplicationResources(top_level, &resource,
 	  app_pixel_resources, XtNumber(app_pixel_resources),
 	  (ArgList) NULL, 0);
 
 	fore_color_data.pixel = resource._fore_Pixel;
 	back_color_data.pixel = resource._back_Pixel;
 	XQueryColors(DISP, DefaultColormapOfScreen(SCRN), color_data, 2);
 
 	fg_initial.r = fore_color_data.red;
 	fg_initial.g = fore_color_data.green;
 	fg_initial.b = fore_color_data.blue;
 	bg_initial.r = back_color_data.red;
 	bg_initial.g = back_color_data.green;
 	bg_initial.b = back_color_data.blue;
 
 	/*
 	 *	Step 3:  Initialize the dvi file and set titles.
 	 */
 
 	init_font_open();
 	if (init_dvi_file() == False)
 		errx(1, "Bad default DVI document");
 	prescan();
 	init_page();
 
 	/*
 	 *	Step 4:  Set initial window size.
 	 *	This needs to be done before colors are assigned because if
 	 *	-s 0 is specified, then we need to compute the shrink factor
 	 *	(which in turn affects whether init_pix is called).
 	 */
 
 	/* Create icon. */
 	XtVaSetValues(top_level, XtNiconPixmap,
 		XCreateBitmapFromData( DISP, XtScreen(top_level)->root,
 			(const char *) xdvi_bits, xdvi_width, xdvi_height),
 		NULL);
 
 	XtVaSetValues(top_level, XtNinput, True, NULL);
 
 	XrmPutStringResource(&db, "XDvi.form.baseTranslations",
 		base_translations);
 
 	if (resource.main_translations != NULL)
 		XrmPutStringResource(&db, "XDvi.form.translations",
 			resource.main_translations);
 
 	/*
 	 * Widget creation.
 	 */
 	form_widget = XtVaCreateManagedWidget("form", formWidgetClass,
 		top_level, XtNdefaultDistance, 0,
 		NULL);
 
 	vport_widget = XtVaCreateManagedWidget("vport", viewportWidgetClass,
 		form_widget,
 		XtNborderWidth, 0,
 		XtNtop,		XawChainTop,
 		XtNbottom,	XawChainBottom,
 		XtNleft,	XawChainLeft,
 		XtNright,	XawChainRight,
 		XtNallowHoriz,	True,
 		XtNallowVert,	True,
 		NULL);
 
 	clip_widget = XtNameToWidget(vport_widget, "clip");
 
 	draw_widget = XtVaCreateManagedWidget("drawing", &drawingWidgetClass,
 		vport_widget,
 		XtNwidth,	page_w,
 		XtNheight,	page_h,
 		XtNx,		0,
 		XtNy,		0,
 		XtNlabel,	(XtArgVal) "",
 		NULL);
 
 	addr_widget = XtVaCreateManagedWidget("address", asciiTextWidgetClass,
 		form_widget,
 		XtNfromVert,	(XtArgVal) vport_widget,
 		XtNdataCompression, False,
 		XtNeditType,	XawtextEdit,
 		/* Don't resize this widget with the rest of the form. */
 		XtNtop,		XawChainBottom,
 		XtNbottom,	XawChainBottom,
 		XtNstring,	(XtArgVal) (url ? url : addr_default),
 		XtNinsertPosition, strlen(url ? url : addr_default),
 		NULL);
 
 	XtOverrideTranslations(addr_widget, XtParseTranslationTable(
 		"<Key>Return:addr-go()"));
 
 	XtOverrideTranslations(form_widget, XtParseTranslationTable(
 		"\"0\":digit(0)\n"
 		"\"1\":digit(1)\n"
 		"\"2\":digit(2)\n"
 		"\"3\":digit(3)\n"
 		"\"4\":digit(4)\n"
 		"\"5\":digit(5)\n"
 		"\"6\":digit(6)\n"
 		"\"7\":digit(7)\n"
 		"\"8\":digit(8)\n"
 		"\"9\":digit(9)\n"
 		"\"-\":minus()\n"
 		"<Motion>:motion()\n"
 		"<BtnUp>:release()"));
 
 	if (resource.wheel_translations != NULL) {
 		XtAugmentTranslations(form_widget, XtParseTranslationTable(
 			"<BtnDown>:wheel-actions()"));
 
 		compile_wheel_actions();
 	}
 
 	/* set background colors of the drawing and clip widgets */
 	Arg back_args = {XtNbackground, (XtArgVal) resource._back_Pixel};
 	XtSetValues(draw_widget, &back_args, 1);
 	XtSetValues(clip_widget, &back_args, 1);
 
 	set_default_winsize();
 
 	/*
 	 *	Step 5:  Realize the widgets (or windows).
 	 */
 
 
 	XtAddEventHandler(vport_widget, StructureNotifyMask, False,
 		handle_resize, NULL);
 	XtAddEventHandler(draw_widget, ExposureMask, False, handle_expose,
 		&mane);
 	XtRealizeWidget(top_level);
 
 	/*
 	 * Assume that if we have a vertical scroll bar its because of
 	 * vertical overflow. Make the window wider to account for the
 	 * bars width.
 	 */
 	Widget y_bar = XtNameToWidget(vport_widget, "vertical");
 	if (y_bar != NULL) {
 		Dimension width;
 		XtWidgetGeometry reply;
 
 		XtVaGetValues(y_bar, XtNwidth, &width, NULL);
 		XtQueryGeometry(top_level, NULL, &reply);
 
 		XtVaSetValues(top_level, XtNwidth, reply.width + width + 1,
 		    NULL);
 	}
 
 	XSetWMProtocols(DISP, XtWindow(top_level), &XA_WM_DELETE_WINDOW, 1);
 	XtAddEventHandler(top_level, NoEventMask, True, handle_messages, NULL);
 
 	currwin.win = mane.win = XtWindow(draw_widget);
 
 	XSetWindowAttributes wattrs;
 	wattrs.backing_store = Always;
 	XChangeWindowAttributes(DISP, mane.win, CWBackingStore, &wattrs);
 
 	image = XCreateImage(DISP, CopyFromParent, 1, XYBitmap, 0,
 			     (char *) NULL, 0, 0, BMBITS, 0);
 	image->bitmap_unit = BMBITS;
 #ifdef	WORDS_BIGENDIAN
 	image->bitmap_bit_order = MSBFirst;
 #else
 	image->bitmap_bit_order = LSBFirst;
 #endif
 	short endian = MSBFirst << 8 | LSBFirst;
 	image->byte_order = *((char *) &endian);
 
 	/*
 	 *	Step 6:  Assign colors and GCs.
 	 *		 Because of the latter, this has to go after Step 5.
 	 *		 In color mode, color changes affect foreGC, foreGC2,
 	 *		 and ruleGC, but not copyGC.
 	 */
 
 	if (resource._gamma == 0.0)
 	    resource._gamma = 1.0;
 	if (resource.reverse)
 		resource._gamma = 1.5;
 
 #define	MakeGC(fcn, fg, bg)	(values.function = fcn, \
 	  values.foreground=fg, values.background=bg, \
 	  XCreateGC(DISP, XtWindow(top_level), \
 	    GCFunction | GCForeground | GCBackground, &values))
 
 	XGCValues	values;
 
 	/* Not affected by color changes.  */
 	copyGC = MakeGC(GXcopy, resource._fore_Pixel, resource._back_Pixel);
 	linkGC = MakeGC(GXxor, resource._fore_Pixel ^ resource._back_Pixel,
 	    resource._back_Pixel);
 
 	ready_cursor = XCreateFontCursor(DISP, XC_cross);
 	redraw_cursor = XCreateFontCursor(DISP, XC_watch);
 
 	for(;;)		/* normal operation */
 		do_pages();
 }