[mup] / mup / mupdisp / dos.c


/* Copyright (c) 1995, 1998 by Arkkra Enterprises */
/* All rights reserved */

/* Functions for displaying Mup/Ghostscript output on screen using
 * Watcom C */

#ifdef __WATCOMC__
#include "mupdisp.h"
#include <graph.h>
#include <stdlib.h>
#include <malloc.h>
#include <stdio.h>
#include <conio.h>
#include <fcntl.h>
#include <io.h>

/* hard code X and Y sizes for the moment */
#define XSIZE		640
#define YSIZE		480

/* image to be calloc'ed has 6 header bytes, then each row consecutively */
#define BITS2BYTES(bits)	(((bits) + 7) / 8)	/* round upwards */
#define SIZEIMAGE	(6 + ((long)BITS2BYTES(XSIZE)*4) * (long)YSIZE)
static char *Image;

static void zapblock P((char *area, long size));
\f

/* initialize graphics driver, etc */

void
dos_setup()

{
	struct videoconfig vidinfo;


	/* initalize best graphics mode */
	if (_setvideomode(_VRES16COLOR) == 0) {
		fprintf(stderr, "can't set graphics mode\n");
		generalcleanup(1);
	}

	_getvideoconfig(&vidinfo);

	if (vidinfo.numxpixels != XSIZE || vidinfo.numypixels != YSIZE) {
		_setvideomode(_DEFAULTMODE);
		fprintf(stderr, "video mode %dx%d not supported\n",
				vidinfo.numxpixels, vidinfo.numypixels);
		generalcleanup(0);
	}

	/*
	 * Allocate the image buffer.  Note that both parameters must be less
	 * than 65536, but the total size (product) can be greater.  The +1
	 * is to allow room for the header bytes (and then some).
	 */
	Image = (char *)calloc(BITS2BYTES(YSIZE)*4 + 1, XSIZE);
	if (Image == NULL) {
		_setvideomode(_DEFAULTMODE);
		fprintf(stderr, "can't allocate image buffer\n");
		generalcleanup(0);
	}

	/* set aspect ratio adjust */
	Conf_info_p->adjust = 1.375 * (double) vidinfo.numypixels
					/ (double) vidinfo.numxpixels;
	Conf_info_p->vlines = vidinfo.numypixels;

	/* set screen to all white */
	_setbkcolor(_BRIGHTWHITE);
	_clearscreen(_GCLEARSCREEN);
}
\f

/* before exiting, clean up graphics, then call the general cleanup routine */

void
dos_cleanup(int status)
{
	 _setvideomode(_DEFAULTMODE);
	 generalcleanup(status);
}
\f

/* draw a screen worth of the bitmap, starting at specified raster line */

void
dos_draw(line, small)

int line;       /* start at this raster line */
int small;      /* YES or NO for small or large page image */

{
	int r;				/* row index */
	long offset;                    /* into bitmap file */
	int fd;				/* file descriptor */
	int himage_bytes;		/* horizontal image bytes */
	char *row_ptr;			/* point at a row of the image */
	int n;				/* loop variable */


	/* make sure we have a valid page to draw */
	if (Currpage_p == (struct Pginfo *) 0) {
		( *(Conf_info_p->error) ) ("page # out of range");
		return;
	}

	/* figure out where in the bitmap file this page is */
	offset = Currpage_p->seqnum * BYTES_PER_PAGE;
	fd = gen1file(small);
	lseek(fd, offset + (long)line * BYTES_PER_LINE, SEEK_SET);

	/* zero out the image buffer */
	zapblock(Image, SIZEIMAGE);

	/* number of bytes representing one horizontal row in full page image */
	himage_bytes = BITS2BYTES(XSIZE) * 4;

	/* set the header bytes in the image */
	Image[0] = XSIZE % 256;
	Image[1] = XSIZE / 256;
	Image[2] = YSIZE % 256;
	Image[3] = YSIZE / 256;
	Image[4] = 4;
	Image[5] = 0;

	/* set screen to all white */
	_setbkcolor(_BRIGHTWHITE);
	_clearscreen(_GCLEARSCREEN);

	/* for each row */
	for (r = 0; r < Conf_info_p->vlines; r++) {
	    	/* read it directly into the image */
		row_ptr = &Image[ 6 + r * himage_bytes ];
		if (read(fd, row_ptr, BYTES_PER_LINE) != BYTES_PER_LINE) {
			break;
		}

		if (small) {
			/* black out the unused strip on the right */
			for (n = BITS_PER_LINE; n < XSIZE; n++)
				row_ptr[n/8] |= 1 << (7 - n%8);
		}
	}
	/* put at upper left corner, (0, 0) */
	_putimage(0, 0, Image, _GPSET);
}
\f

/* for now we just beep on errors */
/*ARGSUSED*/
void
dos_error(msg)

char *msg;

{
	putc('\7', stderr);
}
\f

/* for user interface, call command processor for each character read */

void
dos_user_interf()

{
	int c;
	int special = 0;	/* 1 = got a null, which is first character
				 * of special key sequence */
	for ( ; ; ) {
		c = getch();
		if (c == '\0') {
			special = 1;
			continue;
		}
		if (special == 1) {
			switch (c) {
			case 0x49:
				/* PgUp key */
				c = 'p';
				break;
			case 0x51:
				/* PgDown key */
				c = 'n';
				break;
			case 0x48:
				/* Up arrow key */
				c = 'b';
				break;
			case 0x50:
				/* Down arrow key */
				c = 'f';
				break;
			default:
				special = 0;
				continue;
			}
		}
		do_cmd(c);
		special = 0;
	}
}
\f

/* display a raster centered on window */

void
dos_raster(bitmap, width, height)

unsigned char *bitmap;  /* what to display */
int width, height;      /* of bitmap, width is in bytes */

{
	int r, c;       /* row and column indices */
	int b;          /* index through bits */
	int x, y;       /* upper left corner of where to put bitmap,
			 * x in bytes */
	int himage_bytes;	/* bytes needed for one row in image */
	int n;		/* loop variable */
	char *row_ptr;	/* point at a row of the image */


	himage_bytes = 4 * width;

	/* figure out how to center on screen */
	x = (BYTES_PER_LINE - width) / 2 * 8;
	y = (Conf_info_p->vlines - height) / 2;

	/* zero out the image buffer */
	zapblock(Image, SIZEIMAGE);

	/* set the header bytes in the image */
	Image[0] = (width * 8) % 256;
	Image[1] = (width * 8) / 256;
	Image[2] = height % 256;
	Image[3] = height / 256;
	Image[4] = 4;
	Image[5] = 0;

	/* for each row */
	for (r = 0; r < height; r++) {
		row_ptr = &Image[ 6 + r * himage_bytes ];
		for (c = 0; c < width; c++) {
			for (b = 0; b < 8; b++) {
				if (bitmap[r*width+c] & (1 << (7-b))) {
					/* white (15); set 4 copies of bit */
					for (n = 0; n < 4; n++)
						row_ptr[n*width + c] |=
							(1 << (7-b));
				} else {
					/* black (8); set only the first */
					row_ptr[c] |= (1 << (7-b));
				}
			}
		}
	}

	_putimage(x, y, Image, _GPSET);
}
\f
/* zero out a block of memory that may be bigger than 32K */

#define	BLOCKSIZE	0x3fff

static void
zapblock(area, size)

char *area;
long size;

{
	long k;

	/*
	 * memset's third parm is "unsigned int", so we can't do the whole
	 * area at once.
	 */
	for (k = 0; k < size; k += BLOCKSIZE) {
		if (size - k >= BLOCKSIZE)
			(void)memset(&area[k], 0, BLOCKSIZE);
		else
			(void)memset(&area[k], 0, size - k);
	}
}

#else

/* some compilers don't like empty files, so if __WATCOMC__ isn't defined,
 * put something here to keep those compilers happy */
static short dummy;

#endif
Commit	Line	Data
69695f33 MW	1
	2	/* Copyright (c) 1995, 1998 by Arkkra Enterprises */
	3	/* All rights reserved */
	4
	5	/* Functions for displaying Mup/Ghostscript output on screen using
	6	* Watcom C */
	7
	8	#ifdef __WATCOMC__
	9	#include "mupdisp.h"
	10	#include <graph.h>
	11	#include <stdlib.h>
	12	#include <malloc.h>
	13	#include <stdio.h>
	14	#include <conio.h>
	15	#include <fcntl.h>
	16	#include <io.h>
	17
	18	/* hard code X and Y sizes for the moment */
	19	#define XSIZE 640
	20	#define YSIZE 480
	21
	22	/* image to be calloc'ed has 6 header bytes, then each row consecutively */
	23	#define BITS2BYTES(bits) (((bits) + 7) / 8) /* round upwards */
	24	#define SIZEIMAGE (6 + ((long)BITS2BYTES(XSIZE)4) (long)YSIZE)
	25	static char *Image;
	26
	27	static void zapblock P((char *area, long size));
	28	\f
	29
	30	/* initialize graphics driver, etc */
	31
	32	void
	33	dos_setup()
	34
	35	{
	36	struct videoconfig vidinfo;
	37
	38
	39	/* initalize best graphics mode */
	40	if (_setvideomode(_VRES16COLOR) == 0) {
	41	fprintf(stderr, "can't set graphics mode\n");
	42	generalcleanup(1);
	43	}
	44
	45	_getvideoconfig(&vidinfo);
	46
	47	if (vidinfo.numxpixels != XSIZE \|\| vidinfo.numypixels != YSIZE) {
	48	_setvideomode(_DEFAULTMODE);
	49	fprintf(stderr, "video mode %dx%d not supported\n",
	50	vidinfo.numxpixels, vidinfo.numypixels);
	51	generalcleanup(0);
	52	}
	53
	54	/*
	55	* Allocate the image buffer. Note that both parameters must be less
	56	* than 65536, but the total size (product) can be greater. The +1
	57	* is to allow room for the header bytes (and then some).
	58	*/
	59	Image = (char )calloc(BITS2BYTES(YSIZE)4 + 1, XSIZE);
	60	if (Image == NULL) {
	61	_setvideomode(_DEFAULTMODE);
	62	fprintf(stderr, "can't allocate image buffer\n");
	63	generalcleanup(0);
	64	}
65
66	/* set aspect ratio adjust */
67	Conf_info_p->adjust = 1.375 * (double) vidinfo.numypixels
68	/ (double) vidinfo.numxpixels;
69	Conf_info_p->vlines = vidinfo.numypixels;
70
71	/* set screen to all white */
72	_setbkcolor(_BRIGHTWHITE);
73	_clearscreen(_GCLEARSCREEN);
74	}
75	\f
76
77	/* before exiting, clean up graphics, then call the general cleanup routine */
78
79	void
80	dos_cleanup(int status)
81	{
82	_setvideomode(_DEFAULTMODE);
83	generalcleanup(status);
84	}
85	\f
86
87	/* draw a screen worth of the bitmap, starting at specified raster line */
88
89	void
90	dos_draw(line, small)
91
92	int line; /* start at this raster line */
93	int small; /* YES or NO for small or large page image */
94
95	{
96	int r; /* row index */
97	long offset; /* into bitmap file */
98	int fd; /* file descriptor */
99	int himage_bytes; /* horizontal image bytes */
100	char row_ptr; / point at a row of the image */
101	int n; /* loop variable */
102
103
104	/* make sure we have a valid page to draw */
105	if (Currpage_p == (struct Pginfo *) 0) {
106	( *(Conf_info_p->error) ) ("page # out of range");
107	return;
108	}
109
110	/* figure out where in the bitmap file this page is */
111	offset = Currpage_p->seqnum * BYTES_PER_PAGE;
112	fd = gen1file(small);
113	lseek(fd, offset + (long)line * BYTES_PER_LINE, SEEK_SET);
114
115	/* zero out the image buffer */
116	zapblock(Image, SIZEIMAGE);
117
118	/* number of bytes representing one horizontal row in full page image */
119	himage_bytes = BITS2BYTES(XSIZE) * 4;
120
121	/* set the header bytes in the image */
122	Image[0] = XSIZE % 256;
123	Image[1] = XSIZE / 256;
124	Image[2] = YSIZE % 256;
125	Image[3] = YSIZE / 256;
126	Image[4] = 4;
127	Image[5] = 0;
128
129	/* set screen to all white */
130	_setbkcolor(_BRIGHTWHITE);
131	_clearscreen(_GCLEARSCREEN);
132
133	/* for each row */
134	for (r = 0; r < Conf_info_p->vlines; r++) {
135	/* read it directly into the image */
136	row_ptr = &Image[ 6 + r * himage_bytes ];
137	if (read(fd, row_ptr, BYTES_PER_LINE) != BYTES_PER_LINE) {
138	break;
139	}
140
141	if (small) {
142	/* black out the unused strip on the right */
143	for (n = BITS_PER_LINE; n < XSIZE; n++)
144	row_ptr[n/8] \|= 1 << (7 - n%8);
145	}
146	}
147	/* put at upper left corner, (0, 0) */
148	_putimage(0, 0, Image, _GPSET);
149	}
150	\f
151
152	/* for now we just beep on errors */
153	/ARGSUSED/
154	void
155	dos_error(msg)
156
157	char *msg;
158
159	{
160	putc('\7', stderr);
161	}
162	\f
163
164	/* for user interface, call command processor for each character read */
165
166	void
167	dos_user_interf()
168
169	{
170	int c;
171	int special = 0; /* 1 = got a null, which is first character
172	* of special key sequence */
173	for ( ; ; ) {
174	c = getch();
175	if (c == '\0') {
176	special = 1;
177	continue;
178	}
179	if (special == 1) {
180	switch (c) {
181	case 0x49:
182	/* PgUp key */
183	c = 'p';
184	break;
185	case 0x51:
186	/* PgDown key */
187	c = 'n';
188	break;
189	case 0x48:
190	/* Up arrow key */
191	c = 'b';
192	break;
193	case 0x50:
194	/* Down arrow key */
195	c = 'f';
196	break;
197	default:
198	special = 0;
199	continue;
200	}
201	}
202	do_cmd(c);
203	special = 0;
204	}
205	}
206	\f
207
208	/* display a raster centered on window */
209
210	void
211	dos_raster(bitmap, width, height)
212
213	unsigned char bitmap; / what to display */
214	int width, height; /* of bitmap, width is in bytes */
215
216	{
217	int r, c; /* row and column indices */
218	int b; /* index through bits */
219	int x, y; /* upper left corner of where to put bitmap,
220	* x in bytes */
221	int himage_bytes; /* bytes needed for one row in image */
222	int n; /* loop variable */
223	char row_ptr; / point at a row of the image */
224
225
226	himage_bytes = 4 * width;
227
228	/* figure out how to center on screen */
229	x = (BYTES_PER_LINE - width) / 2 * 8;
230	y = (Conf_info_p->vlines - height) / 2;
231
232	/* zero out the image buffer */
233	zapblock(Image, SIZEIMAGE);
234
235	/* set the header bytes in the image */
236	Image[0] = (width * 8) % 256;
237	Image[1] = (width * 8) / 256;
238	Image[2] = height % 256;
239	Image[3] = height / 256;
240	Image[4] = 4;
241	Image[5] = 0;
242
243	/* for each row */
244	for (r = 0; r < height; r++) {
245	row_ptr = &Image[ 6 + r * himage_bytes ];
246	for (c = 0; c < width; c++) {
247	for (b = 0; b < 8; b++) {
248	if (bitmap[r*width+c] & (1 << (7-b))) {
249	/* white (15); set 4 copies of bit */
250	for (n = 0; n < 4; n++)
251	row_ptr[n*width + c] \|=
252	(1 << (7-b));
253	} else {
254	/* black (8); set only the first */
255	row_ptr[c] \|= (1 << (7-b));
256	}
257	}
258	}
259	}
260
261	_putimage(x, y, Image, _GPSET);
262	}
263	\f
264	/* zero out a block of memory that may be bigger than 32K */
265
266	#define BLOCKSIZE 0x3fff
267
268	static void
269	zapblock(area, size)
270
271	char *area;
272	long size;
273
274	{
275	long k;
276
277	/*
278	* memset's third parm is "unsigned int", so we can't do the whole
279	* area at once.
280	*/
281	for (k = 0; k < size; k += BLOCKSIZE) {
282	if (size - k >= BLOCKSIZE)
283	(void)memset(&area[k], 0, BLOCKSIZE);
284	else
285	(void)memset(&area[k], 0, size - k);
286	}
287	}
288
289	#else
290
291	/* some compilers don't like empty files, so if __WATCOMC__ isn't defined,
292	* put something here to keep those compilers happy */
293	static short dummy;
294
295	#endif