/*		DATA.C		11/17/86 - 3/30/87	J. Grant	*/

#include "portab.h"
#include "vdidef.alw"
#include "vdiext.alw"
#include "vdifunc.alw"

GLOBAL	BOOLEAN		abort;
GLOBAL	BOOLEAN		flip_y;
GLOBAL	BOOLEAN		g_endpre;
GLOBAL	BOOLEAN		g_fontset;
GLOBAL	BOOLEAN		g_fstimg;
GLOBAL	BOOLEAN		g_outeof;
GLOBAL	BOOLEAN		pending;

GLOBAL	WORD		dev_color;
GLOBAL	WORD		dev_t_color;
GLOBAL	WORD		dev_t_face;
GLOBAL	WORD		dev_t_h_align;
GLOBAL	WORD		dev_t_rotation;
GLOBAL	WORD		dev_t_xscale;
GLOBAL	WORD		dev_t_yscale;
GLOBAL	WORD		dev_t_under;
GLOBAL	WORD		dev_t_v_align;
GLOBAL	WORD		d_clip;
GLOBAL	WORD		g_copies = 0;
GLOBAL	WORD		g_ffmax = 0;
GLOBAL	WORD		g_fftype;
GLOBAL	WORD		g_maxface = 0;
GLOBAL	WORD		g_mode = MD_REPLACE;
GLOBAL	WORD		g_orient = 0;
GLOBAL	WORD		g_pages = 0;
GLOBAL	WORD		g_squeez = 0;
GLOBAL	WORD		g_tray = 0;
GLOBAL	WORD		g_x1clip;
GLOBAL	WORD		g_x2clip;
GLOBAL	WORD		g_y1clip;
GLOBAL	WORD		g_y2clip;
GLOBAL	WORD		high_x;
GLOBAL	WORD		high_y;
GLOBAL	WORD		low_x;
GLOBAL	WORD		low_y;
GLOBAL	WORD		marg_xl;
GLOBAL	WORD		marg_xr;
GLOBAL	WORD		marg_yt;
GLOBAL	WORD		marg_yb;
GLOBAL	WORD		y_max;

GLOBAL	WORD		contrl[CONTRL_SIZE];
GLOBAL	WORD		cur_attr[24];
GLOBAL	WORD		intin[INTIN_SIZE];
GLOBAL	WORD		intout[INTOUT_SIZE];
GLOBAL	WORD		ptsin[PTSIN_SIZE];
GLOBAL	WORD		ptsout[PTSOUT_SIZE];

GLOBAL	BOOLEAN		pat_down[NUM_PATTERNS];

GLOBAL	BYTE		filbuf[FILBUF_SIZE];
GLOBAL	BYTE		g_dta[44];
GLOBAL	BYTE		g_fnames[FFNAME_SIZE];
GLOBAL	BYTE		g_psfont[66];

GLOBAL	BYTE		attr_index[] =
{
	L_COLOR,	/* 17	Set polyline color index.	*/
	M_TYPE,		/* 18	Set polymarker type.		*/
	M_HEIGHT,	/* 19	Set polymarker height.		*/
	M_COLOR,	/* 20	Set polymarker color index.	*/
	T_FACE,		/* 21	Set text face.			*/
	T_COLOR,	/* 22	Set text color index.		*/
	F_INTERIOR,	/* 23	Set fill interior style.	*/
	F_STYLE,	/* 24	Set fill style index.		*/
	F_COLOR		/* 25	Set fill color index.		*/
};

GLOBAL	BYTE		p0[] =	/* Device fill 0 -- brick: */
{
	0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80,
	0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0xff, 0xff,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xff, 0xff
};

GLOBAL	BYTE		p1[] =	/* Device fill 1 -- diagonal brick: */
{
	0x02, 0x00, 0x01, 0x00, 0x00, 0x80, 0x00, 0x40,
	0x00, 0x20, 0x00, 0x50, 0x00, 0x88, 0x01, 0x04,
	0x02, 0x02, 0x04, 0x01, 0x88, 0x00, 0x50, 0x00,
	0x20, 0x00, 0x10, 0x00, 0x08, 0x00, 0x04, 0x00
};

GLOBAL	BYTE		p2[] =	/* Device fill 2 -- grass: */
{
	0x10, 0x10, 0x20, 0x08, 0x40, 0x04, 0x80, 0x02,
	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x10, 0x10, 0x08, 0x20, 0x04, 0x40, 0x02, 0x80,
	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

GLOBAL	BYTE		p3[] =	/* Device fill 3 -- dithered circles: */
{
	0x0c, 0x30, 0x18, 0x18, 0x30, 0x0c, 0x61, 0x86,
	0x30, 0x0c, 0x18, 0x18, 0x0c, 0x30, 0x06, 0x60,
	0x0c, 0x30, 0x18, 0x18, 0x30, 0x0c, 0x61, 0x86,
	0x30, 0x0c, 0x18, 0x18, 0x0c, 0x30, 0x06, 0x60
};

GLOBAL	BYTE		p4[] =	/* Device fill 4 -- dashed x's: */
{
	0x18, 0x00, 0x0c, 0x00, 0x04, 0x00, 0x00, 0x00,
	0x00, 0x04, 0x00, 0x0c, 0x00, 0x18, 0x00, 0x30,
	0x00, 0x60, 0x00, 0xc0, 0x00, 0x80, 0x00, 0x00,
	0x80, 0x00, 0xc0, 0x00, 0x60, 0x00, 0x30, 0x00
};

GLOBAL	BYTE		p5[] =	/* Device fill 5 -- cobble stone: */
{
	0xc0, 0x71, 0xc0, 0x01, 0x01, 0xe0, 0x01, 0xe0,
	0x01, 0xe0, 0xe0, 0x01, 0xe0, 0x01, 0xe3, 0xc1,
	0x03, 0xc0, 0x03, 0xc0, 0x00, 0x0f, 0x1c, 0x0f,
	0x1c, 0x0f, 0x1c, 0x00, 0x00, 0x70, 0xc0, 0x71
};

GLOBAL	BYTE		p6[] =	/* Device fill 6 -- sand: */
{
	0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x02, 0x00,
	0x00, 0x00, 0x40, 0x00, 0x00, 0x08, 0x01, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01
};

GLOBAL	BYTE		p7[] =	/* Device fill 7 -- rough weave: */
{
	0x00, 0x21, 0x00, 0x21, 0x00, 0x21, 0xff, 0xe1,
	0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xff, 0xe1, 0xff,
	0x21, 0x00, 0x21, 0x00, 0x21, 0x00, 0xe1, 0xff,
	0xe1, 0xe1, 0xe1, 0xe1, 0xff, 0xe1, 0xff, 0xe1
};

GLOBAL	BYTE		p8[] =	/* Device fill 8 -- quilt: */
{
	0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xc1,
	0x60, 0x03, 0x30, 0x06, 0x18, 0x0c, 0x0c, 0x18,
	0x06, 0x30, 0x03, 0x60, 0xc1, 0xc0, 0xc0, 0x80,
	0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc
};

GLOBAL	BYTE		p9[] =	/* Device fill 9 -- patterned cross: */
{
	0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0,
	0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0,
	0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc,
	0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0
};

GLOBAL	BYTE		p10[] =	/* Device fill 10 -- large balls: */
{
	0xff, 0xff, 0xfe, 0xbf, 0xfb, 0x0f, 0xea, 0x07,
	0xec, 0x03, 0xd8, 0x03, 0xd8, 0x01, 0xb8, 0x01,
	0xb8, 0x01, 0xf8, 0x03, 0xec, 0x07, 0xf4, 0x07,
	0xf8, 0x0f, 0xfc, 0x3f, 0xff, 0xff, 0xff, 0xff
};

GLOBAL	BYTE		p11[] =	/* Device fill 11 -- arches: */
{
	0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00,
	0x0c, 0x00, 0x1e, 0x00, 0x3f, 0x00, 0xff, 0xc0,
	0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
	0x00, 0x0c, 0x00, 0x1e, 0x00, 0x3f, 0xc0, 0xff
};

GLOBAL	BYTE		p12[] =	/* Device fill 12 -- rev. vid. balls: */
{
	0x3f, 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x3f, 0x00,
	0x3f, 0x38, 0x3f, 0x38, 0x40, 0x80, 0x80, 0x40,
	0x00, 0x3f, 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x3f,
	0x38, 0x3f, 0x38, 0x3f, 0x80, 0x40, 0x40, 0x80
};

GLOBAL	BYTE		p13[] =	/* Device fill 13 -- checkerboard: */
{
	0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
	0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
	0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00,
	0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00
};

GLOBAL	BYTE		p14[] =	/* Device fill 14 -- filled diamond: */
{
	0x00, 0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0,
	0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
	0xff, 0xff, 0x7f, 0xff, 0x3f, 0xfe, 0x1f, 0xfc,
	0x0f, 0xf8, 0x07, 0xf0, 0x03, 0xe0, 0x01, 0xc0
};

GLOBAL	BYTE		p15[] =	/* Device fill 15 -- herringbone: */
{
	0xff, 0xff, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08,
	0x10, 0x10, 0x20, 0x20, 0x40, 0x40, 0x80, 0x80,
	0xff, 0xff, 0x40, 0x40, 0x20, 0x20, 0x10, 0x10,
	0x08, 0x08, 0x04, 0x04, 0x02, 0x02, 0x01, 0x01
};

GLOBAL	BYTE		p16[] =	/* Device fill 16 -- narrow spaced +45: */
{
	0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x08,
	0x04, 0x04, 0x02, 0x02, 0x01, 0x01, 0x80, 0x80,
	0x40, 0x40, 0x20, 0x20, 0x10, 0x10, 0x08, 0x08,
	0x04, 0x04, 0x02, 0x02, 0x01, 0x01, 0x80, 0x80
};

GLOBAL	BYTE		p17[] =	/* Device fill 17 -- medium thick +45: */
{
	0xc0, 0xc0, 0x60, 0x60, 0x30, 0x30, 0x18, 0x18,
	0x0c, 0x0c, 0x06, 0x06, 0x03, 0x03, 0x81, 0x81,
	0xc0, 0xc0, 0x60, 0x60, 0x30, 0x30, 0x18, 0x18,
	0x0c, 0x0c, 0x06, 0x06, 0x03, 0x03, 0x81, 0x81
};

GLOBAL	BYTE		p18[] =	/* Device fill 18 -- medium spaced +-45: */
{
	0x01, 0x80, 0x02, 0x40, 0x04, 0x20, 0x08, 0x10,
	0x10, 0x08, 0x20, 0x04, 0x40, 0x02, 0x80, 0x01,
	0x80, 0x01, 0x40, 0x02, 0x20, 0x04, 0x10, 0x08,
	0x08, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01, 0x80
};

GLOBAL	BYTE		p19[] =	/* Device fill 19 -- medium vertical: */
{
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80
};

GLOBAL	BYTE		p20[] =	/* Device fill 20 -- medium horizontal: */
{
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
};

GLOBAL	BYTE		p21[] =	/* Device fill 21 -- medium spaced cross: */
{
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff
};

GLOBAL	BYTE		p22[] =	/* Device fill 22 -- widely spaced +45: */
{
	0x40, 0x00, 0x20, 0x00, 0x10, 0x00, 0x08, 0x00,
	0x04, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x80,
	0x00, 0x40, 0x00, 0x20, 0x00, 0x10, 0x00, 0x08,
	0x00, 0x04, 0x00, 0x02, 0x00, 0x01, 0x80, 0x00
};

GLOBAL	BYTE		p23[] =	/* Device fill 23 -- widely thick +45: */
{
	0xc0, 0x01, 0xe0, 0x00, 0x70, 0x00, 0x38, 0x00,
	0x1c, 0x00, 0x0e, 0x00, 0x07, 0x00, 0x03, 0x80,
	0x01, 0xc0, 0x00, 0xe0, 0x00, 0x70, 0x00, 0x38,
	0x00, 0x1c, 0x00, 0x0e, 0x00, 0x07, 0x80, 0x03
};

GLOBAL	BYTE		p24[] =	/* Device fill 24 -- widely spaced +-45: */
{
	0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0x08, 0x08,
	0x04, 0x10, 0x02, 0x20, 0x01, 0x40, 0x00, 0x80,
	0x01, 0x40, 0x02, 0x20, 0x04, 0x10, 0x08, 0x08,
	0x10, 0x04, 0x20, 0x02, 0x40, 0x01, 0x80, 0x00
};

GLOBAL	BYTE		p25[] =	/* Device fill 25 -- widely vertical: */
{
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00
};

GLOBAL	BYTE		p26[] =	/* Device fill 26 -- widely horizontal: */
{
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
};

GLOBAL	BYTE		p27[] =	/* Device fill 27 -- widely spaced cross: */
{
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00,
	0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xff, 0xff
};

GLOBAL	BYTE		user_fill[] =	/* User-defined device fill: */
{
	0x00, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x20, 0x04,
	0x20, 0x04, 0x2e, 0x74, 0x2e, 0x54, 0x2e, 0x54,
	0x2e, 0x54, 0x2e, 0x54, 0x2e, 0x74, 0x20, 0x04,
	0x20, 0x04, 0x3f, 0xfc, 0x00, 0x00, 0x00, 0x00
};

GLOBAL	BYTE		user_line[24] =
{
	"[]"		/* User-defined. */
};

GLOBAL	WORD		dev_tab[] =
{
	XS_LETTER,	/* 0	x resolution				*/
	YS_LETTER,	/* 1	y resolution				*/
	1,		/* 2	precisely scaled image			*/
	85,		/* 3	width of pixel				*/
	85,		/* 4	height of pixel 			*/
	0,		/* 5	continuous character scaling		*/
	MAX_L_STYLE,	/* 6	line styles				*/
	MAX_L_WIDTH,	/* 7	line widths				*/
	MAX_M_TYPE,	/* 8	marker types				*/
	0,		/* 9 	marker sizes				*/
	9,		/* 10	text fonts 				*/
	MAX_F_STYLE,	/* 11	area patterns				*/
	12,		/* 12	crosshatch patterns			*/
	2,		/* 13	colors at one time			*/
	11,		/* 14	number of GDP's				*/
	1,		/* 15	GDP bar					*/
	2,		/* 16	GDP arc					*/
	3,		/* 17	GDP pie					*/
	4,		/* 18	GDP circle				*/
	5,		/* 19	GDP ellipse				*/
	6,		/* 20	GDP elliptical arc			*/
	7,		/* 21	GDP elliptical pie			*/
	8,		/* 22	GDP rounded rectangle			*/
	9,		/* 23	GDP filled rounded rectangle		*/
	10,		/* 24	GDP justified text			*/
	3,		/* 25	GDP #1					*/
	0,		/* 26	GDP #2					*/
	3,		/* 27	GDP #3					*/
	3,		/* 28	GDP #4					*/
	3,		/* 29	GDP #5					*/
	0,		/* 30	GDP #6					*/
	3,		/* 31	GDP #7					*/
	0,		/* 32	GDP #8					*/
	3,		/* 33	GDP #9					*/
	2,		/* 34	GDP #10					*/
	0,		/* 35	monochrome				*/
	1,		/* 36	text rotation possible			*/
	1,		/* 37	filled areas possible			*/
	0,		/* 38	cell arrays no possible			*/
	2,		/* 39	palette size				*/
	0,		/* 40	no locator devices			*/
	0,		/* 41	no valuator devices			*/
	0,		/* 42	no choice devices			*/
	0,		/* 43	no string devices			*/
	-1		/* 44	landscape output handled by workstation	*/
};

GLOBAL	WORD		inq_pts[] =
{
	99,	/* 0	clipping rectangle upper left x (TBD)	*/
	99,	/* 1	clipping rectangle upper left y (TBD)	*/
	99,	/* 2	clipping rectangle lower right x (TBD)	*/
	99,	/* 3	clipping rectangle lower right y (TBD)	*/
	0, 0, 0, 0, 0, 0, 0, 0	/* spares			*/
};

GLOBAL	WORD		inq_tab[] =
{
	0,	/* 0	not screen				*/
	1,	/* 1	number of background colors		*/
	0xf,	/* 2	text effects supported (mask)		*/
	0,	/* 3	scaling rasters not possible		*/
	1,	/* 4	number of planes			*/
	0,	/* 5	no video lookup table			*/
	99,	/* 6	performance factor			*/
	0,	/* 7	contour fill not possible		*/
	2,	/* 8	arbitrary character rotations		*/
	1,	/* 9	only one writing mode			*/
	0,	/* 10	no input modes				*/
	1,	/* 11	text alignment possible			*/
	0,	/* 12	no inking possible			*/
	0,	/* 13	no rubber banding possible		*/
	PTSIN_SIZE/2 - 1,	/* 14	maximum vertices	*/
	INTIN_SIZE,		/* 15	maximum intin size	*/
	0,	/* 16	no mouse buttons			*/
	1,	/* 17	no styles for wide lines		*/
	0,	/* 18	no writing modes for wide lines		*/
	0,	/* 19	clipping flag				*/
	2,	/* 20	extended dot size units			*/
			/* 0 => not applicable			*/
			/* 1 => 1/10 microns			*/
			/* 2 => 1/100 microns			*/
			/* 3 => 1/1000 microns			*/
	8467,	/* 21	x dot size in [20] units		*/
	8467,	/* 22	y dot size in [20] units		*/
	300,	/* 23	x dots per inch				*/
	300,	/* 24	y dots per inch				*/
	1,	/* 25 	bit image capabilities flag		*/
			/* 0 => not applicable			*/
			/* 1 => 0,90,180,270 degree rotation	*/
	0,	/* 26   LSW off screen memory			*/
	0,	/* 27   MSW off screen memory			*/
	1,	/* 28 Capabilities flags			*/
			/* bit 0 = native hardcopy support	*/
			/* bit 1 : bit 15 = unused, must be 0	*/
	0, 0, 0, 0, 0, 0, 0, 0, 0,		/* spares	*/
	0, 0, 0, 0, 0, 0, 0			/* spares	*/
};

GLOBAL	WORD		siz_tab[] =
{
	4,		/* 0	minimum char width			*/
	4,		/* 1	minimum char height			*/
	300,		/* 2	maximum char width			*/
	300,		/* 3	maximum char height			*/
	1,		/* 4	minimum line width			*/
	0,		/* 5	-- not used				*/
	MAX_L_WIDTH,	/* 6	maximum line width			*/
	0,		/* 7	-- not used				*/
	MIN_M_HEIGHT,	/* 8	minimum marker width			*/
	MIN_M_HEIGHT,	/* 9	minimum marker height			*/
	MAX_M_HEIGHT,	/* 10	maximum marker width			*/
	MAX_M_HEIGHT	/* 11	maximum marker height			*/
};

GLOBAL	WORD		page_tab[][2] =
{
	XS_LETTER, YS_LETTER,	/* 0:  letter		*/
	XS_HALF, YS_HALF,	/* 1:  -> half		*/
	XS_HALF, YS_HALF,	/* 2:  -> half		*/
	XS_HALF, YS_HALF,	/* 3:  -> half		*/
	XS_HALF, YS_HALF,	/* 4:  -> half		*/
	XS_HALF, YS_HALF,	/* 5:  half		*/
	XS_B5, YS_B5,		/* 6:  -> B5		*/
	XS_B5, YS_B5,		/* 7:  -> B5		*/
	XS_B5, YS_B5,		/* 8:  -> B5		*/
	XS_B5, YS_B5,		/* 9:  -> B5		*/
	XS_B5, YS_B5,		/* 10: B5		*/
	XS_LETTER, YS_LETTER,	/* 11: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 12: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 13: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 14: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 15: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 16: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 17: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 18: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 19: -> letter	*/
	XS_LETTER, YS_LETTER,	/* 20: letter		*/
	XS_A4, YS_A4,		/* 21: -> A4		*/
	XS_A4, YS_A4,		/* 22: -> A4		*/
	XS_A4, YS_A4,		/* 23: -> A4		*/
	XS_A4, YS_A4,		/* 24: -> A4		*/
	XS_A4, YS_A4,		/* 25: -> A4		*/
	XS_A4, YS_A4,		/* 26: -> A4		*/
	XS_A4, YS_A4,		/* 27: -> A4		*/
	XS_A4, YS_A4,		/* 28: -> A4		*/
	XS_A4, YS_A4,		/* 29: -> A4		*/
	XS_A4, YS_A4,		/* 30: A4		*/
	XS_LEGAL, YS_LEGAL,	/* 31: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 32: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 33: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 34: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 35: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 36: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 37: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 38: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 39: -> legal		*/
	XS_LEGAL, YS_LEGAL,	/* 40: legal		*/
	XS_DOUBLE, YS_DOUBLE,	/* 41: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 42: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 43: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 44: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 45: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 46: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 47: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 48: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 49: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 50: double		*/
	XS_DOUBLE, YS_DOUBLE,	/* 51: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 52: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 53: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 54: -> double	*/
	XS_BROAD, YS_BROAD,	/* 55: -> broadsheet	*/
	XS_DOUBLE, YS_DOUBLE,	/* 56: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 57: -> double	*/
	XS_DOUBLE, YS_DOUBLE,	/* 58: -> double	*/
	XS_DOUBLE, YS_DOUBLE	/* 59: -> double	*/
};

GLOBAL	BYTE		*line_types[] =
{
	"[]",			/* Solid line. */
	"[12 4]",		/* Long dash. */
	"[3 5]",		/* Dot. */
	"[7 3 3 3]",		/* Dash, dot. */
	"[8]",			/* Dash. */
	"[4 3 2 2 2 3]",	/* Dash, dot, dot. */
	user_line		/* User-defined. */
};

GLOBAL	BYTE		*pat_def[] =
{
	p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
	p10, p11, p12, p13, p14, p15, p16, p17, p18, p19,
	p20, p21, p22, p23, p24, p25, p26, p27,
	user_fill
};

GLOBAL	VOID		(*low_table[])() =
{
	/*  0 */	nop,		/*  1 */	open_wk,
	/*  2 */	close_wk,	/*  3 */	clear_wk,
	/*  4 */	update_wk,	/*  5 */	escape,
	/*  6 */	polyline,	/*  7 */	polymarker,
	/*  8 */	text,		/*  9 */	fill_area,
	/* 10 */	nop,		/* 11 */	gdp,
	/* 12 */	t_height,	/* 13 */	t_rotation,
	/* 14 */	nop,		/* 15 */	l_type,
	/* 16 */	l_width,	/* 17 */	l_color,
	/* 18 */	m_type,		/* 19 */	m_height,
	/* 20 */	m_color,	/* 21 */	t_face,
	/* 22 */	t_color,	/* 23 */	f_interior,
	/* 24 */	f_style,	/* 25 */	f_color,
	/* 26 */	nop,		/* 27 */	nop,
	/* 28 */	nop,		/* 29 */	nop,
	/* 30 */	nop,		/* 31 */	nop,
	/* 32 */	w_mode,		/* 33 */	nop,
	/* 34 */	nop,		/* 35 */	nop,
	/* 36 */	nop,		/* 37 */	nop,
	/* 38 */	nop,		/* 39 */	t_alignment
};

GLOBAL	VOID		(*high_table[])() =
{
	/* 100 */	nop,		/* 101 */	nop,
	/* 102 */	q_extended,	/* 103 */	nop,
	/* 104 */	f_perimeter,	/* 105 */	nop,
	/* 106 */	t_effects,	/* 107 */	t_point,
	/* 108 */	l_end_styles,	/* 109 */	nop,
	/* 110 */	nop,		/* 111 */	nop,
	/* 112 */	f_ud_pattern,	/* 113 */	l_ud_style,
	/* 114 */	f_rectangle,	/* 115 */	nop,
	/* 116 */	nop,		/* 117 */	nop,
	/* 118 */	nop,		/* 119 */	load_fonts,
	/* 120 */	nop,		/* 121 */	nop,
	/* 122 */	nop,		/* 123 */	nop,
	/* 124 */	nop,		/* 125 */	nop,
	/* 126 */	nop,		/* 127 */	nop,
	/* 128 */	nop,		/* 129 */	clip,
	/* 130 */	vqt_name	/* 131 */
};

GLOBAL	IMAGEDEF	image;		/* Bit image information. */
GLOBAL	FONTMAP		font_map[256];