wdvi

special.c (28781B)

---

 /*========================================================================*\
 
 Copyright (c) 1990-2002  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 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:
 	This module is based on prior work as noted below.
 
 \*========================================================================*/
 
 /*
  * Support drawing routines for TeXsun and TeX
  *
  *      Copyright, (C) 1987, 1988 Tim Morgan, UC Irvine
  *	Adapted for xdvi by Jeffrey Lee, U. of Toronto
  *
  * At the time these routines are called, the values of hh and vv should
  * have been updated to the upper left corner of the graph (the position
  * the \special appears at in the dvi file).  Then the coordinates in the
  * graphics commands are in terms of a virtual page with axes oriented the
  * same as the Imagen and the SUN normally have:
  *
  *                      0,0
  *                       +-----------> +x
  *                       |
  *                       |
  *                       |
  *                      \ /
  *                       +y
  *
  * Angles are measured in the conventional way, from +x towards +y.
  * Unfortunately, that reverses the meaning of "counterclockwise"
  * from what it's normally thought of.
  *
  * A lot of floating point arithmetic has been converted to integer
  * arithmetic for speed.  In some places, this is kind-of kludgy, but
  * it's worth it.
  */
 
 #include <ctype.h>
 #include <err.h>
 #include <limits.h>	/* abs() */
 #include <math.h>	/* sqrt(), sin(), cos() */
 #include <stdlib.h>	/* abs() */
 #include <string.h>	/* memcmp() */
 
 #include "dvi-init.h"	/* page_info */
 #include "dvi-draw.h"	/* PXL_V, PXL_H */
 #include "events.h"	/* do_color_change() */
 #include "special.h"
 #include "xdvi.h"
 #include "util.h"	/* xmalloc() */
 
 #define	rint(x)	floor((x) + 0.5)
 
 
 #define	MAXPOINTS	300	/* Max points in a path */
 #define	MAX_PEN_SIZE	7	/* Max pixels of pen width */
 #define	TWOPI		(3.14159265359 * 2.0)
 
 
 static	int	xx[MAXPOINTS], yy[MAXPOINTS];	/* Path in milli-inches */
 static	int	path_len = 0;	/* # points in current path */
 static	int	pen_size = 1;	/* Pixel width of lines drawn */
 
 static	Boolean	whiten = False;
 static	Boolean	shade = False;
 static	Boolean	blacken = False;
 
 /* Unfortunately, these values also appear in dvisun.c */
 #define	xRESOLUTION	(pixels_per_inch/shrink_factor)
 #define	yRESOLUTION	(pixels_per_inch/shrink_factor)
 
 
 /*
  *	X drawing routines
  */
 
 #define	toint(x)	((int) ((x) + 0.5))
 #define	xconv(x)	(toint(tpic_conv*(x))/shrink_factor + PXL_H)
 #define	yconv(y)	(toint(tpic_conv*(y))/shrink_factor + PXL_V)
 
 /*
  *	Draw a line from (fx,fy) to (tx,ty).
  *	Right now, we ignore pen_size.
  */
 static	void
 line_btw(int fx, int fy, int tx, int ty)
 {
 	int	fcx = xconv(fx);
 	int	tcx = xconv(tx);
 	int	fcy = yconv(fy);
 	int	tcy = yconv(ty);
 
 	if ((fcx >= max_x && tcx >= max_x) || (fcx < min_x && tcx < min_x) ||
 	    (fcy >= max_y && tcy >= max_y) || (fcy < min_y && tcy < min_y))
 		return;
 	if (fg_active != fg_current)
 		do_color_change();
 
 	XDrawLine(DISP, currwin.win, ruleGC,
 	      fcx - currwin.base_x, fcy - currwin.base_y,
 	      tcx - currwin.base_x, tcy - currwin.base_y);
 }
 
 /*
  *	Draw a dot at (x,y)
  */
 static	void
 dot_at(int x, int y)
 {
 	int	cx = xconv(x);
 	int	cy = yconv(y);
 
 	if (cx >= max_x || cx < min_x || cy >= max_y || cy < min_y)
 		return;
 	if (fg_active != fg_current)
 		do_color_change();
 
 	XDrawPoint(DISP, currwin.win, ruleGC,
 	           cx - currwin.base_x, cy - currwin.base_y);
 }
 
 /*
  *	Apply the requested attributes to the last path (box) drawn.
  *	Attributes are reset.
  *	(Not currently implemented.)
  */
 
 static	void
 do_attribute_path(int last_min_x, int last_max_x, int last_min_y, int last_max_y)
 {
 }
 
 /*
  *	Set the size of the virtual pen used to draw in milli-inches
  */
 
 static	void
 set_pen_size(char *cp)
 {
 	int	ps;
 
 	if (sscanf(cp, " %d ", &ps) != 1) {
 		warnx("invalid .ps command format: %s", cp);
 		return;
 	}
 
 	pen_size = (ps * (xRESOLUTION + yRESOLUTION) + 1000) / 2000;
 	if (pen_size < 1)
 		pen_size = 1;
 	else if (pen_size > MAX_PEN_SIZE)
 		pen_size = MAX_PEN_SIZE;
 }
 
 
 /*
  *	Print the line defined by previous path commands
  */
 
 static	void
 flush_path(void)
 {
 	int	i;
 	int	last_min_x, last_max_x, last_min_y, last_max_y;
 
 	last_min_x = 30000;
 	last_min_y = 30000;
 	last_max_x = -30000;
 	last_max_y = -30000;
 	for (i = 1; i < path_len; i++) {
 	    if (xx[i] > last_max_x) last_max_x = xx[i];
 	    if (xx[i] < last_min_x) last_min_x = xx[i];
 	    if (yy[i] > last_max_y) last_max_y = yy[i];
 	    if (yy[i] < last_min_y) last_min_y = yy[i];
 	    line_btw(xx[i], yy[i], xx[i+1], yy[i+1]);
 	}
 	if (xx[path_len] > last_max_x) last_max_x = xx[path_len];
 	if (xx[path_len] < last_min_x) last_min_x = xx[path_len];
 	if (yy[path_len] > last_max_y) last_max_y = yy[path_len];
 	if (yy[path_len] < last_min_y) last_min_y = yy[path_len];
 	path_len = 0;
 	do_attribute_path(last_min_x, last_max_x, last_min_y, last_max_y);
 }
 
 
 /*
  *	Print a dashed line along the previously defined path, with
  *	the dashes/inch defined.
  */
 
 static	void
 flush_dashed(char *cp, Boolean dotted)
 {
 	int	i;
 	int	numdots;
 	int	lx0, ly0, lx1, ly1;
 	int	cx0, cy0, cx1, cy1;
 	float	inchesperdash;
 	double	d, spacesize, a, b, dx, dy, milliperdash;
 
 	if (sscanf(cp, " %f ", &inchesperdash) != 1) {
 	    warnx("invalid format for dotted/dashed line: %s", cp);
 	    return;
 	}
 	if (path_len <= 1 || inchesperdash <= 0.0) {
 	    warnx("invalid conditions for dotted/dashed line");
 	    return;
 	}
 	milliperdash = inchesperdash * 1000.0;
 	lx0 = xx[1];	ly0 = yy[1];
 	lx1 = xx[2];	ly1 = yy[2];
 	dx = lx1 - lx0;
 	dy = ly1 - ly0;
 	if (dotted) {
 	    numdots = sqrt(dx*dx + dy*dy) / milliperdash + 0.5;
 	    if (numdots == 0) numdots = 1;
 	    for (i = 0; i <= numdots; i++) {
 		a = (float) i / (float) numdots;
 		cx0 = lx0 + a * dx + 0.5;
 		cy0 = ly0 + a * dy + 0.5;
 		dot_at(cx0, cy0);
 	    }
 	}
 	else {
 	    d = sqrt(dx*dx + dy*dy);
 	    numdots = d / (2.0 * milliperdash) + 1.0;
 	    if (numdots <= 1)
 		line_btw(lx0, ly0, lx1, ly1);
 	    else {
 		spacesize = (d - numdots * milliperdash) / (numdots - 1);
 		for (i = 0; i < numdots - 1; i++) {
 		    a = i * (milliperdash + spacesize) / d;
 		    b = a + milliperdash / d;
 		    cx0 = lx0 + a * dx + 0.5;
 		    cy0 = ly0 + a * dy + 0.5;
 		    cx1 = lx0 + b * dx + 0.5;
 		    cy1 = ly0 + b * dy + 0.5;
 		    line_btw(cx0, cy0, cx1, cy1);
 		    b += spacesize / d;
 		}
 		cx0 = lx0 + b * dx + 0.5;
 		cy0 = ly0 + b * dy + 0.5;
 		line_btw(cx0, cy0, lx1, ly1);
 	    }
 	}
 	path_len = 0;
 }
 
 
 /*
  *	Add a point to the current path
  */
 
 static	void
 add_path(char *cp)
 {
 	int	pathx, pathy;
 
 	if (++path_len >= MAXPOINTS)
 		errx(1, "Too many points");
 	if (sscanf(cp, " %d %d ", &pathx, &pathy) != 2)
 		errx(1, "Malformed path command");
 	xx[path_len] = pathx;
 	yy[path_len] = pathy;
 }
 
 
 /*
  *	Draw to a floating point position
  */
 
 static void
 im_fdraw(double x, double y)
 {
 	if (++path_len >= MAXPOINTS)
 		errx(1, "Too many arc points");
 	xx[path_len] = x + 0.5;
 	yy[path_len] = y + 0.5;
 }
 
 
 /*
  *	Draw an ellipse with the indicated center and radices.
  */
 
 static	void
 draw_ellipse(int xc, int yc, int xr, int yr)
 {
 	double	angle, theta;
 	int	n;
 	int	px0, py0, px1, py1;
 
 	angle = (xr + yr) / 2.0;
 	theta = sqrt(1.0 / angle);
 	n = TWOPI / theta + 0.5;
 	if (n < 12) n = 12;
 	else if (n > 80) n = 80;
 	n /= 2;
 	theta = TWOPI / n;
 
 	angle = 0.0;
 	px0 = xc + xr;		/* cos(0) = 1 */
 	py0 = yc;		/* sin(0) = 0 */
 	while ((angle += theta) <= TWOPI) {
 	    px1 = xc + xr*cos(angle) + 0.5;
 	    py1 = yc + yr*sin(angle) + 0.5;
 	    line_btw(px0, py0, px1, py1);
 	    px0 = px1;
 	    py0 = py1;
 	}
 	line_btw(px0, py0, xc + xr, yc);
 }
 
 /*
  *	Draw an arc
  */
 
 static	void
 arc(char *cp, Boolean invis)
 {
 	int	xc, yc, xrad, yrad, n;
 	float	start_angle, end_angle, angle, theta, r;
 	double	xradius, yradius, xcenter, ycenter;
 
 	if (sscanf(cp, " %d %d %d %d %f %f ", &xc, &yc, &xrad, &yrad,
 		&start_angle, &end_angle) != 6) {
 	    warnx("invalid arc specification: %s", cp);
 	    return;
 	}
 
 	if (invis) return;
 
 	/* We have a specialized fast way to draw closed circles/ellipses */
 	if (start_angle <= 0.0 && end_angle >= 6.282) {
 	    draw_ellipse(xc, yc, xrad, yrad);
 	    return;
 	}
 	xcenter = xc;
 	ycenter = yc;
 	xradius = xrad;
 	yradius = yrad;
 	r = (xradius + yradius) / 2.0;
 	theta = sqrt(1.0 / r);
 	n = 0.3 * TWOPI / theta + 0.5;
 	if (n < 12) n = 12;
 	else if (n > 80) n = 80;
 	n /= 2;
 	theta = TWOPI / n;
 	flush_path();
 	im_fdraw(xcenter + xradius * cos(start_angle),
 	    ycenter + yradius * sin(start_angle));
 	angle = start_angle + theta;
 	if (end_angle < start_angle) end_angle += TWOPI;
 	while (angle < end_angle) {
 	    im_fdraw(xcenter + xradius * cos(angle),
 		ycenter + yradius * sin(angle));
 	    angle += theta;
 	}
 	im_fdraw(xcenter + xradius * cos(end_angle),
 	    ycenter + yradius * sin(end_angle));
 	flush_path();
 }
 
 
 /*
  *	APPROXIMATE integer distance between two points
  */
 
 #define	dist(x0, y0, x1, y1)	(abs(x0 - x1) + abs(y0 - y1))
 
 
 /*
  *	Draw a spline along the previously defined path
  */
 
 static	void
 flush_spline(void)
 {
 	int	xp, yp;
 	int	N;
 	int	lastx, lasty;
 	Boolean	lastvalid = False;
 	int	t1, t2, t3;
 	int	steps;
 	int	j;
 	int	i, w;
 
 	N = path_len + 1;
 	xx[0] = xx[1];
 	yy[0] = yy[1];
 	xx[N] = xx[N-1];
 	yy[N] = yy[N-1];
 	for (i = 0; i < N - 1; i++) {	/* interval */
 	    steps = (dist(xx[i], yy[i], xx[i+1], yy[i+1]) +
 		dist(xx[i+1], yy[i+1], xx[i+2], yy[i+2])) / 80;
 	    for (j = 0; j < steps; j++) {	/* points within */
 		w = (j * 1000 + 500) / steps;
 		t1 = w * w / 20;
 		w -= 500;
 		t2 = (750000 - w * w) / 10;
 		w -= 500;
 		t3 = w * w / 20;
 		xp = (t1*xx[i+2] + t2*xx[i+1] + t3*xx[i] + 50000) / 100000;
 		yp = (t1*yy[i+2] + t2*yy[i+1] + t3*yy[i] + 50000) / 100000;
 		if (lastvalid) line_btw(lastx, lasty, xp, yp);
 		lastx = xp;
 		lasty = yp;
 		lastvalid = True;
 	    }
 	}
 	path_len = 0;
 }
 
 
 /*
  *	Shade the last box, circle, or ellipse
  */
 
 static	void
 shade_last(void)
 {
 	blacken = whiten = False;
 	shade = True;
 }
 
 
 /*
  *	Make the last box, circle, or ellipse, white inside (shade with white)
  */
 
 static	void
 whiten_last(void)
 {
 	whiten = True;
 	blacken = shade = False;
 }
 
 
 /*
  *	Make last box, etc, black inside
  */
 
 static	void
 blacken_last(void)
 {
 	blacken = True;
 	whiten = shade = False;
 }
 
 
 void
 init_prescan(void)
 {
 	scanned_page = scanned_page_color = scanned_page_reset = -1;
 
 	if (!resource._use_color)
 	    scanned_page_color = total_pages + 1;
 }
 
 
 /*
  *	Table of dvips color names.  Produced by passing the table in
  *	dvipsk/color.lpro through the following perl script, and then
  *	sorting by most common colors.
  *
  *	#! /usr/bin/perl -w
  *	
  *	sub cvpart {
  *	    $val = $_[0] < 1.0 ? 1.0 - $_[0] : 0.0;
  *	    return int($val * 65535 + 0.5)
  *	}
  *	
  *	$pat = "^\\/(\\w+)\\s*\\{\\s*([0-9.]+)\\s*([0-9.]+)\\s*([0-9.]+)"
  *	  . "\\s*([0-9.]+)\\s*setcmykcolor\\s*\\}\\s*DC\\s*\$";
  *	while (<STDIN>) {
  *	    chop;
  *	    if (/^%%/) {next;}
  *	    if (/$pat/o) {
  *		printf "\t{ \"%s\",\t { %g, %g, %g } },\n",
  *		  $1, cvpart($2 + $5), cvpart($3 + $5), cvpart($4 + $5);
  *	    }
  *	    else {
  *		print "Bad line: ", $_, "\n";
  *	    }
  *	}
  */
 
 struct dvipscolor {
 	const char	*name;
 	struct rgb	color;
 } colornames[] = {
 	{ "Black",	 { 0, 0, 0 } },
 	{ "White",	 { 65535, 65535, 65535 } },
 	{ "Gray",	 { 32768, 32768, 32768 } },
 	{ "Red",	 { 65535, 0, 0 } },
 	{ "Green",	 { 0, 65535, 0 } },
 	{ "Blue",	 { 0, 0, 65535 } },
 	{ "Yellow",	 { 65535, 65535, 0 } },
 	{ "Cyan",	 { 0, 65535, 65535 } },
 	{ "Magenta",	 { 65535, 0, 65535 } },
 	{ "GreenYellow", { 55705, 65535, 20316 } },
 	{ "Goldenrod",	 { 65535, 58982, 10486 } },
 	{ "Dandelion",	 { 65535, 46530, 10486 } },
 	{ "Apricot",	 { 65535, 44564, 31457 } },
 	{ "Peach",	 { 65535, 32768, 19661 } },
 	{ "Melon",	 { 65535, 35389, 32768 } },
 	{ "YellowOrange", { 65535, 38010, 0 } },
 	{ "Orange",	 { 65535, 25559, 8520 } },
 	{ "BurntOrange", { 65535, 32112, 0 } },
 	{ "Bittersweet", { 49807, 655, 0 } },
 	{ "RedOrange",	 { 65535, 15073, 8520 } },
 	{ "Mahogany",	 { 42598, 0, 0 } },
 	{ "Maroon",	 { 44564, 0, 0 } },
 	{ "BrickRed",	 { 47185, 0, 0 } },
 	{ "OrangeRed",	 { 65535, 0, 32768 } },
 	{ "RubineRed",	 { 65535, 0, 57015 } },
 	{ "WildStrawberry", { 65535, 2621, 39976 } },
 	{ "Salmon",	 { 65535, 30801, 40632 } },
 	{ "CarnationPink", { 65535, 24248, 65535 } },
 	{ "VioletRed",	 { 65535, 12452, 65535 } },
 	{ "Rhodamine",	 { 65535, 11796, 65535 } },
 	{ "Mulberry",	 { 41942, 5243, 64224 } },
 	{ "RedViolet",	 { 38666, 0, 43253 } },
 	{ "Fuchsia",	 { 29491, 655, 60292 } },
 	{ "Lavender",	 { 65535, 34078, 65535 } },
 	{ "Thistle",	 { 57671, 26869, 65535 } },
 	{ "Orchid",	 { 44564, 23593, 65535 } },
 	{ "DarkOrchid",	 { 39321, 13107, 52428 } },
 	{ "Purple",	 { 36044, 9175, 65535 } },
 	{ "Plum",	 { 32768, 0, 65535 } },
 	{ "Violet",	 { 13762, 7864, 65535 } },
 	{ "RoyalPurple", { 16384, 6553, 65535 } },
 	{ "BlueViolet",	 { 6553, 3277, 62914 } },
 	{ "Periwinkle",	 { 28180, 29491, 65535 } },
 	{ "CadetBlue",	 { 24903, 28180, 50462 } },
 	{ "CornflowerBlue", { 22937, 57015, 65535 } },
 	{ "MidnightBlue", { 0, 28835, 37355 } },
 	{ "NavyBlue",	 { 3932, 30146, 65535 } },
 	{ "RoyalBlue",	 { 0, 32768, 65535 } },
 	{ "Cerulean",	 { 3932, 58326, 65535 } },
 	{ "ProcessBlue", { 2621, 65535, 65535 } },
 	{ "SkyBlue",	 { 24903, 65535, 57671 } },
 	{ "Turquoise",	 { 9830, 65535, 52428 } },
 	{ "TealBlue",	 { 7864, 64224, 41942 } },
 	{ "Aquamarine",	 { 11796, 65535, 45875 } },
 	{ "BlueGreen",	 { 9830, 65535, 43908 } },
 	{ "Emerald",	 { 0, 65535, 32768 } },
 	{ "JungleGreen", { 655, 65535, 31457 } },
 	{ "SeaGreen",	 { 20316, 65535, 32768 } },
 	{ "ForestGreen", { 0, 57671, 0 } },
 	{ "PineGreen",	 { 0, 49151, 10486 } },
 	{ "LimeGreen",	 { 32768, 65535, 0 } },
 	{ "YellowGreen", { 36700, 65535, 17039 } },
 	{ "SpringGreen", { 48496, 65535, 15728 } },
 	{ "OliveGreen",	 { 0, 39321, 0 } },
 	{ "RawSienna",	 { 36044, 0, 0 } },
 	{ "Sepia",	 { 19661, 0, 0 } },
 	{ "Brown",	 { 26214, 0, 0 } },
 	{ "Tan",	 { 56360, 38010, 28835 } },
 };
 
 static void
 reverse_color(struct rgb *rgbp)
 {
 	if (resource.reverse == False)
 		return;
 
 	rgbp->r = 65535 - rgbp->r;
 	rgbp->g = 65535 - rgbp->g;
 	rgbp->b = 65535 - rgbp->b;
 }
 
 static	Boolean
 parse_color(const char *cp0, const char *cp, struct rgb *rgbp)
 {
 	double		r, g, b;
 
 	while (*cp == ' ')
 		++cp;
 
 	if (strncasecmp(cp, "rgb ", 4) == 0) {
 	    if (sscanf(cp + 3, "%lf %lf %lf", &r, &g, &b) == 3
 	      && r >= 0 && r <= 1 && g >= 0 && g <= 1 && b >= 0 && b <= 1) {
 		rgbp->r = r * 65535 + 0.5;
 		rgbp->g = g * 65535 + 0.5;
 		rgbp->b = b * 65535 + 0.5;
 		reverse_color(rgbp);
 		return True;
 	    }
 	}
 	else if (strncasecmp(cp, "gray ", 5) == 0) {
 	    if (sscanf(cp + 4, "%lf", &r) == 1 && r >= 0 && r <= 1) {
 		rgbp->r = rgbp->g = rgbp->b = r * 65535 + 0.5;
 		reverse_color(rgbp);
 		return True;
 	    }
 	}
 	else if (strncasecmp(cp, "cmyk ", 5) == 0) {
 	    double k;
 
 	    if (sscanf(cp + 4, "%lf %lf %lf %lf", &r, &g, &b, &k) == 4
 	      && r >= 0 && r <= 1 && g >= 0 && g <= 1 && b >= 0 && b <= 1
 	      && k >= 0 && k <= 1) {
 		r = 1.0 - r - k;	/* cyan --> red */
 		rgbp->r = (r < 0 ? 0 : r * 65535 + 0.5);
 		g = 1.0 - g - k;	/* magenta --> green */
 		rgbp->g = (g < 0 ? 0 : g * 65535 + 0.5);
 		b = 1.0 - b - k;	/* yellow --> blue */
 		rgbp->b = (b < 0 ? 0 : b * 65535 + 0.5);
 		reverse_color(rgbp);
 		return True;
 	    }
 	}
 	else if (strncasecmp(cp, "hsb ", 4) == 0) {
 	    double hue, sat, bri;
 
 	    if (sscanf(cp + 3, "%lf %lf %lf", &hue, &sat, &bri) == 3 && hue >= 0
 	      && hue <= 1 && sat >= 0 && sat <= 1 && bri >= 0 && bri <= 1) {
 		int	h	= (int) (6 * hue);
 		double	p	= bri * (1 - sat);
 		double	q	= bri * (1 - sat * (6 * hue - h));
 		double	t	= p - q + bri;
 
 		switch (h) {
 		    case 0:  r = bri; g = t; b = p; break; /* Red - Yel */
 		    case 1:  r = q; g = bri; b = p; break; /* Yel - Grn */
 		    case 2:  r = p; g = bri; b = t; break; /* Grn - Cyn */
 		    case 3:  r = p; g = q; b = bri; break; /* Cyn - Blu */
 		    case 4:  r = t; g = p; b = bri; break; /* Blu - Mag */
 		    case 5:  r = bri; g = p; b = q; break; /* Mag - Red */
 		    case 6:  r = bri; g = b = p;    break; /* Red */
 		}
 		rgbp->r = r * 65535 + 0.5;
 		rgbp->g = g * 65535 + 0.5;
 		rgbp->b = b * 65535 + 0.5;
 		reverse_color(rgbp);
 		return True;
 	    }
 	}
 	else {
 		/* check table of dvips color names */
 		for (int i = 0; i < XtNumber(colornames); i++) {
 			if (strcmp(cp, colornames[i].name) != 0)
 				continue;
 
 			*rgbp = colornames[i].color;
 			reverse_color(rgbp);
 			return True;
 		}
 	}
 
 	if (cp0 != NULL)
 	    warnx("Invalid color name in special `%s'", cp0);
 
 	return False;
 }
 
 
 /*
  *	Color stack used when scanning.  These records stay around, to ease
  *	the burden on xmalloc().  The first entry is a dummy entry, giving
  *	the default foreground color (as modified).
  */
 
 struct colorframe {
 	struct colorframe	*next, *prev;
 	struct rgb		color;
 };
 
 static	struct colorframe	scanstack_head;
 static	int			scanstack_len;
 static	struct colorframe	*scanstack_current;
 
 static	void
 init_page_colors(void)
 {
 	int	i;
 
 	page_colors = xmalloc(total_pages * sizeof *page_colors);
 
 	for (i = 0; i <= scanned_page + 1; ++i) {
 	    page_colors[i].bg = bg_initial;	/* from command line */
 	    page_colors[i].colorstack = &fg_initial;
 	    page_colors[i].stacksize = 1;
 	}
 	while (i < total_pages)
 	    page_colors[i++].colorstack = NULL;
 
 	scanstack_head.color = fg_initial;
 	scanstack_len = 1;			/* nothing yet */
 	scanstack_current = &scanstack_head;	/* stack position */
 }
 
 
 static	void
 scan_bg_color(const char *cp)
 {
 	if (!resource._use_color)
 	    return;
 
 	if (page_colors == NULL)
 	    init_page_colors();
 
 	(void) parse_color(cp, cp + 11, &page_colors[scanned_page + 1].bg);
 }
 
 static	void
 scan_color(const char *cp)
 {
 	const char	*cp1 = cp + 6;
 
 	if (!resource._use_color)
 	    return;
 
 	while (*cp1 == ' ') ++cp1;
 
 	if (page_colors == NULL)
 	    init_page_colors();
 
 	if (strncasecmp(cp1, "push ", 5) == 0) {
 	    if (scanstack_current->next == NULL) {	/* if at end */
 		scanstack_current->next = xmalloc(sizeof *scanstack_current);
 		scanstack_current->next->prev = scanstack_current;
 		scanstack_current->next->next = NULL;
 	    }
 	    scanstack_current = scanstack_current->next;
 	    ++scanstack_len;
 	    if (!parse_color(cp, cp1 + 5, &scanstack_current->color))
 		scanstack_current->color = scanstack_current->prev->color;
 	}
 	else if (strncasecmp(cp1, "pop", 3) == 0) {
 	    if (scanstack_len <= 1) {
 		  warnx("Color pop occurred with empty color stack.");
 	    }
 	    else {
 		scanstack_current = scanstack_current->prev;
 		--scanstack_len;
 	    }
 	}
 	else {
 	    (void) parse_color(cp, cp1, &scanstack_head.color);
 	    if (scanstack_len > 1) {
 		struct colorframe	*cfp;
 
 		warnx("Global color change occurred with non-empty color stack"
 		    ";\ncoping by setting all stack entries to that color.");
 		for (cfp = scanstack_head.next;; cfp = cfp->next) {
 		    cfp->color = scanstack_head.color;
 		    if (cfp == scanstack_current) break;
 		}
 	    }
 	}
 }
 
 void
 scan_color_eop(void)
 {
 	int			i;
 	const struct rgb	*prev;
 	struct colorframe	*cf;
 	const struct rgb	*p1;
 	struct rgb		*rgbp;
 
 	if (page_colors == NULL)
 	    return;
 
 	/* set background color for next page */
 	if (scanned_page + 1 < total_pages)
 	    page_colors[scanned_page + 1].bg = page_colors[scanned_page].bg;
 
 	/* save the stack contents */
 	page_colors[scanned_page].stacksize = scanstack_len;
 
 	prev = &fg_initial;
 	i = 1;
 	if (scanned_page > 0) {
 	    prev = page_colors[scanned_page - 1].colorstack;
 	    i = page_colors[scanned_page - 1].stacksize;
 	}
 	if (scanstack_len <= i) {
 	    /* try to reuse the previous array */
 	    p1 = prev;
 	    cf = &scanstack_head;
 	    for (i = 0;;) {
 		if (p1->r != cf->color.r || p1->g != cf->color.g
 		  || p1->b != cf->color.b)
 		    break;
 		if (++i >= scanstack_len) {	/* end loop; reuse memory */
 		    page_colors[scanned_page].colorstack = prev;
 		    return;	/* done */
 		}
 		++p1;
 		cf = cf->next;
 	    }
 	}
 	page_colors[scanned_page].colorstack = rgbp
 	  = xmalloc(scanstack_len * sizeof *rgbp);
 	cf = &scanstack_head;
 	for (i = 0; i < scanstack_len; ++i) {
 	    *rgbp++ = cf->color;
 	    cf = cf->next;
 	}
 }
 
 
 /*
  *	Page stack when displaying.  Again, the records stay around once
  *	allocated.  Bottom entries in the stack (inherited from previous
  *	pages) are stored in an array instead (see comments in xdvi.h).
  */
 
 static	struct colorframe	*rcs_head;
 
 
 /*
  *	We don't actually do any X calls yet to change colors; that can wait
  *	until a character or rule needs to be drawn.
  */
 
 void
 set_fg_color(const struct rgb *color)
 {
 	struct fgrec	**fgpp;
 
 	if (fg_current != NULL &&
 	    color->r == fg_current->color.r &&
 	    color->g == fg_current->color.g &&
 	    color->b == fg_current->color.b)
 		return;
 
 	for (fgpp = &bg_current->fg_head;;) {
 		fg_current = *fgpp;
 		if (fg_current == NULL) {	/* if color is not in list */
 			fg_current = *fgpp = xmalloc(sizeof *fg_current);
 			fg_current->next = NULL;
 			fg_current->color = *color;
 			fg_current->pixel_good = False;
 			break;
 	    	}
 		if (fg_current->color.r == color->r &&
 		    fg_current->color.g == color->g &&
 		    fg_current->color.b == color->b)
 			break;
 		fgpp = &fg_current->next;
 	}
 	if (debug & DBG_DVI)
 		printf("Changing fg color to %5d %5d %5d\n",
 		       color->r, color->g, color->b);
 }
 
 static	void
 color_special(const char *cp)
 {
 	if (!resource._use_color)
 	    return;
 
 	while (*cp == ' ') ++cp;
 
 	if (strncasecmp(cp, "push ", 5) == 0) {
 	    if (rcs_top == NULL) {
 		if (rcs_head == NULL) {
 		    rcs_head = xmalloc(sizeof *rcs_head);
 		    rcs_head->prev = rcs_head->next = NULL;
 		}
 		rcs_top = rcs_head;
 	    }
 	    else {
 		struct colorframe *rcs_next;
 
 		rcs_next = rcs_top->next;
 		if (rcs_next == NULL) {
 		    rcs_next = rcs_top->next = xmalloc(sizeof *rcs_next);
 		    rcs_next->prev = rcs_top;
 		    rcs_next->next = NULL;
 		}
 		rcs_top = rcs_next;
 	    }
 	    if (!parse_color(NULL, cp + 5, &rcs_top->color)) {
 		if (rcs_top->prev != NULL)
 		    rcs_top->color = rcs_top->prev->color;
 		else
 		    rcs_top->color = color_bottom[color_bot_size - 1];
 	    }
 	    set_fg_color(&rcs_top->color);
 	}
 	else if (strncasecmp(cp, "pop", 3) == 0) {
 	    /* Pop stack */
 	    if (rcs_top != NULL) {
 		if (color_bot_size > 0)
 		    rcs_top = rcs_top->prev;
 		else return;
 	    }
 	    else if (color_bot_size > 1)
 		--color_bot_size;
 	    else {
 		if (scanned_page_reset >= 0) {
 		    /* turn on scanning and redraw the page */
 		    scanned_page =
 		      scanned_page_color = scanned_page_reset = -1;
 		    ev_flags |= EV_NEWPAGE;		/* force a redraw */
 		}
 		return;
 	    }
 
 	    set_fg_color(rcs_top != NULL ? &rcs_top->color
 		: &color_bottom[color_bot_size - 1]);
 	}
 	else {
 	    struct rgb color;
 
 	    if (!parse_color(NULL, cp, &color)) return;
 
 	    /* clear stack */
 	    if (rcs_head == NULL) {
 		rcs_head = xmalloc(sizeof *rcs_head);
 		rcs_head->prev = rcs_head->next = NULL;
 	    }
 	    rcs_top = rcs_head;
 	    color_bot_size = 0;
 
 	    /* Change top of stack */
 	    rcs_top->color = color;
 
 	    set_fg_color(&color);
 	}
 }
 
 
 static int
 atopix(const float val, const char unit[2])
 {
 	double		factor;
 
 #if A4
 	factor = 1.0 / 2.54;	/* cm */
 #else
 	factor = 1.0;		/* inches */
 #endif
 	switch (unit[0] << 8 | unit[1]) {
 #if A4
 		case 'i' << 8 | 'n':  factor = 1.0;			break;
 #else
 		case 'c' << 8 | 'm':  factor = 1.0 / 2.54;		break;
 #endif
 		case 'm' << 8 | 'm':  factor = 1.0 / 25.4;		break;
 		case 'p' << 8 | 't':  factor = 1.0 / 72.27;		break;
 		case 'p' << 8 | 'c':  factor = 12.0 / 72.27;		break;
 		case 'b' << 8 | 'p':  factor = 1.0 / 72.0;		break;
 		case 'd' << 8 | 'd':  factor = 1238.0 / 1157.0 / 72.27;	break;
 		case 'c' << 8 | 'c':  factor = 12 * 1238.0 / 1157.0 / 72.27;
 									break;
 		case 's' << 8 | 'p':  factor = 1.0 / 72.27 / 65536;	break;
 	}
 
 	return (int) (factor * val * pixels_per_inch + 0.5);
 }
 
 static	void
 scan_papersize(const char *cp)
 {
 	float		wf, hf;
 	char		wu[3], hu[3];
 	unsigned int	w, h;
 
 	if (sscanf(cp, "%f%2s,%f%2s", &wf, wu, &hf, hu) != 4) {
 		warnx("error parsing papersize special '%s'", cp);
 		return;
 	}
 
 	w = atopix(wf, wu);
 	h = atopix(hf, hu);
 
 	if (w == 0 || h == 0) {
 		warnx("invalid papersize special '%s'", cp);
 		return;
 	}
 
 	page_info[scanned_page + 1].pw = page_info[scanned_page + 1].ww = w;
 	page_info[scanned_page + 1].ph = page_info[scanned_page + 1].wh = h;
 }
 
 
 /*
  *	The following copyright message applies to the rest of this file.  --PV
  */
 
 /*
  *	This program is Copyright (C) 1987 by the Board of Trustees of the
  *	University of Illinois, and by the author Dirk Grunwald.
  *
  *	This program may be freely copied, as long as this copyright
  *	message remaines affixed. It may not be sold, although it may
  *	be distributed with other software which is sold. If the
  *	software is distributed, the source code must be made available.
  *
  *	No warranty, expressed or implied, is given with this software.
  *	It is presented in the hope that it will prove useful.
  *
  *	Hacked in ignorance and desperation by jonah@db.toronto.edu
  */
 
 /*
  *      The code to handle the \specials generated by tpic was modified
  *      by Dirk Grunwald using the code Tim Morgan at Univ. of Calif, Irvine
  *      wrote for TeXsun.
  */
 
 static	char *
 endofcommand(char *cp)
 {
 	while (isspace(*cp))
 		++cp;
 	if (*cp != '=')
 		return NULL;
 	do 
 		++cp;
 	while (isspace(*cp));
 
 	return cp;
 }
 
 void
 applicationDoSpecial(char *cp)
 {
 	if (debug & DBG_DVI)
 		printf("          `%s'\n", cp);
 
 	/* Skip white space */
 	while (isspace(*cp)) ++cp;
 
 	/* Ignore initial "xdvi:" */
 	if (memcmp(cp, "xdvi:", 5) == 0) {
 		cp += 5;
 		while (isspace(*cp))
 			++cp;
 	}
 
 	if (strncasecmp(cp, "color ", 6) == 0) {
 		color_special(cp + 6);
 		return;
 	}
 
 	/* these should have been scanned */
 
 	if (*cp == '!' ||
 	    (strncasecmp(cp, "header", 6) == 0 && endofcommand(cp + 6) != NULL)) {
 		return;
 	}
 
 	if (strncasecmp(cp, "background ", 11) == 0) {
 		if (resource._use_color && scanned_page_reset >= 0) {
 			/* turn on scanning and redraw the page */
 			scanned_page = scanned_page_color =
 			    scanned_page_reset = -1;
 			ev_flags |= EV_NEWPAGE;		/* force a redraw */
 		}
 		return;
 	}
 
 	if (memcmp(cp, "papersize", 9) == 0 && endofcommand(cp + 9) != NULL) {
 		if (scanned_page_reset >= 0) {
 			/* turn on scanning and redraw the page */
 			scanned_page = scanned_page_color =
 			    scanned_page_reset = -1;
 			ev_flags |= EV_NEWPAGE;		/* force a redraw */
 		}
 		return;
 	}
 
 	/* tpic specials */
 
 	if (*cp >= 'a' && *cp <= 'z' && cp[1] >= 'a' && cp[1] <= 'z' &&
 		(isspace(cp[2]) || cp[2] == '\0')) {
 
 #define	CMD(x, y)	((x) << 8 | (y))
 	    switch (CMD(*cp, cp[1])) {
 		case CMD('p','n'): set_pen_size(cp + 2); return;
 		case CMD('f','p'): flush_path(); return;
 		case CMD('d','a'): flush_dashed(cp + 2, False); return;
 		case CMD('d','t'): flush_dashed(cp + 2, True); return;
 		case CMD('p','a'): add_path(cp + 2); return;
 		case CMD('a','r'): arc(cp + 2, False); return;
 		case CMD('i','a'): arc(cp + 2, True); return;
 		case CMD('s','p'): flush_spline(); return;
 		case CMD('s','h'): shade_last(); return;
 		case CMD('w','h'): whiten_last(); return;
 		case CMD('b','k'): blacken_last(); return;
 		case CMD('i','p'): /* throw away the path -- jansteen */
 		    path_len = 0; return;
 	    }
 #undef	CMD
 	}
 
 	/* We support hypertex */
 	if (strncasecmp(cp, "html: ", 5) == 0)
 		return;
 
 	warnx("special '%s' not implemented", cp);
 }
 
 
 void
 scan_special(char *cp)
 {
 	char	*p;
 
 	if (debug & DBG_PS)
 		printf("Scanning special `%s'.\n", cp);
 
 	/* Skip white space */
 	while (isspace(*cp)) ++cp;
 
 	/* Ignore initial "xdvi:" */
 	if (memcmp(cp, "xdvi:", 5) == 0) {
 		cp += 5;
 		while (isspace(*cp)) ++cp;
 	}
 
 	if (strncasecmp(cp, "background ", 11) == 0) {
 		scan_bg_color(cp);
 		return;
 	}
 	else if (strncasecmp(cp, "color ", 6) == 0) {
 		scan_color(cp);
 		return;
 	}
 
 	if (memcmp(cp, "papersize", 9) == 0 &&
 	    (p = endofcommand(cp + 9)) != NULL) {
 		scan_papersize(p);
 		return;
 	}
 }