[simh.git] / Ibm1130 / ibm1130_gdu.c

#include "ibm1130_defs.h"\r
\r
/* ibm1130_gdu.c: IBM 1130 2250 Graphical Display Unit\r
\r
   (Under construction)\r
   stuff to fix:\r
   "store revert" might be backwards?\r
   alpha keyboard is not implemented\r
   pushbuttons are not implemented\r
   there is something about interrupts being deferred during a subroutine transition?\r
\r
   Based on the SIMH package written by Robert M Supnik\r
\r
 * (C) Copyright 2002, Brian Knittel.\r
 * You may freely use this program, but: it offered strictly on an AS-IS, AT YOUR OWN\r
 * RISK basis, there is no warranty of fitness for any purpose, and the rest of the\r
 * usual yada-yada. Please keep this notice and the copyright in any distributions\r
 * or modifications.\r
 *\r
 * This is not a supported product, but I welcome bug reports and fixes.\r
 * Mail to simh@ibm1130.org\r
 */\r
\r
#define BLIT_MODE					/* define for better performance, undefine when debugging generate_image() */\r
/* #define DEBUG_LIGHTPEN */		/* define to debug light-pen sensing */\r
\r
#define DEFAULT_GDU_RATE      20	/* default frame rate */\r
#define DEFAULT_PEN_THRESHOLD  3	/* default looseness of light-pen hit */\r
#define INDWIDTH			  32	/* width of an indicator (there are two columns of these) */\r
#define INITSIZE             512	/* initial window size */\r
\r
#define GDU_DSW_ORDER_CONTROLLED_INTERRUPT	0x8000\r
#define GDU_DSW_KEYBOARD_INTERUPT			0x4000\r
#define GDU_DSW_DETECT_INTERRUPT			0x2000\r
#define GDU_DSW_CYCLE_STEAL_CHECK			0x1000\r
#define GDU_DSW_DETECT_STATUS				0x0800\r
#define GDU_DSW_LIGHT_PEN_SWITCH			0x0100\r
#define GDU_DSW_BUSY						0x0080\r
#define GDU_DSW_CHARACTER_MODE				0x0040\r
#define GDU_DSW_POINT_MODE					0x0020\r
#define GDU_DSW_ADDR_DISP					0x0003\r
\r
#define GDU_FKEY_DATA_AVAILABLE				0x8000\r
#define GDU_FKEY_KEY_CODE					0x1F00\r
#define GDU_FKEY_OVERLAY_CODE				0x00FF\r
\r
#define GDU_AKEY_DATA_AVAILABLE				0x8000\r
#define GDU_AKEY_END						0x1000\r
#define GDU_AKEY_CANCEL						0x0800\r
#define GDU_AKEY_ADVANCE					0x0400\r
#define GDU_AKEY_BACKSPACE					0x0200\r
#define GDU_AKEY_JUMP						0x0100\r
#define GDU_AKEY_KEY_CODE					0x00FF\r
\r
/* -------------------------------------------------------------------------------------- */\r
\r
#define UNIT_V_DISPLAYED	   		(UNIT_V_UF + 0)\r
#define UNIT_V_DETECTS_ENABLED		(UNIT_V_UF + 1)\r
#define UNIT_V_INTERRUPTS_DEFERRED	(UNIT_V_UF + 2)\r
#define UNIT_V_LARGE_CHARS			(UNIT_V_UF + 3)\r
\r
#define UNIT_DISPLAYED	   			(1u << UNIT_V_DISPLAYED)			/* display windows is up */\r
#define UNIT_DETECTS_ENABLED		(1u << UNIT_V_DETECTS_ENABLED)		/* light pen detects are enabled */\r
#define UNIT_INTERRUPTS_DEFERRED	(1u << UNIT_V_INTERRUPTS_DEFERRED)	/* light pen interrupts are deferred */\r
#define UNIT_LARGE_CHARS			(1u << UNIT_V_LARGE_CHARS)			/* large character mode */\r
\r
static t_stat gdu_reset (DEVICE *dptr);\r
\r
static int16 gdu_dsw  = 1;									/* device status word */\r
static int16 gdu_ar   = 0;									/* address register */\r
static int16 gdu_x    = 0;									/* X deflection */\r
static int16 gdu_y    = 0;									/* Y deflection */\r
static int16 gdu_fkey = 0;									/* function keyboard register */\r
static int16 gdu_akey = 0;									/* alphanumeric keyboard register */\r
static int16 gdu_revert = 0;								/* revert address register */\r
static int32 gdu_indicators = 0;							/* programmed indicator lamps */\r
static int32 gdu_threshold = DEFAULT_PEN_THRESHOLD;			/* mouse must be within 3/1024 of line to be a hit */\r
static int32 gdu_rate = DEFAULT_GDU_RATE;					/* refresh rate. 0 = default */\r
\r
UNIT gdu_unit = { UDATA (NULL, 0, 0) };\r
\r
REG gdu_reg[] = {\r
	{ HRDATA (GDUDSW,   gdu_dsw, 		16) },				/* device status word */\r
	{ HRDATA (GDUAR,    gdu_ar,  		16) },				/* address register */\r
	{ HRDATA (GDUXREG,  gdu_x,   		16) },				/* X deflection register */\r
	{ HRDATA (GDUYREG,  gdu_y,    		16) },				/* Y deflection register */\r
	{ HRDATA (GDUFKEY,  gdu_fkey,    	16) },				/* function keyboard register */\r
	{ HRDATA (GDUAKEY,  gdu_akey,    	16) },				/* alphanumeric keyboard register */\r
	{ HRDATA (GDUREVERT,gdu_revert,     16) },				/* revert address register */\r
	{ HRDATA (GDUAKEY,  gdu_indicators, 32) },				/* programmed indicators */\r
	{ DRDATA (GDUTHRESH,gdu_threshold,  32) },				/* mouse closeness threshhold */\r
	{ DRDATA (GDURATE,  gdu_rate,       32) },				/* refresh rate in frames/sec */\r
	{ NULL }  };\r
\r
DEVICE gdu_dev = {\r
	"GDU", &gdu_unit, gdu_reg, NULL,\r
	1, 16, 16, 1, 16, 16,\r
	NULL, NULL, gdu_reset,\r
	NULL, NULL, NULL};\r
\r
/* -------------------------------------------------------------------------------------- */\r
\r
#ifndef GUI_SUPPORT\r
\r
static t_stat gdu_reset (DEVICE *dptr)\r
{\r
	return SCPE_OK;\r
}\r
\r
void xio_2250_display (int32 addr, int32 func, int32 modify)\r
{\r
	/* ignore commands if device is nonexistent */\r
}\r
\r
t_bool gdu_active (void)\r
{\r
	return 0;\r
}\r
\r
/* -------------------------------------------------------------------------------------- */\r
#else	/* GUI_SUPPORT defined */\r
\r
/******* PLATFORM INDEPENDENT CODE ********************************************************/\r
\r
static int32 gdu_instaddr;							// address of first word of instruction\r
static int xmouse, ymouse, lpen_dist, lpen_dist2;	// current mouse pointer, scaled closeness threshhold, same squared\r
static double sfactor;								// current scaling factor\r
static t_bool last_abs = TRUE;						// last positioning instruction was absolute\r
static t_bool mouse_present = FALSE;				// mouse is/is not in the window\r
static void clear_interrupts (void);\r
static void set_indicators (int32 new_inds);\r
static void start_regeneration (void);\r
static void halt_regeneration (void);\r
static void draw_characters (void);\r
static void notify_window_closed (void);\r
\r
// routines that must be implemented per-platform\r
\r
static void	  DrawLine(int x0, int y0, int x1, int y1);\r
static void	  DrawPoint(int x, int y);\r
static void   CheckGDUKeyboard(void);\r
static t_bool CreateGDUWindow(void);\r
static void	  StartGDUUpdates(void);\r
static void	  StopGDUUpdates(void);\r
static void   GetMouseCoordinates(void);\r
static void   UpdateGDUIndicators(void);\r
static void   ShowPenHit (int x, int y);\r
static void   EraseGDUScreen (void);\r
\r
/* -------------------------------------------------------------------------------------- */\r
\r
void xio_2250_display (int32 addr, int32 func, int32 modify)\r
{\r
	switch (func) {\r
		case XIO_SENSE_DEV:\r
			ACC = (gdu_dsw & GDU_DSW_BUSY) ? GDU_DSW_BUSY : gdu_dsw;\r
			if (modify & 1)\r
				clear_interrupts();\r
			break;\r
\r
		case XIO_READ:								/* store status data into word pointed to by IOCC packet */\r
			if (gdu_dsw & GDU_DSW_BUSY)				/* not permitted while device is busy */\r
				break;\r
\r
			WriteW(addr,   gdu_ar);					/* save status information */\r
			WriteW(addr+1, gdu_dsw);\r
			WriteW(addr+2, gdu_x & 0x7FF);\r
			WriteW(addr+3, gdu_y & 0x7FF);\r
			WriteW(addr+4, gdu_fkey);\r
			WriteW(addr+5, gdu_akey);\r
			gdu_ar = (int16) (addr+6);				/* this alters the channel address register? */\r
\r
			clear_interrupts();						/* read status clears the interrupts */\r
			break;\r
\r
		case XIO_WRITE:\r
			if (gdu_dsw & GDU_DSW_BUSY)				/* treated as no-op if display is busy */\r
				break;\r
\r
			if (modify & 0x80) {					/* bit 8 on means set indicators, 0 means start regeneration */\r
				set_indicators((ReadW(addr) << 16) | ReadW(addr+1));\r
			}\r
			else {\r
				gdu_ar   = (int16) addr;\r
				gdu_fkey = 0;\r
				gdu_akey = 0;\r
				clear_interrupts();\r
				start_regeneration();\r
			}\r
			break;\r
\r
		case XIO_CONTROL:\r
			if (modify & 0x80) {					/* bit 8 on means reset, off is no-op */\r
				gdu_reset(&gdu_dev);\r
				set_indicators((addr << 16) | addr);\r
			}\r
			break;\r
\r
		default:									/* all other commands are no-ops */\r
			break;\r
	}\r
}\r
\r
static t_stat gdu_reset (DEVICE *dptr)\r
{\r
	halt_regeneration();\r
	clear_interrupts();\r
	set_indicators(0);\r
	gdu_x = gdu_y = 512;\r
	CLRBIT(gdu_unit.flags, UNIT_INTERRUPTS_DEFERRED | UNIT_DETECTS_ENABLED | UNIT_LARGE_CHARS);\r
	gdu_dsw = 1;\r
	return SCPE_OK;\r
}\r
\r
static void clear_interrupts (void)\r
{\r
	CLRBIT(gdu_dsw, GDU_DSW_ORDER_CONTROLLED_INTERRUPT | GDU_DSW_KEYBOARD_INTERUPT | GDU_DSW_DETECT_INTERRUPT);\r
	CLRBIT(ILSW[3], ILSW_3_2250_DISPLAY);\r
	calc_ints();\r
}\r
\r
static void gdu_interrupt (int32 dswbit)\r
{\r
	SETBIT(gdu_dsw, dswbit);\r
	SETBIT(ILSW[3], ILSW_3_2250_DISPLAY);\r
	calc_ints();\r
	halt_regeneration();\r
}\r
\r
static void set_indicators (int32 new_inds)\r
{\r
	gdu_indicators = new_inds;\r
	if (gdu_unit.flags & UNIT_DISPLAYED)\r
		UpdateGDUIndicators();\r
}\r
\r
static void start_regeneration (void)\r
{\r
	SETBIT(gdu_dsw, GDU_DSW_BUSY);\r
\r
	if ((gdu_unit.flags & UNIT_DISPLAYED) == 0) {\r
		if (! CreateGDUWindow())\r
			return;\r
\r
		SETBIT(gdu_unit.flags, UNIT_DISPLAYED);\r
	}\r
\r
	StartGDUUpdates();\r
}\r
\r
static void halt_regeneration (void)\r
{\r
			// halt_regeneration gets called at end of every refresh interation, so it should NOT black out the\r
			// screen -- this is why it was flickering so badly. The lower level code (called on a timer)\r
			// should check to see if GDU_DSW_BUSY is clear, and if it it still zero after several msec,\r
			// only then should it black out the screen and call StopGDUUpdates.\r
	if (gdu_dsw & GDU_DSW_BUSY) {\r
//		StopGDUUpdates();							// let lower level code discover this during next refresh\r
		CLRBIT(gdu_dsw, GDU_DSW_BUSY);\r
	}\r
//	EraseGDUScreen();								// let cessation of regeneration erase it (eventually)\r
}\r
\r
static void notify_window_closed (void)\r
{\r
	if (gdu_dsw & GDU_DSW_BUSY) {\r
		StopGDUUpdates();\r
		CLRBIT(gdu_dsw, GDU_DSW_BUSY);\r
	}\r
\r
	CLRBIT(gdu_unit.flags, UNIT_DISPLAYED);\r
\r
	gdu_reset(&gdu_dev);\r
}\r
\r
static int32 read_gduword (void)\r
{\r
	int32 w;\r
\r
	w = M[gdu_ar++ & mem_mask];\r
	gdu_dsw = (int16) ((gdu_dsw & ~GDU_DSW_ADDR_DISP) | ((gdu_ar - gdu_instaddr) & GDU_DSW_ADDR_DISP));\r
\r
	return w;\r
}\r
\r
#define DIST2(x0,y0,x1,y1) (((x1)-(x0))*((x1)-(x0))+((y1)-(y0))*((y1)-(y0)))\r
\r
static void draw (int32 newx, int32 newy, t_bool beam)\r
{\r
	int xmin, xmax, ymin, ymax, xd, yd;\r
	double s;\r
	int hit = FALSE;\r
\r
	if (beam) {\r
		if (gdu_dsw & GDU_DSW_POINT_MODE) {\r
			DrawPoint(newx, newy);\r
\r
#ifdef DEBUG_LIGHTPEN\r
			if (DIST2(newx, newy, xmouse, ymouse) <= lpen_dist2)\r
				hit = TRUE;\r
#else\r
			if (gdu_unit.flags & UNIT_DETECTS_ENABLED && mouse_present)\r
				if (DIST2(newx, newy, xmouse, ymouse) <= lpen_dist2)\r
					hit = TRUE;\r
#endif\r
		}\r
		else {\r
			DrawLine(gdu_x, gdu_y, newx, newy);\r
\r
			// calculate proximity of light pen to the line\r
#ifndef DEBUG_LIGHTPEN\r
			if (gdu_unit.flags & UNIT_DETECTS_ENABLED && mouse_present) {\r
#endif\r
				if (gdu_x <= newx)\r
					xmin = gdu_x, xmax = newx;\r
				else\r
					xmin = newx,  xmax = gdu_x;\r
\r
				if (gdu_y <= newy)\r
					ymin = gdu_y, ymax = newy;\r
				else\r
					ymin = newy,  ymax = gdu_y;\r
\r
				if (newx == gdu_x) {\r
					// line is vertical. Nearest point is an endpoint if the mouse is above or\r
					// below the line segment, otherwise the segment point at the same y as the mouse\r
					xd = gdu_x;\r
					yd = (ymouse <= ymin) ? ymin : (ymouse >= ymax) ? ymax : ymouse;\r
\r
					if (DIST2(xd, yd, xmouse, ymouse) <= lpen_dist2)\r
						hit = TRUE;\r
				}\r
				else if (newy == gdu_y) {\r
					// line is horizontal. Nearest point is an endpoint if the mouse is to the left or\r
					// the right of the line segment, otherwise the segment point at the same x as the mouse\r
					xd = (xmouse <= xmin) ? xmin : (xmouse >= xmax) ? xmax : xmouse;\r
					yd = gdu_y;\r
\r
					if (DIST2(xd, yd, xmouse, ymouse) <= lpen_dist2)\r
						hit = TRUE;\r
				}\r
				else {\r
					// line is diagonal. See if the mouse is inside the box lpen_dist wider than the line segment's bounding rectangle\r
					if (xmouse >= (xmin-lpen_dist) && xmouse <= (xmax+lpen_dist) && ymouse >= (ymin-lpen_dist) || ymouse <= (ymax+lpen_dist)) {\r
						// compute the point at the intersection of the line through the line segment and the normal\r
						// to that line through the mouse. This is the point on the line through the line segment\r
						// nearest the mouse\r
\r
						s  = (double)(newy - gdu_y) / (double)(newx - gdu_x);		// slope of line segment\r
						xd = (int) ((ymouse + xmouse/s - gdu_y + s*gdu_x) / (s + 1./s) + 0.5);\r
\r
						// if intersection is beyond either end of the line segment, the nearest point to the\r
						// mouse is nearest segment end, otherwise it's the computed intersection point\r
						if (xd < xmin || xd > xmax) {\r
#ifdef DEBUG_LIGHTPEN\r
							// if it's a hit, set xd and yd so we can display the hit\r
							if (DIST2(gdu_x, gdu_y, xmouse, ymouse) <= lpen_dist2) {\r
								hit = TRUE;\r
								xd = gdu_x;\r
								yd = gdu_y;\r
							}\r
							else if (DIST2(newx, newy, xmouse, ymouse) <= lpen_dist2) {\r
								hit = TRUE;\r
								xd = newx;\r
								yd = newy;\r
							}\r
#else\r
							if (DIST2(gdu_x, gdu_y, xmouse, ymouse) <= lpen_dist2 || DIST2(newx, newy, xmouse, ymouse) <= lpen_dist2)\r
								hit = TRUE;\r
#endif\r
						}\r
						else {\r
							yd = (int) (gdu_y + s*(xd - gdu_x) + 0.5);\r
							if (DIST2(xd, yd, xmouse, ymouse) <= lpen_dist2)\r
								hit = TRUE;\r
						}\r
					}\r
				}\r
#ifndef DEBUG_LIGHTPEN\r
			}\r
#endif\r
		}\r
	}\r
\r
	if (hit) {\r
#ifdef DEBUG_LIGHTPEN\r
		ShowPenHit(xd, yd);\r
		if (gdu_unit.flags & UNIT_DETECTS_ENABLED && mouse_present)\r
			SETBIT(gdu_dsw, GDU_DSW_DETECT_STATUS);\r
#else\r
		SETBIT(gdu_dsw, GDU_DSW_DETECT_STATUS);\r
#endif\r
	}\r
\r
	gdu_x = (int16) newx;\r
	gdu_y = (int16) newy;\r
}\r
\r
static void generate_image (void)\r
{\r
	int32 instr, new_addr, newx, newy;\r
	t_bool run = TRUE, accept;\r
\r
	if (! (gdu_dsw & GDU_DSW_BUSY))\r
		return;\r
\r
	GetMouseCoordinates();\r
\r
	lpen_dist  = (int) (gdu_threshold/sfactor + 0.5);	// mouse-to-line threshhold at current scaling factor\r
	lpen_dist2 = lpen_dist * lpen_dist;\r
\r
	while (run) {\r
		if ((gdu_dsw & GDU_DSW_DETECT_STATUS) && ! (gdu_unit.flags & UNIT_INTERRUPTS_DEFERRED)) {\r
			CLRBIT(gdu_dsw, GDU_DSW_DETECT_STATUS);	// clear when interrupt is activated\r
			gdu_interrupt(GDU_DSW_DETECT_INTERRUPT);\r
			run = FALSE;\r
			break;\r
		}\r
\r
		gdu_instaddr = gdu_ar;						// remember address of GDU instruction\r
		instr = read_gduword();						// fetch instruction (and we really are cycle stealing here!)\r
\r
		switch ((instr >> 12) & 0xF) {				// decode instruction\r
			case 0:									// short branch\r
			case 1:\r
				gdu_revert = gdu_ar;				// save revert address & get new address\r
				gdu_ar = (int16) (read_gduword() & 0x1FFF);\r
				if (gdu_dsw & GDU_DSW_CHARACTER_MODE) {\r
					draw_characters();				// in character mode this means we are at character data\r
					gdu_ar = gdu_revert;\r
				}\r
				break;\r
\r
			case 2:									// long branch/interrupt\r
				new_addr = read_gduword();			// get next word\r
				accept = ((instr & 1) ? (gdu_dsw & GDU_DSW_LIGHT_PEN_SWITCH) : TRUE) && ((instr & 2) ? (gdu_dsw & GDU_DSW_DETECT_STATUS) : TRUE);\r
\r
				if (instr & 2)						// clear after testing\r
					CLRBIT(gdu_dsw, GDU_DSW_DETECT_STATUS);\r
\r
				if (instr & 0x0400)					// NOP\r
					accept = FALSE;\r
\r
				if (accept) {\r
					if (instr & 0x0800) {			// branch\r
						gdu_revert = gdu_ar;\r
\r
						if (instr & 0x0080)			// indirect\r
							new_addr = M[new_addr & mem_mask];\r
\r
						gdu_ar = (int16) new_addr;\r
\r
						if (gdu_dsw & GDU_DSW_CHARACTER_MODE) {\r
							draw_characters();\r
							gdu_ar = gdu_revert;\r
						}\r
					}\r
					else {							// interrupt\r
						gdu_interrupt(GDU_DSW_ORDER_CONTROLLED_INTERRUPT);\r
						run = FALSE;\r
					}\r
				}\r
				break;\r
\r
			case 3:									// control instructions\r
				CLRBIT(gdu_dsw, GDU_DSW_CHARACTER_MODE);\r
\r
				switch ((instr >> 8) & 0xF) {\r
					case 1:							// set pen mode\r
						if ((instr & 0xC) == 8)\r
							SETBIT(gdu_unit.flags, UNIT_DETECTS_ENABLED);\r
						else if ((instr & 0xC) == 4)\r
							CLRBIT(gdu_unit.flags, UNIT_DETECTS_ENABLED);\r
\r
						if ((instr & 0x3) == 2)\r
							SETBIT(gdu_unit.flags, UNIT_INTERRUPTS_DEFERRED);\r
						else if ((instr & 0x3) == 1)\r
							CLRBIT(gdu_unit.flags, UNIT_INTERRUPTS_DEFERRED);\r
						break;\r
\r
					case 2:							// set graphic mode\r
						if (instr & 1)\r
							SETBIT(gdu_dsw, GDU_DSW_POINT_MODE);\r
						else\r
							CLRBIT(gdu_dsw, GDU_DSW_POINT_MODE);\r
						break;\r
\r
					case 3:							// set character mode\r
						SETBIT(gdu_dsw, GDU_DSW_CHARACTER_MODE);\r
						if (instr & 1)\r
							SETBIT(gdu_unit.flags, UNIT_LARGE_CHARS);\r
						else\r
							CLRBIT(gdu_unit.flags, UNIT_LARGE_CHARS);\r
						break;\r
\r
					case 4:							// start timer\r
						run = FALSE;				// (which, for us, means stop processing until next timer message)\r
						CheckGDUKeyboard();\r
						break;\r
\r
					case 5:							// store revert\r
						M[gdu_ar & mem_mask] = gdu_revert;\r
						read_gduword();				// skip to next address\r
						break;\r
\r
					case 6:							// revert\r
						gdu_ar = gdu_revert;\r
						break;\r
\r
					default:						// all others treated as no-ops\r
						break;\r
				}\r
				break;\r
\r
			case 4:									// long absolute\r
			case 5:\r
				CLRBIT(gdu_dsw, GDU_DSW_CHARACTER_MODE);\r
				newx = instr & 0x3FF;\r
				newy = read_gduword() & 0x3FF;\r
				draw(newx, newy, instr & 0x1000);\r
				last_abs = TRUE;\r
				break;\r
\r
			case 6:									// short absolute\r
			case 7:\r
				CLRBIT(gdu_dsw, GDU_DSW_CHARACTER_MODE);\r
				newx = gdu_x;\r
				newy = gdu_y;\r
				if (instr & 0x0800)\r
					newy = instr & 0x3FF;\r
				else\r
					newx = instr & 0x3FF;\r
				draw(newx, newy, instr & 0x1000);\r
				last_abs = TRUE;\r
				break;\r
\r
			default:								// high bit set - it's a relative instruction\r
				CLRBIT(gdu_dsw, GDU_DSW_CHARACTER_MODE);\r
				newx = (instr >> 8) & 0x3F;\r
				newy = instr & 0x3F;\r
\r
				if (instr & 0x4000)					// sign extend x - values are in 2's complement\r
					newx |= -1 & ~0x3F;				// although documentation doesn't make that clear\r
\r
				if (instr & 0x0040)					// sign extend y\r
					newy |= -1 & ~0x3F;\r
\r
				newx = gdu_x + newx;\r
				newy = gdu_y + newy;\r
				draw(newx, newy, instr & 0x0080);\r
				last_abs = FALSE;\r
				break;\r
		}\r
	}\r
}\r
\r
static struct charinfo {		// character mode scaling info:\r
	int dx, dy;						// character and line spacing\r
	double sx, sy;					// scaling factors: character units to screen units\r
	int xoff, yoff;					// x and y offset to lower left corner of character\r
	int suby;						// subscript/superscript offset\r
} cx[2] = {\r
	{14, 20, 1.7, 2.0, -6, -7,  6},	// regular\r
	{21, 30, 2.5, 3.0, -9, -11, 9}	// large\r
};\r
\r
static void draw_characters (void)\r
{\r
	int32 w, x0, y0, x1, y1, yoff = 0, ninstr = 0;\r
	t_bool dospace, didstroke = FALSE;\r
	struct charinfo *ci;\r
\r
	ci = &cx[(gdu_unit.flags & UNIT_LARGE_CHARS) ? 1 : 0];\r
	x0 = gdu_x + ci->xoff;						// starting position\r
	y0 = gdu_y + ci->yoff;\r
\r
	do {\r
		if (++ninstr > 29) {					// too many control words\r
			gdu_interrupt(GDU_DSW_CYCLE_STEAL_CHECK);\r
			return;\r
		}\r
\r
		dospace = TRUE;\r
		w = M[gdu_ar++ & mem_mask];				// get next stroke or control word\r
\r
		x1 = (w >> 12) & 7;\r
		y1 = (w >>  8) & 7;\r
\r
		if (x1 == 7) {							// this is a character control word\r
			dospace = FALSE;					// inhibit character spacing\r
\r
			switch (y1) {\r
				case 1:							// subscript\r
					if (yoff == 0)				// (ignored if superscript is in effect)\r
						yoff = -ci->suby;\r
					break;\r
\r
//				case 2:							// no-op or null (nothing to do)\r
//				default:						// all unknowns are no-ops\r
//					break;\r
\r
				case 4:							// superscript\r
					yoff = ci->suby;\r
					break;\r
\r
				case 7:							// new line\r
					gdu_x = 0;\r
					gdu_y -= (int16) ci->dy;\r
					if (gdu_y < 0 && last_abs)\r
						gdu_y = (int16) (1024 - ci->dy);	// this is a guess\r
					break;\r
			}\r
		}\r
		else {									// this is stroke data -- extract two strokes\r
			x1 = gdu_x + (int) (x1*ci->sx + 0.5);\r
			y1 = gdu_y + (int) ((y1+yoff)*ci->sy + 0.5);\r
\r
			if (w & 0x0800) {\r
				didstroke = TRUE;\r
				DrawLine(x0, y0, x1, y1);\r
			}\r
\r
			x0 = (w >> 4) & 7;\r
			y0 =  w       & 7;\r
\r
			x0 = gdu_x + (int) (x0*ci->sx + 0.5);\r
			y0 = gdu_y + (int) ((y0+yoff)*ci->sy + 0.5);\r
\r
			if (w & 0x0008) {\r
				didstroke = TRUE;\r
				DrawLine(x1, y1, x0, y0);\r
			} \r
		}\r
\r
		if (dospace) {\r
			gdu_x += ci->dx;\r
			if (gdu_x > 1023 && last_abs) {		// line wrap\r
				gdu_x = 0;\r
				gdu_y -= (int16) ci->dy;\r
			}\r
		}\r
	} while ((w & 0x0080) == 0);				// repeat until we hit revert bit\r
\r
	if (didstroke && mouse_present && (gdu_unit.flags & UNIT_DETECTS_ENABLED)) {\r
		if (xmouse >= (gdu_x - ci->xoff/2) && xmouse <= (gdu_x + ci->xoff/2) &&\r
	    	    ymouse >= (gdu_y - ci->yoff/2) && ymouse <= (gdu_y + ci->yoff/2))\r
			SETBIT(gdu_dsw, GDU_DSW_DETECT_STATUS);\r
	}\r
}\r
\r
/******* PLATFORM SPECIFIC CODE ***********************************************************/\r
\r
#ifdef _WIN32\r
\r
#include <windows.h>\r
#include <windowsx.h>\r
\r
#define APPCLASS "IBM2250GDU"					// window class name\r
\r
#define RGB_GREEN RGB(0,255,0)					// handy colors\r
#define RGB_RED   RGB(255,0,0)\r
\r
static HINSTANCE hInstance;\r
static HWND hwGDU       = NULL;\r
static HDC  hdcGDU      = NULL;\r
static HBITMAP hBmp     = NULL;\r
static int  curwid      = 0;\r
static int  curht       = 0;\r
static BOOL wcInited    = FALSE;\r
static DWORD GDUPumpID   = 0;\r
static HANDLE hGDUPump  = INVALID_HANDLE_VALUE;\r
static HPEN hGreenPen   = NULL;\r
static HBRUSH hRedBrush = NULL;\r
#ifdef DEBUG_LIGHTPEN\r
static HPEN hRedPen     = NULL;\r
#endif\r
static HBRUSH hGrayBrush, hDarkBrush;\r
static HPEN hBlackPen;\r
static int halted = 0;								// number of time intervals that GDU has been halted w/o a regeneration\r
static LRESULT APIENTRY GDUWndProc (HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);\r
static DWORD   WINAPI   GDUPump (LPVOID arg);\r
\r
static void destroy_GDU_window (void)\r
{\r
	if (hwGDU != NULL)\r
		SendMessage(hwGDU, WM_CLOSE, 0, 0);			// cross thread call is OK\r
\r
	if (hGDUPump != INVALID_HANDLE_VALUE) {			// this is not the most graceful way to do it\r
		TerminateThread(hGDUPump, 0);\r
		hGDUPump  = INVALID_HANDLE_VALUE;\r
		GDUPumpID = 0;\r
		hwGDU     = NULL;\r
	}\r
\r
	if (hdcGDU != NULL) {\r
		DeleteDC(hdcGDU);\r
		hdcGDU = NULL;\r
	}\r
\r
	if (hBmp != NULL) {\r
		DeleteObject(hBmp);\r
		hBmp = NULL;\r
	}\r
\r
	if (hGreenPen != NULL) {\r
		DeleteObject(hGreenPen);\r
		hGreenPen = NULL;\r
	}\r
\r
	if (hRedBrush != NULL) {\r
		DeleteObject(hRedBrush);\r
		hRedBrush = NULL;\r
	}\r
\r
#ifdef DEBUG_LIGHTPEN\r
	if (hRedPen != NULL) {\r
		DeleteObject(hRedPen);\r
		hRedPen = NULL;\r
	}\r
#endif\r
}\r
\r
static t_bool CreateGDUWindow (void)\r
{\r
	static BOOL did_atexit = FALSE;\r
\r
	hInstance = GetModuleHandle(NULL);\r
\r
	if (hGDUPump == INVALID_HANDLE_VALUE)\r
		hGDUPump = CreateThread(NULL, 0, GDUPump, 0, 0, &GDUPumpID);\r
\r
	if (! did_atexit) {\r
		atexit(destroy_GDU_window);\r
		did_atexit = TRUE;\r
	}\r
\r
	return TRUE;\r
}\r
\r
// windows message handlers ----------------------------------------------------\r
\r
// close the window\r
\r
static void gdu_WM_CLOSE (HWND hWnd)\r
{\r
	DestroyWindow(hWnd);\r
}\r
\r
// the window is being destroyed\r
\r
static void gdu_WM_DESTROY (HWND hWnd)\r
{\r
	notify_window_closed();\r
	hwGDU = NULL;\r
}\r
\r
// adjust the min and max resizing boundaries\r
\r
static void gdu_WM_GETMINMAXINFO (HWND hWnd, LPMINMAXINFO mm)\r
{\r
	mm->ptMinTrackSize.x = 100 + 2*INDWIDTH;\r
	mm->ptMinTrackSize.y = 100;\r
}\r
\r
static void PaintImage (HDC hDC, BOOL draw_indicators)\r
{\r
	HPEN hOldPen;\r
	RECT r;\r
	int wid, ht, x, y, dy, i, j, ycirc;\r
	unsigned long bit;\r
\r
	GetClientRect(hwGDU, &r);\r
	wid = r.right+1 - 2*INDWIDTH;\r
	ht  = r.bottom+1;\r
	sfactor = (double) MIN(wid,ht) / 1024.;\r
\r
	if (gdu_dsw & GDU_DSW_BUSY) {\r
#ifdef BLIT_MODE\r
		// if compiled for BLIT_MODE, draw the image into a memory display context, then\r
		// blit the new image over window. This eliminates the flicker that a normal erase-and-\r
		// repaint would cause.\r
\r
		if (wid != curwid || ht != curht) {		// dimensions have changed, discard old memory display context\r
			if (hdcGDU != NULL) {\r
				DeleteDC(hdcGDU);\r
				hdcGDU = NULL;\r
			}\r
			curwid = wid;\r
			curht  = ht;\r
		}\r
\r
		if (hdcGDU == NULL) {					// allocate memory display context & select a bitmap into it\r
			hdcGDU = CreateCompatibleDC(hDC);\r
			if (hBmp != NULL)\r
				DeleteObject(hBmp);\r
			hBmp = CreateCompatibleBitmap(hDC, wid, ht);\r
			SelectObject(hdcGDU, hBmp);\r
		}\r
\r
		PatBlt(hdcGDU, 0, 0, wid, ht, BLACKNESS);			// start with a black screen\r
\r
		hOldPen = SelectObject(hdcGDU, hGreenPen);\r
\r
		SetMapMode(hdcGDU, MM_ANISOTROPIC);\r
		SetWindowExtEx(hdcGDU, 1024, -1024, NULL);\r
		SetViewportExtEx(hdcGDU, wid, ht, NULL);\r
		SetWindowOrgEx(hdcGDU, 0, 1023, NULL);\r
\r
		generate_image();									// run the display program to paint the image into the memory context\r
\r
		SetWindowExtEx(hdcGDU, wid, ht, NULL);				// undo the scaling so the blit isn't distorted\r
		SetViewportExtEx(hdcGDU, wid, ht, NULL);\r
		SetWindowOrgEx(hdcGDU, 0, 0, NULL);\r
		BitBlt(hDC, 0, 0, wid, ht, hdcGDU, 0, 0, SRCCOPY);	// blit the new image over the old\r
\r
		SelectObject(hdcGDU, hOldPen);\r
#else\r
		// for testing purposes -- draw the image directly onto the screen.\r
		// Compile this way when you want to single-step through the image drawing routine,\r
		// so you can see the draws occur.\r
		hdcGDU = hDC;\r
		hOldPen = SelectObject(hdcGDU, hGreenPen);\r
\r
		SetMapMode(hdcGDU, MM_ANISOTROPIC);\r
		SetWindowExtEx(hdcGDU, 1024, -1024, NULL);\r
		SetViewportExtEx(hdcGDU, wid, ht, NULL);\r
		SetWindowOrgEx(hdcGDU, 0, 1023, NULL);\r
\r
		generate_image();\r
\r
		SelectObject(hdcGDU, hOldPen);\r
		hdcGDU = NULL;\r
#endif\r
	}\r
\r
	if (draw_indicators) {\r
		x  = r.right-2*INDWIDTH+1;\r
		dy = ht / 16;\r
		ycirc = MIN(dy-2, 8);\r
\r
		r.left = x;\r
		FillRect(hDC, &r, hGrayBrush);\r
		SelectObject(hDC, hBlackPen);\r
\r
		bit = 0x80000000L;\r
		for (i = 0; i < 2; i++) {\r
			MoveToEx(hDC, x, 0, NULL);\r
			LineTo(hDC, x, r.bottom);\r
			y = 0;\r
			for (j = 0; j < 16; j++) {\r
				MoveToEx(hDC, x, y, NULL);\r
				LineTo(hDC, x+INDWIDTH, y);\r
\r
				SelectObject(hDC, (gdu_indicators & bit) ? hRedBrush : hDarkBrush);\r
				Pie(hDC, x+1, y+1, x+1+ycirc, y+1+ycirc, x+1, y+1, x+1, y+1);\r
\r
				y += dy;\r
				bit >>= 1;\r
			}\r
			x += INDWIDTH;\r
		}\r
	}\r
}\r
\r
// repaint the window\r
\r
static void gdu_WM_PAINT (HWND hWnd)\r
{\r
	PAINTSTRUCT ps;\r
	HDC hDC;\r
				// code for display\r
	hDC = BeginPaint(hWnd, &ps);\r
	PaintImage(hDC, TRUE);\r
	EndPaint(hWnd, &ps);\r
}\r
\r
// the window has been resized\r
\r
static void gdu_WM_SIZE (HWND hWnd, UINT state, int cx, int cy)\r
{\r
	InvalidateRect(hWnd, NULL, TRUE);\r
}\r
\r
// tweak the sizing rectangle during a resize to guarantee a square window\r
\r
static void gdu_WM_SIZING (HWND hWnd, WPARAM fwSide, LPRECT r)\r
{\r
	switch (fwSide) {\r
		case WMSZ_LEFT:\r
        case WMSZ_RIGHT:\r
        case WMSZ_BOTTOMLEFT:\r
        case WMSZ_BOTTOMRIGHT:\r
        	r->bottom = r->right - r->left - 2*INDWIDTH + r->top;\r
        	break;\r
\r
        case WMSZ_TOP:\r
        case WMSZ_BOTTOM:\r
        case WMSZ_TOPRIGHT:\r
        	r->right  = r->bottom - r->top + r->left + 2*INDWIDTH;\r
        	break;\r
\r
        case WMSZ_TOPLEFT:\r
        	r->left   = r->top - r->bottom + r->right - 2*INDWIDTH;\r
        	break;\r
	}\r
}\r
\r
// the refresh timer has gone off\r
\r
static void gdu_WM_TIMER (HWND hWnd, UINT id)\r
{\r
	HDC hDC;\r
\r
	if (running) {			// if CPU is running, update picture\r
		if ((gdu_dsw & GDU_DSW_BUSY) == 0) {	// regeneration is not to occur\r
			if (++halted >= 4) {				// stop the timer if four timer intervals go by with the display halted\r
				EraseGDUScreen();				// screen goes black due to cessation of refreshing\r
				StopGDUUpdates();				// might as well kill the timer\r
				return;\r
			}\r
		}\r
		else\r
			halted = 0;\r
\r
#ifdef BLIT_MODE\r
		hDC = GetDC(hWnd);						// blit the new image right over the old\r
		PaintImage(hDC, FALSE);\r
		ReleaseDC(hWnd, hDC);\r
#else\r
		InvalidateRect(hWnd, NULL, TRUE);		// repaint\r
#endif\r
    }\r
}\r
\r
// window procedure ------------------------------------------------------------\r
\r
#define HANDLE(msg)	case msg: return HANDLE_##msg(hWnd, wParam, lParam, gdu_##msg);\r
\r
#ifndef HANDLE_WM_SIZING\r
// void Cls_OnSizing(HWND hwnd, UINT fwSide, LPRECT r)\r
#  define HANDLE_WM_SIZING(hwnd, wParam, lParam, fn) \\r
    ((fn)((hwnd), (UINT)(wParam), (LPRECT)(lParam)), 0L)\r
#endif\r
\r
static LRESULT APIENTRY GDUWndProc (HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)\r
{\r
	switch (iMessage) {\r
		HANDLE(WM_CLOSE);\r
		HANDLE(WM_GETMINMAXINFO);\r
		HANDLE(WM_DESTROY);\r
		HANDLE(WM_PAINT);\r
		HANDLE(WM_SIZE);\r
		HANDLE(WM_SIZING);\r
		HANDLE(WM_TIMER);\r
		default:					// any message we don't process\r
			return DefWindowProc(hWnd, iMessage, wParam, lParam);\r
	}\r
	return 0L;\r
}\r
\r
// graphic calls ----------------------------------------------------------------\r
\r
static void	DrawLine (int x0, int y0, int x1, int y1)\r
{\r
	MoveToEx(hdcGDU, x0, y0, NULL);\r
	LineTo(hdcGDU, x1, y1);\r
}\r
\r
static void	DrawPoint (int x, int y)\r
{\r
	SetPixel(hdcGDU, x, y, RGB_GREEN);\r
}\r
\r
static void UpdateGDUIndicators(void)\r
{\r
	if (hwGDU != NULL)\r
		InvalidateRect(hwGDU, NULL, FALSE);			// no need to erase the background -- the draw routine fully paints the indicator\r
}\r
\r
static void CheckGDUKeyboard (void)\r
{\r
}\r
\r
static UINT idTimer = 0;\r
\r
static void	StartGDUUpdates (void)\r
{\r
	int msec;\r
\r
	if (idTimer == 0) {\r
		msec = (gdu_rate == 0) ? (1000 / DEFAULT_GDU_RATE) : 1000/gdu_rate;\r
		idTimer = SetTimer(hwGDU, 1, msec, NULL);\r
	}\r
	halted = 0;\r
}\r
\r
static void	StopGDUUpdates (void)\r
{\r
	if (idTimer != 0) {\r
		KillTimer(hwGDU, 1);\r
		idTimer = 0;\r
		halted  = 10000;\r
	}\r
}\r
\r
static void GetMouseCoordinates()\r
{\r
	POINT p;\r
	RECT r;\r
\r
	GetCursorPos(&p);\r
	GetClientRect(hwGDU, &r);\r
	if (! ScreenToClient(hwGDU, &p)) {\r
		xmouse = ymouse = -2000;\r
		mouse_present = FALSE;\r
		return;\r
	}\r
\r
	if (p.x < r.left || p.x >= r.right || p.y < r.top || p.y > r.bottom) {\r
		mouse_present = FALSE;\r
		return;\r
	}\r
\r
	// convert mouse coordinates to scaled coordinates\r
\r
	xmouse =        (int) (1024./(r.right+1.-2*INDWIDTH)*p.x + 0.5);\r
	ymouse = 1023 - (int) (1024./(r.bottom+1.)*p.y + 0.5);\r
	mouse_present = TRUE;\r
}\r
\r
t_bool gdu_active (void)\r
{\r
	return gdu_dsw & GDU_DSW_BUSY;\r
}\r
\r
static void EraseGDUScreen (void)\r
{\r
	if (hwGDU != NULL)								/* redraw screen. it will be blank if GDU is not running */\r
		InvalidateRect(hwGDU, NULL, TRUE);\r
}\r
\r
/* GDUPump - thread responsible for creating and displaying the graphics window */\r
\r
static DWORD WINAPI GDUPump (LPVOID arg)\r
{\r
	MSG msg;\r
	WNDCLASS wc;\r
\r
	if (! wcInited) {								/* register Window class */\r
		memset(&wc, 0, sizeof(wc));\r
		wc.style         = CS_NOCLOSE;\r
		wc.lpfnWndProc   = GDUWndProc;\r
		wc.hInstance     = hInstance;\r
		wc.hCursor       = LoadCursor(NULL, IDC_ARROW);\r
		wc.hbrBackground = GetStockObject(BLACK_BRUSH);\r
		wc.lpszClassName = APPCLASS;\r
\r
		if (! RegisterClass(&wc)) {\r
			GDUPumpID = 0;\r
			return 0;\r
		}\r
\r
		wcInited = TRUE;\r
	}\r
\r
	if (hGreenPen == NULL)\r
		hGreenPen = CreatePen(PS_SOLID, 1, RGB_GREEN);\r
\r
#ifdef DEBUG_LIGHTPEN\r
	if (hRedPen == NULL)\r
		hRedPen = CreatePen(PS_SOLID, 1, RGB_RED);\r
#endif\r
\r
	if (hRedBrush == NULL)\r
		hRedBrush = CreateSolidBrush(RGB_RED);\r
\r
	hGrayBrush = GetStockObject(GRAY_BRUSH);\r
	hDarkBrush = GetStockObject(DKGRAY_BRUSH);\r
	hBlackPen  = GetStockObject(BLACK_PEN);\r
\r
	if (hwGDU == NULL) {							/* create window */\r
		hwGDU = CreateWindow(APPCLASS,\r
			"2250 Display",\r
			WS_OVERLAPPEDWINDOW	| WS_CLIPCHILDREN,\r
			CW_USEDEFAULT, CW_USEDEFAULT,			// initial x, y position\r
			INITSIZE+2*INDWIDTH, INITSIZE,			// initial width and height\r
			NULL,									// parent window handle\r
			NULL,									// use class menu\r
			hInstance,								// program instance handle\r
			NULL);									// create parameters\r
\r
		if (hwGDU == NULL) {\r
			GDUPumpID = 0;\r
			return 0;\r
		}\r
	}\r
\r
	ShowWindow(hwGDU, SW_SHOWNOACTIVATE);			/* display it */\r
	UpdateWindow(hwGDU);\r
	\r
	while (GetMessage(&msg, hwGDU, 0, 0)) {			/* message pump - this basically loops forevermore */\r
		TranslateMessage(&msg);\r
		DispatchMessage(&msg);\r
	}\r
\r
	if (hwGDU != NULL) {\r
		DestroyWindow(hwGDU);						/* but if a quit message got posted, clean up */\r
		hwGDU = NULL;\r
	}\r
\r
	GDUPumpID = 0;\r
	return 0;\r
}\r
\r
#ifdef DEBUG_LIGHTPEN\r
static void ShowPenHit (int x, int y)\r
{\r
	HPEN hOldPen;\r
\r
	hOldPen = SelectObject(hdcGDU, hRedPen);\r
	DrawLine(x-10, y-10, x+10, y+10);\r
	DrawLine(x-10, y+10, x+10, y-10);\r
	SelectObject(hdcGDU, hOldPen);\r
}\r
#endif\r
\r
#endif		// _WIN32 defined\r
#endif		// GUI_SUPPORT defined\r