wdvi

events.c (43930B)

---

 /*========================================================================*\
 
 Copyright (c) 1990-2004  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
 	in xdvi.c.
 
 \*========================================================================*/
 
 #include <ctype.h>	/* tolower() */
 #include <err.h>
 #include <limits.h>	/* abs() */
 #include <math.h>	/* pow() */
 #include <stdlib.h>	/* free(), atoi(), atof(), exit(), abs() */
 
 #include <X11/IntrinsicI.h>	/* _XtComputeLateBindings */
 #include <X11/XKBlib.h>
 #define XBell(dpy, percent) XkbBell(dpy, mane.win, percent, (Atom) None)
 
 #include "dvi-init.h"	/* init_page(), full_reset_colors(), reset_colors() */
 #include "dvi-draw.h"	/* prescan(), draw_page(), draw_links() */
 #include "events.h"
 #include "http.h"	/* http_get() */
 #include "popups.h"	/* WARN, Act_print() */
 #include "special.h"	/* page_colors, scanned_page, ... */
 #include "util.h"	/* xmalloc() */
 #include "xdvi.h"
 
 
 #define	MAGBORD	1	/* border size for magnifier */
 
 /*
  * Command line flags.
  */
 
 extern	struct _resource	resource;
 
 #define	clip_w	mane.width
 #define	clip_h	mane.height
 static	Position main_x, main_y;
 static	Position mag_x, mag_y, new_mag_x, new_mag_y;
 static	int	mag_conv_x, mag_conv_y;
 static	Boolean	dragcurs	= False;
 
 typedef	void	(*home_proc)(Boolean);
 typedef void	(*mouse_proc)(XEvent *);
 
 static	void	can_exposures(struct WindowRec *);
 void		null_mouse(XEvent *);
 
 mouse_proc	mouse_motion	= null_mouse;
 mouse_proc	mouse_release	= null_mouse;
 
 
 /*
  *	The cursor shape in the magnifying glass is determined by which
  *	window received the button press event.  Under XAW, that is a parent
  *	of mane.win, so we have to define the cursor of that window instead
  *	of mane.win in that case.
  */
 
 #define CURSORWIN	XtWindow(form_widget)
 
 #define	ACTION_DECL(name)				\
 		void name(Widget, XEvent *, String *, Cardinal *)
 
 #define	ACTION(name)					\
 		void name(Widget w, XEvent *event,	\
 			String *params, Cardinal *num_params)
 
 void
 null_mouse(XEvent *event)
 {
 }
 
 static ACTION_DECL(Act_digit);
 static ACTION_DECL(Act_minus);
 static ACTION_DECL(Act_quit);
 static ACTION_DECL(Act_goto_page);
 static ACTION_DECL(Act_forward_page);
 static ACTION_DECL(Act_back_page);
 static ACTION_DECL(Act_declare_page_number);
 static ACTION_DECL(Act_home);
 static ACTION_DECL(Act_center);
 static ACTION_DECL(Act_left);
 static ACTION_DECL(Act_right);
 static ACTION_DECL(Act_up);
 static ACTION_DECL(Act_down);
 static ACTION_DECL(Act_up_or_previous);
 static ACTION_DECL(Act_down_or_next);
 static ACTION_DECL(Act_show_display_attributes);
 static ACTION_DECL(Act_set_shrink_factor);
 static ACTION_DECL(Act_shrink_to_dpi);
 static ACTION_DECL(Act_set_density);
 static ACTION_DECL(Act_set_color);
 static ACTION_DECL(Act_discard_number);
 
 static ACTION_DECL(Act_magnifier);
 static ACTION_DECL(Act_drag);
 static ACTION_DECL(Act_wheel);
 static ACTION_DECL(Act_hwheel);
 static ACTION_DECL(Act_wheel_actions);
 static ACTION_DECL(Act_motion);
 static ACTION_DECL(Act_release);
 static ACTION_DECL(Act_addr_go);
 static ACTION_DECL(Act_show_links);
 
 
 XtActionsRec	Actions[]	= {
 	{"digit",		Act_digit},
 	{"minus",		Act_minus},
 	{"quit",		Act_quit},
 	{"goto-page",		Act_goto_page},
 	{"forward-page",	Act_forward_page},
 	{"back-page",		Act_back_page},
 	{"declare-page-number",	Act_declare_page_number},
 	{"home",		Act_home},
 	{"center",		Act_center},
 	{"left",		Act_left},
 	{"right",		Act_right},
 	{"up",			Act_up},
 	{"down",		Act_down},
 	{"up-or-previous",	Act_up_or_previous},
 	{"down-or-next",	Act_down_or_next},
 	{"show-display-attributes", Act_show_display_attributes},
 	{"set-shrink-factor",	Act_set_shrink_factor},
 	{"shrink-to-dpi",	Act_shrink_to_dpi},
 	{"set-density",		Act_set_density},
 	{"print",		Act_print},
 	{"set-color",		Act_set_color},
 	{"discard-number",	Act_discard_number},
 	{"magnifier",		Act_magnifier},
 	{"drag",		Act_drag},
 	{"wheel",		Act_wheel},
 	{"hwheel",		Act_hwheel},
 	{"wheel-actions",	Act_wheel_actions},
 	{"motion",		Act_motion},
 	{"release",		Act_release},
 	{"addr-go",		Act_addr_go},
 	{"show-links",		Act_show_links},
 };
 
 Cardinal	num_actions	= XtNumber(Actions);
 
 
 Bool
 compile_action(str, app)
 	const char	*str;
 	struct xdvi_action **app;
 {
 	const char	*p, *p1, *p2;
 	XtActionsRec	*actp;
 	struct xdvi_action *ap;
 
 	for (;;) {
 	    while (*str == ' ' || *str == '\t') ++str;
 
 	    if (*str == '\0' || *str == '\n')
 		break;
 
 	    p = str;
 	    while (((*p | ('a' ^ 'A')) >= 'a' && (*p | ('a' ^ 'A')) <= 'z')
 	      || (*p >= '0' && *p <= '9') || *p == '-' || *p == '_')
 		++p;
 
 	    for (actp = Actions;; ++actp) {
 		if (actp >= Actions + XtNumber(Actions)) {
 		    warnx("cannot compile action '%.*s'", (int) (p - str), str);
 		    *app = NULL;
 		    return False;
 		}
 		if (memcmp(str, actp->string, p - str) == 0
 		  && actp->string[p - str] == '\0')
 		    break;
 	    }
 
 	    while (*p == ' ' || *p == '\t') ++p;
 	    if (*p != '(') {
 		while (*p != '\0' && *p != '\n') ++p;
 		warnx("syntax error in action '%.*s'", (int) (p - str), str);
 		*app = NULL;
 		return False;
 	    }
 	    ++p;
 	    while (*p == ' ' || *p == '\t') ++p;
 	    for (p1 = p;; ++p1) {
 		if (*p1 == '\0' || *p1 == '\n') {
 		    warnx("syntax error in action '%.*s'", (int) (p1 - str), str);
 		    *app = NULL;
 		    return False;
 		}
 		if (*p1 == ')') break;
 	    }
 
 	    ap = xmalloc(sizeof *ap);
 	    ap->proc = actp->proc;
 	    for (p2 = p1;; --p2)
 		if (p2 <= p) {	/* if no args */
 		    ap->num_params = 0;
 		    ap->param = NULL;
 		    break;
 		}
 		else if (p2[-1] != ' ' && p2[-1] != '\t') {
 		    char	*arg;
 
 		    arg = xmalloc(p2 - p + 1);
 		    bcopy(p, arg, p2 - p);
 		    arg[p2 - p] = '\0';
 		    ap->num_params = 1;
 		    ap->param = arg;
 		    break;
 		}
 
 	    *app = ap;
 	    app = &ap->next;
 
 	    str = p1 + 1;
 	}
 
 	*app = NULL;
 	return True;
 }
 
 
 
 static	Widget	x_bar, y_bar;	/* horizontal and vertical scroll bars */
 
 static	Arg	resize_args[] = {
 	{XtNwidth,	(XtArgVal) 0},
 	{XtNheight,	(XtArgVal) 0},
 };
 
 #define	XdviResizeWidget(widget, w, h)	\
 		(width_arg.value = (XtArgVal) (w), \
 		resize_args[1].value = (XtArgVal) (h), \
 		XtSetValues(widget, resize_args, XtNumber(resize_args)) )
 
 #define	width_arg	(resize_args[0])
 #define	height_arg	(resize_args[1])
 
 
 
 /*
  *	Mechanism to keep track of the magnifier window.  The problems are,
  *	(a) if the button is released while the window is being drawn, this
  *	could cause an X error if we continue drawing in it after it is
  *	destroyed, and
  *	(b) creating and destroying the window too quickly confuses the window
  *	manager, which is avoided by waiting for an expose event before
  *	destroying it.
  */
 static	short	alt_stat;	/* 1 = wait for expose, */
 				/* -1 = destroy upon expose */
 
 /*
  *	Data for buffered events.
  */
 
 static	void
 mask_shifts(mask, pshift1, pshift2)
 	Pixel	mask;
 	int	*pshift1, *pshift2;
 {
 	int	k, l;
 
 	for (k = 0; (mask & 1) == 0; ++k)
 	    mask >>= 1;
 	for (l = 0; (mask & 1) == 1; ++l)
 	    mask >>= 1;
 	*pshift1 = sizeof(short) * 8 - l;
 	*pshift2 = k;
 }
 
 
 /*
  *	Warn about overstrike characters.
  */
 
 static	void
 warn_overstrike()
 {
 	static	Boolean	warned_already = False;
 
 	if (!warned_already) {
 	    warned_already = True;
 	    WARN(XmDIALOG_WARNING, "Overstrike characters may be incorrect");
 	}
 }
 
 /*
  *	Allocate a color and add it to our list of pixels to be returned
  *	upon opening a new document.
  */
 
 #define	SHIFTIFY(x, shift1, shift2)	((((Pixel)(x)) >> (shift1)) << (shift2))
 
 static	int	shift1_r, shift1_g, shift1_b;
 static	int	shift2_r, shift2_g, shift2_b;
 static	Boolean	shifts_good	= False;
 
 static Pixel
 alloc_color(const struct rgb *colorp, Pixel fallback_pixel)
 {
 	Visual *visual = DefaultVisualOfScreen(SCRN);
 
 	if (!shifts_good) {
 		mask_shifts(visual->red_mask,   &shift1_r, &shift2_r);
 		mask_shifts(visual->green_mask, &shift1_g, &shift2_g);
 		mask_shifts(visual->blue_mask,  &shift1_b, &shift2_b);
 		shifts_good = True;
 	}
 	return SHIFTIFY(colorp->r, shift1_r, shift2_r) |
 		SHIFTIFY(colorp->g, shift1_g, shift2_g) |
 		SHIFTIFY(colorp->b, shift1_b, shift2_b);
 }
 
 #undef SHIFTIFY
 
 
 /*
  *	Switch colors of GCs, etc.  Called when we're about to use a GC.
  */
 
 #define	SetGC(gc, fcn, fg, bg) \
 	    { \
 		values.function = fcn; \
 		values.foreground = fg; \
 		values.background = bg; \
 		if (gc != NULL) \
 		    XChangeGC(DISP, gc, \
 		      GCFunction | GCForeground | GCBackground, &values); \
 		else \
 		    gc = XCreateGC(DISP, XtWindow(top_level), \
 		      GCFunction | GCForeground | GCBackground, &values); \
 	    }
 
 void
 do_color_change()
 {
 	static	int	shrink_allocated_for = 0;
 	static	GC	foreGC2_bak	= NULL;
 	XGCValues	values;
 	Pixel		set_bits;
 	Pixel		clr_bits;
 	Visual		*visual;
 
 	/*
 	 * use_grey
 	 */
 	if (!fg_current->pixel_good) {
 		fg_current->pixel = alloc_color(&fg_current->color,
 			fore_color_data.pixel);
 		fg_current->pixel_good = True;
 	}
 
 	set_bits = fg_current->pixel & ~bg_current->pixel;
 	clr_bits = bg_current->pixel & ~fg_current->pixel;
 
 	visual = DefaultVisualOfScreen(SCRN);
 
 	if (set_bits & visual->red_mask)
 		set_bits |= visual->red_mask;
 	if (clr_bits & visual->red_mask)
 		clr_bits |= visual->red_mask;
 	if (set_bits & visual->green_mask)
 		set_bits |= visual->green_mask;
 	if (clr_bits & visual->green_mask)
 		clr_bits |= visual->green_mask;
 	if (set_bits & visual->blue_mask)
 		set_bits |= visual->blue_mask;
 	if (clr_bits & visual->blue_mask)
 		clr_bits |= visual->blue_mask;
 
 	/*
 	 * Make the GCs
 	 */
 
 	SetGC(ruleGC, GXcopy, fg_current->pixel, bg_current->pixel);
 	foreGC2 = NULL;
 
 	if (resource.copy || (set_bits && clr_bits && !resource.thorough)) {
 		if (!resource.copy)
 			warn_overstrike();
 		SetGC(foreGC, GXcopy, fg_current->pixel, bg_current->pixel);
 	}
 	else {
 		if (set_bits) {
 			SetGC(foreGC, GXor, fg_current->pixel & set_bits, 0);
 			if (clr_bits) {
 			    SetGC(foreGC2_bak, GXandInverted,
 			      ~fg_current->pixel & clr_bits, 0);
 			    foreGC2 = foreGC2_bak;
 			}
 		}
 		else
 			SetGC(foreGC, GXandInverted,
 				~fg_current->pixel & clr_bits, 0);
 	}
 
 	if (debug & DBG_DVI)
 		printf("do_color_change: fg = %lx, bg = %lx, with%s foreGC2\n",
 		      fg_current->pixel, bg_current->pixel,
 		      foreGC2 == NULL ? "out" : "");
 
 	if (mane.shrinkfactor <= 1) {
 		fg_active = fg_current;
 		return;
 	}
 
 	/*
 	 * mane.shrinkfactor > 1
 	 */
 	int i;
 	unsigned int sf_squared;
 
 	sf_squared = mane.shrinkfactor * mane.shrinkfactor;
 
 	if (shrink_allocated_for < mane.shrinkfactor) {
 		if (pixeltbl != NULL) {
 			free((char *) pixeltbl);
 			if (pixeltbl_t != NULL) {
 				free((char *) pixeltbl_t);
 				pixeltbl_t = NULL;
 			}
 		}
 		pixeltbl = xmalloc((sf_squared + 1) * sizeof(Pixel));
 		shrink_allocated_for = mane.shrinkfactor;
 	}
 	if (foreGC2 != NULL && pixeltbl_t == NULL)
 		/* Can't use sf_squared (or mane.shrinkfactor) here */
 		pixeltbl_t = xmalloc((shrink_allocated_for
 			* shrink_allocated_for + 1) * sizeof(Pixel));
 
 	/*
 	 * Compute pixel values directly.
 	 */
 	for (i = 0; i <= sf_squared; ++i) {
 		double frac = resource._gamma > 0
 			? pow((double) i / sf_squared, 1 / resource._gamma)
 			: 1 - pow((double) (sf_squared - i) / sf_squared,
 			  -resource._gamma);
 		unsigned int	red, green, blue;
 		Pixel		pixel;
 
 		red = frac * ((double) fg_current->color.r
 			- bg_current->color.r)
 			+ bg_current->color.r;
 		green = frac * ((double) fg_current->color.g
 			- bg_current->color.g)
 			+ bg_current->color.g;
 		blue = frac * ((double) fg_current->color.b
 			- bg_current->color.b)
 			+ bg_current->color.b;
 
 #define	SHIFTIFY(x, shift1, shift2) ((((Pixel)(x)) >> (shift1)) << (shift2))
 		pixel = SHIFTIFY(red,   shift1_r, shift2_r) |
 			SHIFTIFY(green, shift1_g, shift2_g) |
 			SHIFTIFY(blue,  shift1_b, shift2_b);
 #undef	SHIFTIFY
 
 		if (foreGC2 != NULL) {	/* if thorough */
 			pixeltbl[i] = pixel & ~bg_current->pixel;
 			pixeltbl_t[i] = ~pixel & bg_current->pixel;
 		}
 		else if (resource.copy || (set_bits && clr_bits))
 			pixeltbl[i] = pixel;
 		else
 			pixeltbl[i] = set_bits ? pixel & set_bits
 				: ~pixel & clr_bits;
 	}
 
 	fg_active = fg_current;
 }
 
 #undef SetGC
 
 
 /*
  *	Event-handling routines
  */
 
 static void
 expose(windowrec, x, y, w, h)
 	struct WindowRec *windowrec;
 	int		x, y;
 	unsigned int	w, h;
 {
 	if (windowrec->min_x > x) windowrec->min_x = x;
 	if (windowrec->max_x < x + w)
 	    windowrec->max_x = x + w;
 	if (windowrec->min_y > y) windowrec->min_y = y;
 	if (windowrec->max_y < y + h)
 	    windowrec->max_y = y + h;
 	ev_flags |= EV_EXPOSE;
 }
 
 static	void
 clearexpose(windowrec, x, y, w, h)
 	struct WindowRec *windowrec;
 	int		x, y;
 	unsigned int	w, h;
 {
 	XClearArea(DISP, windowrec->win, x, y, w, h, False);
 	expose(windowrec, x, y, w, h);
 }
 
 static	void
 scrollwindow(windowrec, x0, y0)
 	struct WindowRec *windowrec;
 	int	x0, y0;
 {
 	int	x, y;
 	int	x2 = 0, y2 = 0;
 	int	ww, hh;
 
 	x = x0 - windowrec->base_x;
 	y = y0 - windowrec->base_y;
 	ww = windowrec->width - x;
 	hh = windowrec->height - y;
 	windowrec->base_x = x0;
 	windowrec->base_y = y0;
 	if (currwin.win == windowrec->win) {
 	    currwin.base_x = x0;
 	    currwin.base_y = y0;
 	}
 	windowrec->min_x -= x;
 	if (windowrec->min_x < 0) windowrec->min_x = 0;
 	windowrec->max_x -= x;
 	if (windowrec->max_x > windowrec->width)
 	    windowrec->max_x = windowrec->width;
 	windowrec->min_y -= y;
 	if (windowrec->min_y < 0) windowrec->min_y = 0;
 	windowrec->max_y -= y;
 	if (windowrec->max_y > windowrec->height)
 	    windowrec->max_y = windowrec->height;
 	if (x < 0) {
 	    x2 = -x;
 	    x = 0;
 	    ww = windowrec->width - x2;
 	}
 	if (y < 0) {
 	    y2 = -y;
 	    y = 0;
 	    hh = windowrec->height - y2;
 	}
 	if (ww <= 0 || hh <= 0) {
 	    XClearWindow(DISP, windowrec->win);
 	    windowrec->min_x = windowrec->min_y = 0;
 	    windowrec->max_x = windowrec->width;
 	    windowrec->max_y = windowrec->height;
 	}
 	else {
 	    XCopyArea(DISP, windowrec->win, windowrec->win, copyGC,
 		x, y, (unsigned int) ww, (unsigned int) hh, x2, y2);
 	    if (x > 0)
 		clearexpose(windowrec, ww, 0,
 		    (unsigned int) x, windowrec->height);
 	    if (x2 > 0)
 		clearexpose(windowrec, 0, 0,
 		    (unsigned int) x2, windowrec->height);
 	    if (y > 0)
 		clearexpose(windowrec, 0, hh,
 		    windowrec->width, (unsigned int) y);
 	    if (y2 > 0)
 		clearexpose(windowrec, 0, 0,
 		    windowrec->width, (unsigned int) y2);
 	}
 }
 
 
 /*
  *	routines for X11 toolkit
  */
 
 Dimension	window_w, window_h;
 
 static	Arg	arg_wh[] = {
 	{XtNwidth,	(XtArgVal) &window_w},
 	{XtNheight,	(XtArgVal) &window_h},
 };
 
 static	Position	window_x, window_y;
 static	Arg	arg_xy[] = {
 	{XtNx,		(XtArgVal) &window_x},
 	{XtNy,		(XtArgVal) &window_y},
 };
 
 #define	get_xy()	XtGetValues(draw_widget, arg_xy, XtNumber(arg_xy))
 
 #define	mane_base_x	0
 #define	mane_base_y	0
 
 
 
 
 static void
 home(Boolean scrl)
 {
 	if (!scrl) XUnmapWindow(DISP, mane.win);
 	get_xy();
 	if (x_bar != NULL) {
 	    XtCallCallbacks(x_bar, XtNscrollProc,
 		(XtPointer) (ptrdiff_t) window_x);
 	}
 	if (y_bar != NULL) {
 	    XtCallCallbacks(y_bar, XtNscrollProc,
 		(XtPointer) (ptrdiff_t) window_y);
 	}
 	if (!scrl) {
 	    XMapWindow(DISP, mane.win);
 	    /* Wait for the server to catch up---this eliminates flicker. */
 	    XSync(DISP, False);
 	}
 }
 
 /*
  *	Same as home(), except move to the bottom of the page.
  */
 
 static	void
 home_bottom(Boolean scrl)
 {
 	XUnmapWindow(DISP, mane.win);
 	get_xy();
 	if (x_bar != NULL) {
 	    XtCallCallbacks(x_bar, XtNscrollProc,
 		(XtPointer) (ptrdiff_t) (window_x));
 	}
 	if (y_bar != NULL)
 	    XtCallCallbacks(y_bar, XtNscrollProc,
 		(XtPointer) (ptrdiff_t) (window_y + (page_h - clip_h)));
 	XMapWindow(DISP, mane.win);
 	/* Wait for the server to catch up---this eliminates flicker. */
 	XSync(DISP, False);
 }
 
 
 static	void
 handle_destroy_bar(w, client_data, call_data)
 	Widget		w;
 	XtPointer	client_data;
 	XtPointer	call_data;
 {
 	* (Widget *) client_data = NULL;
 }
 
 
 static	Boolean	resized	= False;
 
 static	void
 get_geom()
 {
 	static	Dimension	new_clip_w, new_clip_h;
 	static	Arg		arg_wh_clip[] = {
 		{XtNwidth,	(XtArgVal) &new_clip_w},
 		{XtNheight,	(XtArgVal) &new_clip_h},
 	};
 	int		old_clip_w;
 
 	XtGetValues(vport_widget, arg_wh, XtNumber(arg_wh));
 	XtGetValues(clip_widget, arg_wh_clip, XtNumber(arg_wh_clip));
 	/* Note:  widgets may be destroyed but not forgotten */
 	if (x_bar == NULL) {
 	    x_bar = XtNameToWidget(vport_widget, "horizontal");
 	    if (x_bar != NULL)
 		XtAddCallback(x_bar, XtNdestroyCallback, handle_destroy_bar,
 		    (XtPointer) &x_bar);
 	}
 	if (y_bar == NULL) {
 	    y_bar = XtNameToWidget(vport_widget, "vertical");
 	    if (y_bar != NULL)
 		XtAddCallback(y_bar, XtNdestroyCallback, handle_destroy_bar,
 		    (XtPointer) &y_bar);
 	}
 	old_clip_w = clip_w;
 			/* we need to do this because */
 			/* sizeof(Dimension) != sizeof(int) */
 	clip_w = new_clip_w;
 	clip_h = new_clip_h;
 	if (old_clip_w == 0) ev_flags |= EV_NEWPAGE;
 	resized = False;
 }
 
 /*
  *	callback routines
  */
 
 void
 handle_resize(widget, junk, event, cont)
 	Widget	widget;
 	XtPointer junk;
 	XEvent	*event;
 	Boolean	*cont;		/* unused */
 {
 	resized = True;
 }
 
 
 static void
 reconfig()
 {
 	XdviResizeWidget(draw_widget, page_w, page_h);
 	get_geom();
 }
 
 
 
 /*
  *	goto_page is the only place where current_page should be set,
  *	other than when reading a new dvi file.
  */
 
 static	home_proc	home_action	= home;
 
 static void
 goto_page(n, proc)
 	int		n;
 	home_proc	proc;
 {
 	current_page = n;
 	home_action = proc;
 }
 
 
 
 
 
 /* |||
  *	Currently the event handler does not coordinate XCopyArea requests
  *	with GraphicsExpose events.  This can lead to problems if the window
  *	is partially obscured and one, for example, drags a scrollbar.
  */
 
 /*
  *	Actions for the translation mechanism.
  */
 
 static	Boolean	have_arg	= False;
 static	int	number		= 0;
 static	int	sign		= 1;
 
 
 #define	GET_ARG4(arg, param, param2, default)		\
 		if (*num_params > 0)			\
 		    {param;}				\
 		else {					\
 		    if (have_arg) {			\
 			arg = (param2);			\
 			have_arg = False;		\
 			number = 0;			\
 			sign = 1;			\
 		    }					\
 		    else				\
 			{default}			\
 		}
 
 #define	GET_ARG(arg, default)				\
 		GET_ARG4(arg, arg = atoi(*params), sign * number, \
 		  arg = (default);)
 
 #define	GET_ARG6(arg, param, c, param_c, param2, default)\
 		if (*num_params > 0) {			\
 		    if (**params == (c))		\
 			{param_c;}			\
 		    else				\
 			{param;}			\
 		}					\
 		else {					\
 		    if (have_arg) {			\
 			arg = (param2);			\
 			have_arg = False;		\
 			number = 0;			\
 			sign = 1;			\
 		    }					\
 		    else				\
 			{default;}			\
 		}
 
 #define	TOGGLE(arg)							\
 	if (*num_params > 0) {						\
 	    if (**params != 't' && (atoi(*params) != 0) == arg)		\
 		return;							\
 	}								\
 	else {								\
 	    if (have_arg) {						\
 		int	tmparg = number;				\
 									\
 		have_arg = False;					\
 		number = 0;						\
 		sign = 1;						\
 									\
 		if ((tmparg != 0) == arg)				\
 		    return;						\
 	    }								\
 	}
 
 
 
 static
 ACTION(Act_digit)
 {
 	unsigned int	digit;
 
 	if (*num_params != 1 || (digit = **params - '0') > 9) {
 	    XBell(DISP, 0);
 	    return;
 	}
 	have_arg = True;
 	number = number * 10 + digit;
 }
 
 static
 ACTION(Act_minus)
 {
 	have_arg = True;
 	sign = -sign;
 }
 
 static
 ACTION(Act_quit)
 {
 	exit(1);
 }
 
 static
 ACTION(Act_goto_page)
 {
 	int	arg;
 
 	GET_ARG6(arg, arg = atoi(*params) - pageno_correct,
 	  'e', arg = total_pages - 1,
 	  sign * number - pageno_correct, arg = total_pages - 1);
 
 	if (arg < 0 || arg >= total_pages) {
 	    XBell(DISP, 0);
 	    return;
 	}
 
 	if (current_page != arg)
 	    goto_page(arg, home);
 
 	ev_flags |= EV_NEWPAGE;
 	XFlush(DISP);
 	return;		/* Don't use longjmp here:  it might be called from
 			 * within the toolkit, and we don't want to longjmp out
 			 * of Xt routines. */
 }
 
 static
 ACTION(Act_forward_page)
 {
 	int	arg;
 
 	GET_ARG(arg, 1);
 	arg += current_page;
 
 	if (arg >= 0 && arg < total_pages) {
 	    if (current_page != arg)
 		goto_page(arg, home);
 	    /* Control-L (and changing the page) clears this box */
 	    ev_flags |= EV_NEWPAGE;
 	    XFlush(DISP);
 	    return;	/* Don't use longjmp here:  it might be called from
 			 * within the toolkit, and we don't want to longjmp out
 			 * of Xt routines. */
 	}
 	XBell(DISP, 0);
 }
 
 static
 ACTION(Act_back_page)
 {
 	int	arg;
 
 	GET_ARG(arg, 1);
 	arg = current_page - arg;
 
 	if (arg >= 0 && arg < total_pages) {
 	    if (current_page != arg)
 		goto_page(arg, home);
 	    ev_flags |= EV_NEWPAGE;
 	    XFlush(DISP);
 	    return;	/* Don't use longjmp here:  it might be called from
 			 * within the toolkit, and we don't want to longjmp out
 			 * of Xt routines. */
 	}
 	XBell(DISP, 0);
 }
 
 static
 ACTION(Act_declare_page_number)
 {
 	int	arg;
 
 	GET_ARG(arg, 0);
 	pageno_correct = arg - current_page;
 }
 
 static
 ACTION(Act_home)
 {
 	home(True);
 }
 
 static
 ACTION(Act_center)
 {
 	int	x, y;
 
 	x = event->xkey.x - clip_w / 2;
 	y = event->xkey.y - clip_h / 2;
 	/* The clip widget gives a more exact value. */
 	if (x_bar != NULL)
 	    XtCallCallbacks(x_bar, XtNscrollProc, (XtPointer) (ptrdiff_t) x);
 	if (y_bar != NULL)
 	    XtCallCallbacks(y_bar, XtNscrollProc, (XtPointer) (ptrdiff_t) y);
 	XWarpPointer(XtDisplay(w), None, None, 0, 0, 0, 0, -x, -y);
 }
 
 static
 ACTION(Act_left)
 {
 	if (x_bar != NULL)
 	    XtCallCallbacks(x_bar, XtNscrollProc,
 	      (XtPointer) (*num_params == 0 ? (-2 * (ptrdiff_t) clip_w / 3)
 	      : (ptrdiff_t) (-atof(*params) * clip_w)));
 	else
 	    XBell(XtDisplay(w), 0);
 }
 
 static
 ACTION(Act_right)
 {
 	if (x_bar != NULL)
 	    XtCallCallbacks(x_bar, XtNscrollProc,
 	      (XtPointer) (*num_params == 0 ? (2 * (ptrdiff_t) clip_w / 3)
 	      : (ptrdiff_t) (atof(*params) * clip_w)));
 	else
 	    XBell(XtDisplay(w), 0);
 }
 
 static
 ACTION(Act_up)
 {
 	if (y_bar != NULL)
 	    XtCallCallbacks(y_bar, XtNscrollProc,
 	      (XtPointer) (*num_params == 0 ? (-2 * (ptrdiff_t) clip_h / 3)
 	      : (ptrdiff_t) (-atof(*params) * clip_h)));
 	else
 	    XBell(XtDisplay(w), 0);
 }
 
 static
 ACTION(Act_down)
 {
 	if (y_bar != NULL)
 	    XtCallCallbacks(y_bar, XtNscrollProc,
 	      (XtPointer) (*num_params == 0 ? (2 * (ptrdiff_t) clip_h / 3)
 	      : (ptrdiff_t) (atof(*params) * clip_h)));
 	else
 	    XBell(XtDisplay(w), 0);
 }
 
 static
 ACTION(Act_down_or_next)
 {
 	if (y_bar != NULL) {
 		get_xy();
 		if (window_y > (int) clip_h - (int) page_h) {
 		    XtCallCallbacks(y_bar, XtNscrollProc,
 		      (XtPointer) (*num_params == 0
 		      ? (2 * (ptrdiff_t) clip_h / 3)
 		      : (ptrdiff_t) (atof(*params) * clip_h)));
 		    return;
 		}
 	}
 
 	if (current_page < total_pages - 1) {
 	    goto_page(current_page + 1, home);
 	    ev_flags |= EV_NEWPAGE;
 	    XFlush(XtDisplay(w));
 	    return;	/* Don't use longjmp here:  it might be called from
 			 * within the toolkit, and we don't want to longjmp out
 			 * of Xt routines. */
 	}
 	else
 	    XBell(XtDisplay(w), 0);
 }
 
 static
 ACTION(Act_up_or_previous)
 {
 	if (y_bar != NULL) {
 		get_xy();
 		if (window_y < 0) {
 		    XtCallCallbacks(y_bar, XtNscrollProc,
 		      (XtPointer) (*num_params == 0
 		      ? (-2 * (ptrdiff_t) clip_h / 3)
 		      : (ptrdiff_t) (-atof(*params) * clip_h)));
 		    return;
 		}
 	}
 
 	if (current_page > 0) {
 	    goto_page(current_page - 1, home_bottom);
 	    ev_flags |= EV_NEWPAGE;
 	    XFlush(XtDisplay(w));
 	    return;	/* Don't use longjmp here:  it might be called from
 			 * within the toolkit, and we don't want to longjmp out
 			 * of Xt routines. */
 	}
 	else
 	    XBell(XtDisplay(w), 0);
 }
 
 static
 ACTION(Act_show_display_attributes)
 {
 	Display *disp = XtDisplay(w);
 
 	printf("Unit = %d, bitord = %d, byteord = %d\n",
 	    BitmapUnit(disp), BitmapBitOrder(disp), ImageByteOrder(disp));
 }
 
 static	int
 shrink_to_fit()
 {
 	int	value1;
 	int	value2;
 
 	value1 = ROUNDUP(unshrunk_page_w, window_w - 2);
 
 	value2 = ROUNDUP(unshrunk_page_h, window_h - 2);
 
 	return value1 > value2 ? value1 : value2;
 }
 
 static
 ACTION(Act_set_shrink_factor)
 {
 	int	arg;
 
 	GET_ARG6(arg, arg = atoi(*params), 'a', arg = shrink_to_fit(),
 	  number, arg = shrink_to_fit());
 
 	if (arg <= 0 || arg > 10) {
 	    XBell(XtDisplay(w), 0);
 	    return;
 	}
 
 	if (arg == mane.shrinkfactor)
 	    return;
 	mane.shrinkfactor = arg;
 	if (arg != 1 && arg != bak_shrink) {
 	    bak_shrink = arg;
 	    fg_active = NULL;
 	    reset_fonts();
 	}
 
 	if (dvi_file == NULL) {
 	    unshrunk_page_w = unshrunk_page_h = 0;
 	    return;
 	}
 
 	init_page();
 	reconfig();
 	home(False);
 	ev_flags |= EV_NEWPAGE;
 	XFlush(XtDisplay(w));
 }
 
 static
 ACTION(Act_shrink_to_dpi)
 {
 	int	arg;
 
 	GET_ARG(arg, 0);
 
 	if (arg > 0)
 	    arg = (double) pixels_per_inch / arg + 0.5;
 
 	if (arg <= 0) {
 	    XBell(XtDisplay(w), 0);
 	    return;
 	}
 
 	if (arg == mane.shrinkfactor)
 	    return;
 	mane.shrinkfactor = arg;
 	if (arg != 1 && arg != bak_shrink) {
 	    bak_shrink = arg;
 	    fg_active = NULL;
 	    reset_fonts();
 	}
 
 	if (dvi_file == NULL) {
 	    unshrunk_page_w = unshrunk_page_h = 0;
 	    return;
 	}
 
 	init_page();
 	reconfig();
 	home(False);
 	ev_flags |= EV_NEWPAGE;
 	XFlush(XtDisplay(w));
 }
 
 static
 ACTION(Act_set_density)
 {
 	int	arg;
 
 	GET_ARG4(arg, arg = atoi(*params), sign * number,
 	  {XBell(XtDisplay(w), 0); return;});
 
 	float newgamma = arg != 0 ? arg / 100.0 : 1.0;
 
 	/*
 	 * use_grey
 	 */
 	if (newgamma == resource._gamma)
 		return;
 	resource._gamma = newgamma;
 	fg_active = NULL;
 	reset_colors();
 
 	ev_flags |= EV_NEWPAGE;
 	XFlush(XtDisplay(w));
 }
 
 
 static
 ACTION(Act_set_color)
 {
 	TOGGLE(resource._use_color)
 
 	if (resource._use_color) {
 	    resource._use_color = False;
 	    full_reset_colors();
 	    scanned_page_color = total_pages;
 	}
 	else {
 	    resource._use_color = True;
 	    scanned_page = scanned_page_color = scanned_page_reset;
 	}
 	ev_flags |= EV_NEWPAGE;
 }
 
 
 static
 ACTION(Act_discard_number)
 {
 	have_arg = False;
 	number = 0;
 	sign = 1;
 }
 
 
 /* Actions to support the magnifying glass.  */
 
 static	void	mag_motion(XEvent *);
 static	void	mag_release(XEvent *);
 
 static	void
 compute_mag_pos(xp, yp)
 	int	*xp, *yp;
 {
 	int	t;
 
 	t = mag_x + main_x - alt.width/2;
 	if (t > WidthOfScreen(SCRN) - (int) alt.width - 2*MAGBORD)
 	    t = WidthOfScreen(SCRN) - (int) alt.width - 2*MAGBORD;
 	if (t < 0) t = 0;
 	*xp = t;
 	t = mag_y + main_y - alt.height/2;
 	if (t > HeightOfScreen(SCRN) - (int) alt.height - 2*MAGBORD)
 	    t = HeightOfScreen(SCRN) - (int) alt.height - 2*MAGBORD;
 	if (t < 0) t = 0;
 	*yp = t;
 }
 
 static
 ACTION(Act_magnifier)
 {
 	const char		*p;
 	int			x, y;
 	XSetWindowAttributes	attr;
 	Window			throwaway;
 	Display			*disp;
 
 	disp = XtDisplay(w);
 
 	if (event->type != ButtonPress || mouse_release != null_mouse
 	  || alt.win != (Window) 0 || mane.shrinkfactor == 1
 	  || *num_params != 1) {
 	    XBell(disp, 0);
 	    return;
 	}
 
 	p = *params;
 	if (*p == '*') {
 	    int n = atoi(p + 1) - 1;
 
 	    if (n < 0 || n >= 5 || mg_size[n].w <= 0) {
 		XBell(disp, 0);
 		return;
 	    }
 	    alt.width = mg_size[n].w;
 	    alt.height = mg_size[n].h;
 	}
 	else {
 	    alt.width = alt.height = atoi(p);
 	    p = index(p, 'x');
 	    if (p != NULL) {
 		alt.height = atoi(p + 1);
 		if (alt.height == 0) alt.width = 0;
 	    }
 	    if (alt.width == 0) {
 		XBell(disp, 0);
 		return;
 	    }
 	}
 	(void) XTranslateCoordinates(XtDisplay(w), event->xbutton.window, mane.win,
 	  0, 0, &mag_conv_x, &mag_conv_y, &throwaway);
 
 	mag_x = event->xbutton.x + mag_conv_x;
 	mag_y = event->xbutton.y + mag_conv_y;
 	main_x = event->xbutton.x_root - mag_x;
 	main_y = event->xbutton.y_root - mag_y;
 	compute_mag_pos(&x, &y);
 	alt.base_x = (mag_x + mane_base_x) * mane.shrinkfactor - alt.width/2;
 	alt.base_y = (mag_y + mane_base_y) * mane.shrinkfactor - alt.height/2;
 	attr.save_under = True;
 	attr.background_pixel = bg_current->pixel;
 	attr.override_redirect = True;
 	alt.win = XCreateWindow(disp, RootWindowOfScreen(SCRN),
 		    x, y, alt.width, alt.height, MAGBORD,
 		    CopyFromParent, InputOutput, CopyFromParent,
 		    CWSaveUnder | CWBackPixel |
 		    CWOverrideRedirect, &attr);
 	XSelectInput(disp, alt.win, ExposureMask);
 	XMapWindow(disp, alt.win);
 	alt_stat = 1;	/* waiting for exposure */
 	mouse_motion = mag_motion;
 	mouse_release = mag_release;
 }
 
 static	void
 mag_motion(XEvent *event)
 {
 	new_mag_x = event->xmotion.x + mag_conv_x;
 	main_x = event->xmotion.x_root - new_mag_x;
 	new_mag_y = event->xmotion.y + mag_conv_y;
 	main_y = event->xmotion.y_root - new_mag_y;
 
 	if (new_mag_x != mag_x || new_mag_y != mag_y)
 	    ev_flags |= EV_MAG_MOVE;
 	else
 	    ev_flags &= ~EV_MAG_MOVE;
 }
 
 static	void
 mag_release(XEvent *event)
 {
 	if (alt.win != (Window) 0) {
 	    if (alt_stat)
 		alt_stat = -1;	/* destroy upon expose */
 	    else {
 		XDestroyWindow(DISP, alt.win);
 		if (drawing_mag) ev_flags |= EV_MAG_GONE;
 		alt.win = (Window) 0;
 		mouse_motion = mouse_release = null_mouse;
 		ev_flags &= ~EV_MAG_MOVE;
 		can_exposures(&alt);
 	    }
 	}
 }
 
 static	void
 movemag(x, y)
 	int	x, y;
 {
 	int	xx, yy;
 
 	mag_x = x;
 	mag_y = y;
 	if (mag_x == new_mag_x && mag_y == new_mag_y) ev_flags &= ~EV_MAG_MOVE;
 	compute_mag_pos(&xx, &yy);
 	XMoveWindow(DISP, alt.win, xx, yy);
 	scrollwindow(&alt,
 	    (x + mane_base_x) * mane.shrinkfactor - (int) alt.width/2,
 	    (y + mane_base_y) * mane.shrinkfactor - (int) alt.height/2);
 }
 
 
 /* Actions to support dragging the image.  */
 
 static	int	drag_last_x, drag_last_y;	/* last position of cursor */
 static	int	drag_flags;			/* 1 = vert, 2 = horiz */
 
 static	void	drag_motion(XEvent *);
 static	void	drag_release(XEvent *);
 
 static
 ACTION(Act_drag)
 {
 	if (mouse_release != null_mouse && mouse_release != drag_release)
 	    return;
 
 
 	if (*num_params != 1) return;
 	switch (**params) {
 	    case '|':  drag_flags = 1; break;
 	    case '-':  drag_flags = 2; break;
 	    case '+':  drag_flags = 3; break;
 	    default:   return;
 	}
 
 
 	if (mouse_release == null_mouse) {
 	    mouse_motion = drag_motion;
 	    mouse_release = drag_release;
 	    drag_last_x = event->xbutton.x_root;
 	    drag_last_y = event->xbutton.y_root;
 	}
 	else
 	    drag_motion(event);
 
 	XFlush(XtDisplay(w));
 	dragcurs = True;
 }
 
 
 static	void
 drag_motion(XEvent *event)
 {
 
 	if (drag_flags & 2) {	/* if horizontal motion */
 	    if (x_bar != NULL)
 		XtCallCallbacks(x_bar, XtNscrollProc,
 		  (XtPointer) (ptrdiff_t)
 		  (drag_last_x - event->xbutton.x_root));
 	    drag_last_x = event->xbutton.x_root;
 	}
 
 	if (drag_flags & 1) {	/* if vertical motion */
 	    if (y_bar != NULL)
 		XtCallCallbacks(y_bar, XtNscrollProc,
 		  (XtPointer) (ptrdiff_t)
 		  (drag_last_y - event->xbutton.y_root));
 	    drag_last_y = event->xbutton.y_root;
 	}
 }
 
 
 static	void
 drag_release(XEvent *event)
 {
 	drag_motion(event);
 	mouse_motion = mouse_release = null_mouse;
 
 	XDefineCursor(DISP, CURSORWIN,
 	  ev_flags & EV_CURSOR ? redraw_cursor : ready_cursor);
 	XFlush(DISP);
 	dragcurs = False;
 }
 
 
 
 /* Wheel support.  */
 
 static	int	wheel_button	= -1;
 
 static
 ACTION(Act_wheel)
 {
 	int	dist;
 
 	if (*num_params == 0) {
 	    XBell(XtDisplay(w), 0);
 	    return;
 	}
 	dist = (index(*params, '.') == NULL) ? atoi(*params)
 #define WHEEL_UNIT 80
 	  : (int) (atof(*params) * WHEEL_UNIT);
 	if (y_bar != NULL)
 	    XtCallCallbacks(y_bar, XtNscrollProc, (XtPointer) (ptrdiff_t) dist);
 
 	if (event != NULL)
 	    wheel_button = event->xbutton.button;
 }
 
 static	int	wheel_h_button	= -1;
 
 static
 ACTION(Act_hwheel)
 {
 	int	dist;
 
 	if (*num_params == 0) {
 	    XBell(XtDisplay(w), 0);
 	    return;
 	}
 	dist = (index(*params, '.') == NULL) ? atoi(*params)
 	  : (int) (atof(*params) * WHEEL_UNIT);
 	if (x_bar != NULL)
 	    XtCallCallbacks(x_bar, XtNscrollProc, (XtPointer) (ptrdiff_t) dist);
 
 	if (event != NULL)
 	    wheel_h_button = event->xbutton.button;
 }
 
 static
 ACTION(Act_wheel_actions)
 {
 	struct wheel_acts *wactp;
 	struct xdvi_action *actp;
 
 	for (wactp = wheel_actions; wactp != NULL; wactp = wactp->next)
 	    if (event->xbutton.button == wactp->button || wactp->button == 0) {
 		Modifiers mask = 0;
 		Modifiers value = 0;
 
 		if (wactp->late_bindings == NULL
 		  || _XtComputeLateBindings(XtDisplay(w), wactp->late_bindings,
 		  &value, &mask)) {
 		    mask |= wactp->mask;
 		    value |= wactp->value;
 		    if (((value ^ event->xbutton.state) & mask) == 0) {
 			for (actp = wactp->action; actp != NULL;
 			  actp = actp->next)
 			    (actp->proc)(w, event,
 			      &actp->param, &actp->num_params);
 			return;
 		    }
 		}
 	    }
 }
 
 
 /* Internal mouse actions.  */
 
 
 static
 ACTION(Act_motion)
 {
 	if (event->xbutton.button != wheel_button
 	   && event->xbutton.button != wheel_h_button)
 	    mouse_motion(event);
 }
 
 
 static
 ACTION(Act_release)
 {
 	if (event->xbutton.button == wheel_button) {
 	    wheel_button = -1;
 	    return;
 	}
 
 	if (event->xbutton.button == wheel_h_button) {
 	    wheel_h_button = -1;
 	    return;
 	}
 
 	mouse_release(event);
 }
 
 static Boolean
 new_dvi(const char *url)
 {
 	FILE *tmp;
 
 	if ((tmp = http_get(url)) == NULL)
 		return False;
 
 	if (dvi_magic_ok(tmp) == False) {
 		warning_popup_long("%s: Not a DVI file", "OK", NULL, url);
 		return False;
 	}
 
 	if (fseek(tmp, 0L, SEEK_SET) < 0)
 		err(1, "fseek");
 
 	fclose(dvi_file);
 	dvi_file = tmp;
 	ev_flags |= EV_NEWDOC;
 	goto_page(0, home);
 
 	return True;
 }
 
 static void
 cb_addr_go(Widget w, XtPointer client_data, XtPointer call_data)
 {
 	const char	*s;
 
 	if (w == NULL)
 		s = addr_default;
 	else
 		XtVaGetValues(addr_widget, XtNstring, &s, NULL);
 
 	new_dvi(s);
 }
 
 static
 ACTION(Act_addr_go)
 {
 	cb_addr_go(w, NULL, NULL);
 }
 
 
 static Boolean link_mode = False;
 struct htex_data htex_data;
 
 static
 ACTION(Act_show_links)
 {
 	bzero(&htex_data, sizeof(struct htex_data));
 	hypertex_search(&htex_data);
 
 	link_mode = False;
 
 #define numitems(_a)	(sizeof(_a) / sizeof((_a)[0]))
 	for (int i = 0; i < numitems(htex_data.links); i++)
 		if (htex_data.links[i] != NULL) {
 			link_mode = True;
 			free(htex_data.links[i]);
 		}
 
 }
 
 #undef	ACTION
 #undef	GET_ARG4
 #undef	GET_ARG
 #undef	TOGGLE
 
 void
 handle_expose(widget, closure, ev, cont)
 	Widget	widget;
 	XtPointer closure;
 	XEvent	*ev;
 #define	event	(&(ev->xexpose))
 	Boolean	*cont;		/* unused */
 {
 	struct WindowRec *windowrec = (struct WindowRec *) closure;
 
 	if (windowrec == &alt) {
 	    if (alt_stat < 0) {	/* destroy upon exposure */
 		alt_stat = 0;
 		mag_release(ev);
 		return;
 	    }
 	    else
 		alt_stat = 0;
 	}
 
 	expose(windowrec, event->x, event->y,
 	    (unsigned int) event->width, (unsigned int) event->height);
 }
 
 #undef	event
 
 void
 handle_messages(widget, closure, event, cont)
 	Widget	widget;
 	XtPointer closure;
 	XEvent	*event;
 	Boolean	*cont;		/* unused */
 {
 	if (event->type == ClientMessage
 	  && event->xclient.message_type == XA_WM_PROTOCOLS
 	  && event->xclient.data.l[0] == XA_WM_DELETE_WINDOW) {
 	    if (closure != 0)
 		((XtCallbackProc) closure) (widget, NULL, NULL);
 	    else
 		Act_quit(widget, event, NULL, 0);
 	}
 }
 
 static void
 handle_keypress(Widget w, XtPointer closure, XEvent *event, Boolean *cont)
 {
 	Modifiers	 modifiers;
 	KeySym		 keysym;
 	int		 index;
 	const char	*url;
 
 	/*
 	 * Clear the highlights. This second call to the drawing routines
 	 * clears existing highlights.
 	 */
 	bzero(&htex_data, sizeof(struct htex_data));
 	hypertex_search(&htex_data);
 	link_mode = False;
 
 	XtTranslateKeycode(DISP, event->xkey.keycode, 0, &modifiers, &keysym);
 
 	index = tolower(keysym) - 'a';
 	if (index < 0 || index > 26)
 		return;
 
 	url = htex_data.links[index];
 	if (url == NULL)
 		return;
 
 	if (new_dvi(url) == False)
 		return;
 
 	XtVaSetValues(addr_widget, XtNstring, url, NULL);
 	XtVaSetValues(addr_widget, XtNinsertPosition, strlen(url), NULL);
 }
 
 
 /*
  *	Process-related routines.  Call set_chld() to indicate that a given
  *	child process should be watched for when it terminates.  Call
  *	clear_chld() to remove the process from the list.  When the child
  *	terminates, the record is removed from the list and the indicated
  *	process is called.
  */
 
 static	struct xchild	*child_recs	= NULL;	/* head of child process list */
 
 void
 set_chld(cp)
 	struct xchild	*cp;
 {
 	cp->next = child_recs;
 	child_recs = cp;
 }
 
 void
 clear_chld(cp)
 	struct xchild	*cp;
 {
 	struct xchild	**cpp;
 
 	for (cpp = &child_recs;;) {
 	    struct xchild *cp2;
 
 	    cp2 = *cpp;
 	    if (cp2 == cp) break;
 	    cpp = &cp2->next;
 	}
 	*cpp = cp->next;
 }
 
 
 /*
  *	File-related routines.  Call set_io() to indicate that a given fd
  *	should be watched for ability to input or output data.  Call clear_io()
  *	to remove it from the list.  When poll()/select() indicates that the fd
  *	is available for the indicated type of i/o, the corresponding routine
  *	is called.  Call clear_io() to remove an fd from the list.
  *	Both set_io() and clear_io() can be called from within read_proc or
  *	write_proc (although turning an io descriptor on or off is better
  *	accomplished by setting the events flag in the xio structure, and
  *	in the corresponding pollfd structure if the pfd pointer is not NULL
  *	(it is always non-NULL when read_proc and write_proc are called)).
  *	We allocate space for one additional record in the pollfd array, to
  *	accommodate the fd for the X connection; this is done by initializing
  *	num_fds to 1 instead of zero.
  */
 
 static	struct xio	*iorecs	= NULL;	/* head of xio list */
 
 static	struct pollfd	*fds	= NULL;
 static	int		num_fds	= 1;	/* current number of fds */
 static	int		max_fds	= 0;	/* max allocated number of fds */
 static	Boolean		io_dirty= True;	/* need to recompute fds[] array */
 
 void
 set_io(ip)
 	struct xio	*ip;
 {
 	ip->next = iorecs;
 	iorecs = ip;
 
 	++num_fds;
 	if (!io_dirty && num_fds <= max_fds) {
 	    fds[num_fds - 1].fd = ip->fd;
 	    fds[num_fds - 1].events = ip->xio_events;
 	    ip->pfd = &fds[num_fds - 1];
 	}
 	else {
 	    ip->pfd = NULL;
 	    io_dirty = True;
 	}
 }
 
 void
 clear_io(ip)
 	struct xio	*ip;
 {
 	struct xio	**ipp;
 
 	for (ipp = &iorecs;;) {
 	    struct xio *ip2;
 
 	    ip2 = *ipp;
 	    if (ip2 == ip) break;
 	    ipp = &ip2->next;
 	}
 	*ipp = ip->next;
 
 	--num_fds;
 	io_dirty = True;
 }
 
 
 /*
  *	Ultimately, the goal is to have this be the only place in xdvi where
  *	blocking occurs.
  *
  *	The argument to this function should be a mask of event types (EV_*)
  *	indicating which event types should cause read_events to return instead
  *	of waiting for more events.  This function will always process all
  *	pending events and signals before returning.
  *	The return value is the value of ev_flags.
  */
 
 unsigned int
 read_events(unsigned int ret_mask)
 {
 	XEvent	event;
 
 	for(;;) {
 
 		if (!XtPending() && (ev_flags & ret_mask))
 			return ev_flags;
 
 		XtNextEvent(&event);
 
 		if (resized)
 			get_geom();
 		if (event.xany.window == alt.win && event.type == Expose) {
 			handle_expose((Widget) NULL, (XtPointer) &alt, &event,
 				(Boolean *) NULL);
 			continue;
 		}
 		if (link_mode == True && event.type == KeyPress) {
 			handle_keypress(NULL, NULL, &event, NULL);
 			continue;
 		}
 
 		XtDispatchEvent(&event);
 	}
 }
 
 
 /*
  *	Higher-level routines for managing events.
  */
 
 static	void
 can_exposures(windowrec)
 	struct WindowRec *windowrec;
 {
 	windowrec->min_x = windowrec->min_y = MAXDIM;
 	windowrec->max_x = windowrec->max_y = 0;
 }
 
 static	void
 redraw(windowrec)
 	struct WindowRec *windowrec;
 {
 
 	currwin = *windowrec;
 	min_x = currwin.min_x + currwin.base_x;
 	min_y = currwin.min_y + currwin.base_y;
 	max_x = currwin.max_x + currwin.base_x;
 	max_y = currwin.max_y + currwin.base_y;
 	can_exposures(windowrec);
 
 	if (debug & DBG_EVENT)
 	    printf("Redraw %d x %d at (%d, %d) (base=%d,%d)\n", max_x - min_x,
 		max_y - min_y, min_x, min_y, currwin.base_x, currwin.base_y);
 
 	if (!(ev_flags & EV_CURSOR)) {
 	    if (!dragcurs) {
 		XDefineCursor(DISP, CURSORWIN, redraw_cursor);
 		XFlush(DISP);
 	    }
 	    ev_flags |= EV_CURSOR;
 	}
 
 	draw_page();
 }
 
 static	void
 redraw_page()
 {
 	const struct rgb *rgbp;
 
 	if (debug & DBG_EVENT)
 		puts("Redraw page:  ");
 
 	if (scanned_page < current_page) {
 	    prescan();
 	    if (ev_flags & EV_GE_NEWPAGE)	/* if we need to re-prescan */
 		return;
 	}
 
 	if (page_info[current_page].ww != unshrunk_page_w
 	  || page_info[current_page].wh != unshrunk_page_h) {
 	    init_page();
 	    reconfig();
 	}
 
 	/* We can't call home() without proper unshrunk_page_*, which requires
 	 * prescan(), which can't be done from within read_events() */
 
 	if (home_action != NULL) {
 		home_action(False);
 	    home_action = NULL;
 
 	    /* This discards the expose event generated by home() */
 	    if (read_events(EV_NOWAIT) & EV_GE_NEWPAGE)
 		return;
 	    can_exposures(&mane);
 	}
 
 	rgbp = &bg_initial;
 	if (page_colors != NULL)
 	    rgbp = &page_colors[current_page].bg;
 
 	/* Set background color */
 	if (bg_current == NULL
 	  || rgbp->r != bg_current->color.r
 	  || rgbp->g != bg_current->color.g
 	  || rgbp->b != bg_current->color.b) {
 	    struct bgrec **bgpp;
 
 	    for (bgpp = &bg_head;;) {
 		bg_current = *bgpp;
 		if (bg_current == NULL) {	/* if bg is not in list */
 		    bg_current = *bgpp = xmalloc(sizeof *bg_current);
 		    bg_current->next = NULL;
 		    bg_current->color = *rgbp;
 		    bg_current->fg_head = NULL;
 		    bg_current->pixel_good = False;
 		    break;
 		}
 		if (bg_current->color.r == rgbp->r
 		  && bg_current->color.g == rgbp->g
 		  && bg_current->color.b == rgbp->b)
 		    break;
 		bgpp = &bg_current->next;
 	    }
 	    fg_current = NULL;	/* force change of foreground color */
 	    if (debug & DBG_DVI)
 		printf("Changing background color to %5d %5d %5d\n",
 		  bg_current->color.r, bg_current->color.g,
 		  bg_current->color.b);
 
 	    if (!bg_current->pixel_good) {
 		bg_current->pixel = alloc_color(&bg_current->color,
 		  back_color_data.pixel);
 		bg_current->pixel_good = True;
 	    }
 	    XSetWindowBackground(DISP, mane.win, bg_current->pixel);
 	}
 
 	XWindowAttributes attrs;
 	XGetWindowAttributes(DISP, mane.win, &attrs);
 	int backing_store = attrs.backing_store;
 
 	XClearWindow(DISP, mane.win);
 	if (backing_store != NotUseful) {
 	    mane.min_x = mane.min_y = 0;
 	    mane.max_x = page_w;
 	    mane.max_y = page_h;
 	}
 	else {
 	    get_xy();
 	    mane.min_x = -window_x;
 	    mane.max_x = -window_x + clip_w;
 	    mane.min_y = -window_y;
 	    mane.max_y = -window_y + clip_h;
 	}
 	redraw(&mane);
 }
 
 void
 do_pages()
 {
 	(void) read_events(EV_GT_IDLE);
 
 	if (ev_flags & (EV_NEWPAGE | EV_NEWDOC | EV_PS_TOGGLE)) {
 		ev_flags &= ~(EV_NEWPAGE | EV_EXPOSE | EV_PS_TOGGLE);
 		if (ev_flags & EV_NEWDOC) {
 			ev_flags &= ~EV_NEWDOC;
 			if (reload_dvi_file() == False)
 				warning_popup("Bad DVI document", "OK", NULL);
 	    	}
 		can_exposures(&mane);
 		can_exposures(&alt);
 
 		if (dvi_file != NULL)
 			redraw_page();
 	}
 	else if (ev_flags & EV_MAG_MOVE) {
 		if (alt.win == (Window) 0)
 			ev_flags &= ~EV_MAG_MOVE;
 		else if (abs(new_mag_x - mag_x) > 2 * abs(new_mag_y - mag_y))
 			movemag(new_mag_x, mag_y);
 		else if (abs(new_mag_y - mag_y) > 2 * abs(new_mag_x - mag_x))
 			movemag(mag_x, new_mag_y);
 		else
 			movemag(new_mag_x, new_mag_y);
 	}
 	else if (ev_flags & EV_EXPOSE) {
 		if (alt.min_x < MAXDIM) {
 			if (mane.min_x >= MAXDIM)
 				ev_flags &= ~EV_EXPOSE;
 			redraw(&alt);
 		}
 		else {
 			ev_flags &= ~EV_EXPOSE;
 			if (mane.min_x < MAXDIM)
 				redraw(&mane);
 		}
 	}
 	else if (ev_flags & EV_CURSOR) {
 		/*
 		 * This code eliminates unnecessary calls to XDefineCursor,
 		 * since this is a slow operation on some hardware
 		 * (e.g., S3 chips).
 		 */
 		XSync(DISP, False);
 		if (!XtPending()) {
 			ev_flags &= ~EV_CURSOR;
 			if (!dragcurs)
 				XDefineCursor(DISP, CURSORWIN, ready_cursor);
 		}
 	}
 
 	XFlush(DISP);
 }