goto newmove; } }

		i = dtop;
		dtop = psave + 1;
		draw(x);
		draw(y);
		dtop = i;

skipmove:
		pixel = SET_PIXEL;
		message();
		dpos = psave;
		draw_object(0, 0); }
}


copy()
{
	unsigned psave, i, x, y, sx, sy;

	if(select_object("DUP")) {
		psave = dpos;
		++dpos;
		sx = dvalue();
		sy = dvalue();
		pixel = SET_PIXEL;
		dpos = psave;
		draw_object(0, 0);
		pixel = FLIP_PIXEL;
		message();
		printf("DUP: Select new position");
	newcopy:
		dpos = psave;
		draw_object((x = mousex) - sx, (y = mousey) - sy);
		while(!((i = mouse_status()) & MOUSE_LEFT)) {
			if(i & MOUSE_RIGHT) {
				dpos = psave;
				draw_object(x - sx, y - sy);
				message();
				return; }
			if((x != mousex) || (y != mousey)) {
				dpos = psave;
				draw_object(x - sx, y - sy);
				goto newcopy; } }

		drawing[dpos = dtop++] = ACOPY;
		draw(x);
		draw(y);
		draw(psave);

		message();
		pixel = SET_PIXEL;
		draw_object(0, 0); }
}


draw_object(xoffset, yoffset)
	int xoffset, yoffset;
{
	int x, y, i, j, k, l;
	char buffer[80], *ptr;

	if(cursor_flag)
		mouse_status();

	if(!(i = drawing[dpos++]))
		return -1;
	x = dvalue() + xoffset;
	y = dvalue() + yoffset;
	if(!tick++)
		box(max(0, x-1), max(0, y-1), min(HORIZONTAL-1, x+1), min(VERTICAL-1, y+1));

	switch(i) {
		case LINE :
			line(x, y, x+dvalue(), y+dvalue());
			break;
		case BOX :
			box(x, y, x+dvalue(), y+dvalue());
			break;
		case CIRCLE :
			circle(x, y, dvalue());
			break;
		case TEXT :
			i = dvalue();
			ptr = buffer;
			do
				*ptr++ = j = drawing[dpos++];
			while(j);
			text(buffer, x, y, i);
			break;
		case ARC:
			arc(x, y, dvalue(), dvalue(), dvalue());
			break;
		case GROUP :
			i = dvalue();
			j = dpos;
			while((dpos - j) < i)
				draw_object(x, y);
			break;
		case RCOPY :
			i = dpos - 5;
			i += dvalue();
			goto gocopy;
		case ACOPY :
			i = dvalue();
		gocopy:
			j = dpos;
			dpos = i+1;
			k = dvalue();
			l = dvalue();
			dpos = i;
			draw_object(x - k, y - l);
			dpos = j;
			break;
		default:
			message();
			printf("Corrupt drawing file!");
			zero_drawing(dpos -= 5);
			return -1; }
	--tick;
	return 0;
}


skip_object()
{
	unsigned i;

	switch(drawing[dpos++]) {
		case LINE :
		case BOX :
			dpos += 8;
			break;
		case CIRCLE :
		case ACOPY :
		case RCOPY :
			dpos += 6;
			break;
		case TEXT :
			dpos += 6;
			while(drawing[dpos++]);
			break;
		case ARC :
			dpos += 10;
			break;
		case GROUP :
			dvalue();
			dvalue();
			i = dvalue();
			dpos += i;
			break;
		default :
			message();
			printf("Corrupt drawing file!");
			zero_drawing(--dpos);
		case 0 :
			return -1; }
	return 0;
}

select_object(name)
	char *name;
{
	int x, y, i, b;
	char flag;

	flag = -1;
	for(;;) {
		if(flag) {
			message();
			printf("%s: Select object", name);
			flag = 0; }
		if((b = mouse_status()) & MOUSE_RIGHT) {
			message();
			return 0; }
		x = mousex;
		y = mousey;
		dpos = 0;
		while(drawing[i = dpos++]) {
			if((dvalue() == x) && (dvalue() == y)) {
				if(cursor_flag) {
					draw_cursor();
					cursor_flag = 0; }
				dpos = i;
				pixel = CLEAR_PIXEL;
				draw_object(0, 0);
				pixel = SET_PIXEL;
				if(wait_for_left("LEFT to accept, RIGHT to cancel")) {
					dpos = i;
					draw_object(0, 0);
					flag = -1;
					continue; }
				dpos = i;
				message();
				return -1; }
			dpos = i;
			if(skip_object())
				break; } }
}


find_vector(x, y, r, sx, sy)
	int x, y, r, sx, sy;
{
	int rs, i, j, ax, x1, y1, x2, y2, v, v1;
	unsigned d, d1;

	rs = r*r;

	d1 = -1;
	for(v=0; v < (ARC_RES*4); ++v) {
		j = (ARC_RES-1) - (i = v & (ARC_RES-1));
		switch(v & (ARC_RES*3)) {
			case ARC_RES*0 :		
				x1 = x + (ax = scale(r, sine[i], -1));
				y1 = y - sqrt(rs - (ax*ax));
				break;
			case ARC_RES*1 :		
				x1 = x + (ax = scale(r, sine[j], -1));
				y1 = y + sqrt(rs - (ax*ax));
				break;
			case ARC_RES*2 :		/*   */
				x1 = x - (ax = scale(r, sine[i], -1));
				y1 = y + sqrt(rs - (ax*ax));
				break;
			case ARC_RES*3 :		/*   */
				x1 = x - (ax = scale(r, sine[j], -1));
				y1 = y - sqrt(rs - (ax*ax)); }
		x2 = abs(x1 - sx);
		y2 = abs(y1 - sy);
		if((d = sqrt((x2*x2) + (y2*y2))) < d1) {
			v1 = v;
			d1 = d; } }
	return v1;
}


line(x1, y1, x2, y2)
	int x1, y1, x2, y2;
{
	int i, w, h;
	if((w = abs(x1 - x2)) >= (h = abs(y1 - y2))) {
		if(x1 > x2) {
			i = x1;
			x1 = x2;
			x2 = i;
			i = y1;
			y1 = y2;
			y2 = i; }
		if(y1 < y2) {
			for(i=0; i < w; ++i)
				set_pixel(x1+i, y1+scale(i, h, w)); }
		else {
			for(i=0; i < w; ++i)
				set_pixel(x1+i, y1-scale(i, h, w)); } }
	else {
		if(y1 > y2) {
			i = x1;
			x1 = x2;
			x2 = i;
			i = y1;
			y1 = y2;
			y2 = i; }
		if(x1 < x2) {
			for(i=0; i < h; ++i)
				set_pixel(x1+scale(i, w, h), y1+i); }
		else {
			for(i=0; i < h; ++i)
				set_pixel(x1-scale(i, w, h), y1+i); } }

	set_pixel(x2, y2);
}


box(x1, y1, x2, y2)
	int x1, y1, x2, y2;
{
	line(x1, y1, x2, y1);		
	line(x1, y1+1, x1, y2-1);	
	line(x2, y1+1, x2, y2-1);	
	line(x1, y2, x2, y2);		
}


circle(x, y, r)
	int x, y, r;
{
	int i, j, k, rs, lj;

	rs = (lj = r)*r;
	for(i=0; i <= r; ++i) {
		j = k = sqrt(rs - (i*i));
		do {
			set_pixel(x+i, y+j);
			set_pixel(x+i, y-j);
			set_pixel(x-i, y+j);
			set_pixel(x-i, y-j); }
		while(++j < lj);
		lj = k; }
}


arc(x, y, r, v1, v2)
	int x, y, r;
	unsigned char v1, v2;
{
	int rs, i, j, ax, x1, y1, x2, y2;

	x2 = -1;
	rs = r*r;

	do {
		j = (ARC_RES-1) - (i = v1 & (ARC_RES-1));
		switch(v1 & (ARC_RES*3)) {
			case ARC_RES*0 :	/* Quadrant one */
				x1 = x + (ax = scale(r, sine[i], -1));
				y1 = y - sqrt(rs - (ax*ax));
				break;
			case ARC_RES*1 :	/* Quadrant two */
				x1 = x + (ax = scale(r, sine[j], -1));
				y1 = y + sqrt(rs - (ax*ax));
				break;
			case ARC_RES*2 :	/* Quadrant three */
				x1 = x - (ax = scale(r, sine[i], -1));
				y1 = y + sqrt(rs - (ax*ax));
				break;
			case ARC_RES*3 :	/* Quadrant four */
				x1 = x - (ax = scale(r, sine[j], -1));
				y1 = y - sqrt(rs - (ax*ax)); }
		if(x2 != -1)
			line(x2, y2, x1, y1);
		x2 = x1;
		y2 = y1; }
	while(v1++ != v2);
}


text(string, x, y, s)
	char *string;
	int x, y, s;
{
	unsigned i, j, b;
	unsigned char *ptr;

	y -= scale(24, s, 100);
	while(*string) {
		ptr = &font[(*string++ - ' ') * 48];

		for(i=0; i < 24; ++i) {
			b = (*ptr++ << 8) | *ptr++;
			for(j=0; j < 16; ++j) {
				if(b & 0x8000)
					set_pixel(x+scale(j,s,100), y+scale(i,s,100));
				b <<= 1; } }
		x += scale(18, s, 100); }
}

message()
{
	int i;
	gotoxy(0, 0);
	for(i=0; i < 80; ++i)
		putc(' ', stdout);
	gotoxy(0, 0);
}


wait_for_left(prompt)
	char *prompt;
{
	int s;
	message();
	printf(prompt);
	while(!((s = mouse_status()) & MOUSE_LEFT)) {
		if(s & MOUSE_RIGHT) {
			message();
			return -1; } }
	return 0;
}


draw(value)
	unsigned value;
{
	drawing[dtop++] = value >> 8;
	drawing[dtop++] = value & 255;
}


dvalue()
{
	return (drawing[dpos++] << 8) | drawing[dpos++];
}


zero_drawing(top)
	unsigned top;
{
	dtop = top;
	while(top < sizeof(drawing))
		drawing[top++] = 0;
}

get_value(prompt)
	char *prompt;
{
	unsigned value;
	char buffer[51], *ptr;

	message();
	printf(prompt);
	fgets(ptr = buffer, sizeof(buffer)-1, stdin);
	while(isspace(*ptr))
		++ptr;
	value = 0;
	while(isdigit(*ptr))
		value = (value*10) + (*ptr++ - '0');
	message();
	return value;
}


FILE *get_file(prompt, name, ext, mode)
	char *prompt, *name, *ext, *mode;
{
	int i, dot;
	char buffer[65], *ptr;

	message();
	printf("Enter %s filename (%s)?", prompt, name);
	fgets(ptr = buffer, sizeof(buffer)-1, stdin);
	while(isspace(*ptr))
		++ptr;
	if(*ptr) {
		dot = -1;
		for(i = 0; *ptr; ++i)
			if((name[i] = *ptr++) == '.')
				dot = i;
		name[i] = 0;
		if(dot == -1)
			while(name[i++] = *ext++); }
	message();
	return fopen(name, mode);
}


scale(int value, unsigned mul, int div)
{
	 asm	MOV		AX,8[BP]	
	 asm	MUL		WORD PTR 6[BP]	
	 asm	MOV		BX,4[BP]	
	 asm	DIV		BX		
	 asm	SHR		BX,1		
	 asm	JZ		scale1		
	 asm	INC		DX		
	 asm	SUB		BX,DX		
	 asm	ADC		AX,0		
scale1:
}

init_video()
{

	 asm	MOV		AH,0Fh			
	 asm	INT		10h				
	 asm	MOV		DGRP:_vmode,AL	

	 asm	MOV		AX,1A00h		
	 asm	INT		10h			
	 asm	CMP		AL,1Ah			
	 asm	MOV		AL,-1			
	 asm	JZ		initv1			
	 asm	XOR		AX,AX	
initv1:		
}

video_mode(int mode)
{
	 asm	MOV		AL,4[BP]		
	 asm	XOR		AH,AH			
	 asm	INT		10h			
}


init_mouse()
{
	 asm	XOR		AX,AX			
	 asm	INT		33h				
	 asm	AND		AX,AX			
	 asm	JZ		initm1			

	 asm	XOR		CX,CX			
	 asm	MOV		DX,639			
	 asm	MOV		AX,7			
	 asm	INT		33h				
	 asm	MOV		DX,479			
	 asm	MOV		AX,8			
	 asm	INT		33h				
	 asm	MOV		AX,-1			
initm1:
}


set_pixel(int x, int y)
{
	 asm	MOV		DX,4[BP]		
	 asm	CMP		DX,VERTICAL		
	 asm	JAE		noset			
	 asm	MOV		CX,6[BP]		
	 asm	CMP		CX,HORIZONTAL	
	 asm	JAE		noset			
	 asm	MOV		AH,0Ch			
	 asm	MOV		AL,DGRP:_pixel	
	 asm	XOR		BH,BH			
	 asm	INT		10h				
noset:
}


gotoxy(x, y)
{
	 asm	MOV		DH,4[BP]		
	 asm	MOV		DL,6[BP]		
	 asm	XOR		BH,BH			
	 asm	MOV		AH,02h			
	 asm	INT		10h				
}

test_key()
{
	 asm	MOV		AH,01h			
	 asm	INT		16h				
	 asm	JNZ		getk1			
	 asm	XOR		AX,AX	
	 asm    JMP		endp:
	 getk1:
	 asm	 		_get_key
	 endp:
	 
	 
	 
}


get_key()
{
getk1:	asm 	XOR		AH,AH			
	asm	INT		16h				
	asm 	XOR		AH,AH			
}


mouse_status()
{
	int x, y, z;

	if(!cursor_flag) {
newcursor:
		draw_cursor();
		cursor_flag = -1; }
	asm {
		MOV		AX,0003h	
		INT		33h			
		MOV		-2[BP],BX	
		MOV		-4[BP],DX	
		MOV		-6[BP],CX	
		}

	if(snap) {
		x = (x / snap) * snap;
		y = (y / snap) * snap; }

	if((x != mousex) || (y != mousey)) {
		draw_cursor();
		gotoxy(68, 0);
		printf("X=%-3d Y=%-3d", (mousex = x) - xbase, (mousey = y) - ybase);
		goto newcursor; }

	
	if(z & (MOUSE_LEFT|MOUSE_RIGHT|MOUSE_CENTER)) {
	mloop1:		asm {
			
					MOV		AX,0003h		
					INT		33h				
					AND		BL,07h			
					JNZ		mloop1			
			}
		draw_cursor();
		cursor_flag = 0; }

	/* Pass back button status to caller */
	return z;
}