/*
*
*  rg9.c by Aaron Contorer for NCSA
*
*  graphics routines for drawing on Number Nine card
*  Input coordinate space = 0..4095 by 0..4095
*  MUST BE COMPILED WITH LARGE MEMORY MODEL!
* 
*  RG9 = routines callable from outside
*  NO9 = routines for internal use only
*
*/

#include <stdio.h>	/* used for debugging only */
#include <stdlib.h>
#include <dos.h>	/* used for NO9 init call */
#if defined(MSC) && !defined(__TURBOC__) && !defined(__WATCOMC__)
#include <memory.h>
#else
#include <string.h>
#endif
#include "externs.h"

#define TRUE 1
#define FALSE 0
#define INXMAX 4096
#define INXSHIFT 12
#define INYMAX 4096
#define INYSHIFT 12
#define MAGNIFY 1000
#define SCRNXHI 511
#define SCRNYHI 479
#define MAXWIN 32		/* max. number of windows */
#define NO9xmax 512 	/* max. number of pixels in the x direction */
#define NO9ymax 480		/* max. number of pixels in the y direction */

static int NO9active;		/* number of currently NO9active window */
static unsigned char *NO9ram;
static int *NO9bank; 		/* bank control registers */
#ifdef OLD_WAY
static unsigned char power2[8]={1,2,4,8,16,32,64,128};
#endif
static char *NO9name="Number Nine, 512 x 480";
static void clrbuf(unsigned int bank);
static void NO9point(int ,int );
static void NO9setup(void );

/* Current status of an NO9 window */
struct NO9WIN 
{
	char inuse; 							/* true if window in use */
	int pencolor, rotation, size;
	int winbot,winleft,wintall,winwide;		/* position of the window in virtual space */
};

static struct NO9WIN NO9win[MAXWIN];

static void NO9setup(void )         /* prepare variables for use in other functions */
{
#if defined(MSC) && !defined(__TURBOC__) && !defined(__WATCOMC__)
	FP_SEG(NO9ram) = 0xA000;  FP_OFF(NO9ram) = 0;
	FP_SEG(NO9bank) = 0xC070;  FP_OFF(NO9bank) = 5;
#else
    NO9ram=(char *)MK_FP(0xA000,0);
    NO9bank=(int *)MK_FP(0xC070,5);
#endif
}

static void clrbuf(unsigned int bank)
{
	*NO9bank=bank;
	memset(NO9ram,0,0xFFFF);
	NO9ram[0xFFFF]=0;
}

void RG9gmode(void)         /* go into NO9 graphics mode -- not yet implemented */
{
	clrbuf(0x0000);
	clrbuf(0x00ff);
	clrbuf(0xff00);
	clrbuf(0xffff);
}

void RG9tmode(void)         /* go into NO9 text mode -- not supported */
{ }

/* draw a line from (x0,y0) to (x1,y1) */
/* uses Bresenham's Line Algorithm */
void RG9drawline(int w,int x0,int y0,int x1,int y1)
{
	int x,y,dx,dy,d,temp,
	dx2,dy2,			/* 2dx and 2dy */
	direction;		/* +1 or -1, used for slope */
	char transpose;	/* true if switching x and y for vertical-ish line */

	if(w!=NO9active) 
		return;
	x0=(int)(((long)x0*NO9xmax)>>INXSHIFT);
	y0=NO9ymax-1-(int)(((long)y0*NO9ymax)>>INYSHIFT);
	x1=(int)(((long)x1*NO9xmax)>>INXSHIFT);
	y1=NO9ymax-1-(int)(((long)y1*NO9ymax)>>INYSHIFT);
	if(abs(y1-y0)>abs(x1-x0)) {				/* transpose vertical-ish to horizontal-ish */
		temp=x1;
		x1=y1; 
		y1=temp;
		temp=x0; 
		x0=y0; 	
		y0=temp;
		transpose=TRUE;
	  } 
	else 
		transpose=FALSE;				
	if(x1<x0){						/* make sure line is left to right */
		temp=x1; 
		x1=x0; 
		x0=temp; 
		temp=y1; 
		y1=y0; 
		y0=temp;
	  }		
/* SPECIAL CASE: 1 POINT */
	if(x1==x0&&y1==y0) { 
		NO9point(x1,y1);
		return;
	  }        
/* ANY LINE > 1 POINT */
	x=x0;
	y=y0;
	dx=x1-x0;
	if(y1>=y0) {
		dy=y1-y0;
		direction=1;
	  } 
	else {
		dy=y0-y1;
		direction=-1;
	  }
	dx2=dx<<1;
	dy2=dy<<1;
	d=(dy<<1)-dx;
	if(transpose) {		/* CASE OF VERTICALISH (TRANSPOSED) LINES */
		while(x<=x1) {
			if(y>=0&&y<NO9xmax&&x>=0&&x<NO9ymax)
				NO9point(y,x);
			while(d>=0) {
				y+=direction;
				d-=dx2;
			  }
			d+=dy2;
			x++;
		  } 
	  } 
	else {			/* CASE OF HORIZONTALISH LINES */
		while(x<=x1) {
			if(x>=0&&x<NO9xmax&&y>=0&&y<NO9ymax)
				NO9point(x,y);
			while(d>=0) {
				y+=direction;
				d-=dx2;
			  }
			d+=dy2;
			x++;
		  }
	  }				 /* end horizontalish */
}   /* end NO9rasline() */

/*
	Clear the screen.
*/
void RG9clrscr(int w)
{
	if(w==NO9active) {
		NO9setup();
		RG9gmode();
	  }
}

/*
	Set up a new window; return its number.
	Returns -1 if cannot create window.
*/
int RG9newwin(void)
{
	int w=0;

	while(w<MAXWIN && NO9win[w].inuse) 
		w++;
	if(w==MAXWIN) 
		return(-1); 			/* no windows available */
	NO9win[w].pencolor=7;
	NO9win[w].winbot=0;
	NO9win[w].wintall=3120;
	NO9win[w].winleft=0;
	NO9win[w].winwide=4096;
	NO9win[w].inuse=TRUE;
	return(w);
}

void RG9close(int w)
{
	if(NO9active==w) {
		RG9clrscr(w);
		NO9active=-1;
	  }
	NO9win[w].inuse=FALSE;
}

/*
	set point at real pixel x,y
*/
static void NO9point(int x,int y)
{
	unsigned int bank,loc;

	y+=16; 					/* map 480 lines onto 512 lines */
	if(y&256) 
		bank=0xff00;
	else
		 bank=0;
	if(y&128)
		bank|=0x00ff;
	*NO9bank=bank;		
	loc=((y&0x7f)<<9)+x;
	NO9ram[loc]=255; 		/* only drawing in color 255 */
}

/* set pixel at location (x,y) -- no range checking performed */
void RG9point(int w,int x,int y)
{
	int x2,y2; 				/* on-screen coordinates */

	if(w==NO9active) {
		x2=(int)(((long)x*NO9xmax)>>INXSHIFT);
		y2=SCRNYHI-(int)(((long)y*NO9ymax)>>INYSHIFT);
		NO9point(x2,y2);
	  }
}  

/*
	Do whatever has to be done when the drawing is all done.
	(For printers, that means eject page.)
*/
void RG9pagedone(int w)
{
	/* do nothing for NO9 */
	w=w;
}

/*
	Copy 'count' bytes of data to screen starting at current
	cursor location.
*/
void RG9dataline(int w,char *data,int count)
{
	/* Function not supported yet. */
	w=w;
	data=data;
	count=count;
}

/*
	Change pen color to the specified color.
*/
void RG9pencolor(int w,int color)
{
	/* Function not supported yet. */
	w=w;
	color=color;
}

/*
	Set description of future device-supported graphtext.
	Rotation=quadrant.
*/
void RG9charmode(int w,int rotation,int size)
{
	/* No rotatable device-supported graphtext is available on NO9. */
	w=w;
	rotation=rotation;
	size=size;
}


/* Not yet supported: */
void RG9showcur(void ) {}
void RG9lockcur(void ) {}
void RG9hidecur(void ) {}

/* Ring bell in window w */
void RG9bell(int w)
{
	if(w==NO9active) 
		putchar(7);
}

/* return name of device that this RG supports */
char *RG9devname(void )
{
	return(NO9name);
}

/* initialize all RG9 variables */
void RG9init(void )
{
	int i;
	NO9setup();
	for(i=0; i<MAXWIN; i++) {
		NO9win[i].inuse=FALSE;
	  }
	NO9active=-1;
}

/*
	Make this window visible, hiding all others.
	Caller should follow this with clrscr and redraw to show the current
	contents of the window.
*/
void RG9uncover(int w)
{
	NO9active=w;
}

/* Needed for possible future functionality */
void RG9info(int w,int a,int b,int c,int d,int v)
{
	w=w;
	a=a;
	b=b;
	c=c;
	d=d;
	v=v;
}