/*
*
*  rgep.c by Aaron Contorer for NCSA
*
*  graphics routines for drawing on Epson printer
*  Input coordinate space = 0..4095 by 0..4095
*  MUST BE COMPILED WITH LARGE MEMORY MODEL!
*
*/

#include <stdio.h>	/* used for debugging only */
#include <stdlib.h>
#ifdef MSC
#ifdef __TURBOC__
#include <alloc.h>
#else
#include <malloc.h>
#endif
#endif
#include "externs.h"

#define TRUE 1
#define FALSE 0
#define INXMAX 4096
#define INYMAX 4096
#define SCRNXHI 719
#define ROWS 90
#define SCRNYHI 929
#define LINEBYTE 930
#define MAXRW 1		/* max. number of real windows */

static int EPSactive; /* number of currently active window */
static unsigned char EPSpbit[SCRNXHI+1];
#ifdef OLD_WAY
static unsigned char power2[8]={1,2,4,8,16,32,64,128};
#endif
static char *EPSname="Epson, IBM, or compatible printer";
static int EPSxmax=720;
static int EPSymax=LINEBYTE;
#ifdef OLD_WAY
static int EPSbytes=80;	/* number of bytes per line */
#endif
static unsigned char *EPSram[ROWS];
static void (*EPSoutfunc)(char c);
static void signore(char c);
static void EPSpoint(int x,int y);
static void EPSdump(void );
static void EPSsetup(void );

/* Current status of an EPS window */
struct EPSWIN 
{
	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 EPSWIN EPSwins[MAXRW];

/* prepare variables for use in other functions */
static void EPSsetup(void )
{
	int x;
	EPSpbit[0]=128; 
	EPSpbit[1]=64; 
	EPSpbit[2]=32; 
	EPSpbit[3]=16;
	EPSpbit[4]=8;   
	EPSpbit[5]=4;  
	EPSpbit[6]=2;  
	EPSpbit[7]=1;
	for(x=8; x<=SCRNXHI; x++) 
		EPSpbit[x]=EPSpbit[x&7];
}

/* go into EPS graphics mode */
void RGEPgmode(void )
{
}

/* go into EPS text mode */
void RGEPtmode(void )
{
}

/*
	Clear the screen.
*/
void RGEPclrscr(int w)
{
	if(w==EPSactive)
		EPSsetup();
}

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

	for(x=0; x<ROWS; x++) {
		if((EPSram[x]=malloc(LINEBYTE))==NULL) {	/* ran out of memory, free what we have now */
			for(; x>=0; x--)
				free(EPSram[x]);
			return(-1);
		  }	/* end if */
		for(y=0; y<LINEBYTE; y++) 
			(EPSram[x])[y]=0;
	  }
	while(w<MAXRW&&EPSwins[w].inuse) 
		w++;
	if(w==MAXRW) 
		return(-1); /* no windows available */
	EPSwins[w].pencolor=7;
	EPSwins[w].winbot=0;
	EPSwins[w].wintall=3120;
	EPSwins[w].winleft=0;
	EPSwins[w].winwide=4096;
	EPSwins[w].inuse=TRUE;
	return(w);
}

void RGEPclose(int w)
{
	if(EPSactive==w) {
		RGEPclrscr(w);
		EPSactive=-1;
	  }
	EPSdump();
	EPSwins[w].inuse=FALSE;
}

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

	if(w==EPSactive) {
		x2=(int)((long)x*EPSxmax/INXMAX);
		y2=(int)((long)y*EPSymax/INYMAX);
		EPSpoint(x2,y2);
	  }
}  

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

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

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

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

/* Not yet supported: */
void RGEPshowcur(void) {}
void RGEPlockcur(void) {}
void RGEPhidecur(void) {}

/*
	Set bit at x,y
*/
static void EPSpoint(int x,int y)
{
	(EPSram[x>>3])[y]|=EPSpbit[x];
}

/* draw a line from (x0,y0) to (x1,y1) */
/* uses Bresenham's Line Algorithm */
void RGEPdrawline(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!=EPSactive) 
		return;
	x0=(int)((long)x0*EPSxmax/INXMAX);
	y0=(int)((long)y0*EPSymax/INYMAX);
	x1=(int)((long)x1*EPSxmax/INXMAX);
	y1=(int)((long)y1*EPSymax/INYMAX);

	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;			/* make sure line is left to right */
	if(x1<x0) {
		temp=x1; 
		x1=x0; 
		x0=temp; 
		temp=y1; 
		y1=y0; 
		y0=temp;
	  }
									/* SPECIAL CASE: 1 POINT */
	if(x1==x0&&y1==y0) { 
		EPSpoint(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<EPSxmax&&x>=0&&x<EPSymax)
				EPSpoint(y,x);
			while(d>=0) {
				y+=direction;
				d-=dx2;
			  }
			d+=dy2;
			x++;
		  } 
	  } 
	else {				/* CASE OF HORIZONTALISH LINES */
		while(x<=x1) {
			if(x>=0&&x<EPSxmax&&y>=0&&y<EPSymax)
				EPSpoint(x,y);
			while(d>=0){
				y+=direction;
				d-=dx2;
			  }
			d+=dy2;
			x++;
		  }
	  } 				/* end horizontalish */
}   /* end RGEPdrawline() */

/* Ring bell in window w */
void RGEPbell(int w)
{
	w=w;
}

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

/* Ignore the character pointer passed here. */
static void signore(char s)
{
	s=s;
}

/* initialize all RGEP variables */
void RGEPinit(void )
{
	int i;
	EPSsetup();
	for(i=0; i<MAXRW; i++) 
		EPSwins[i].inuse=FALSE;
	EPSactive=-1;
	EPSoutfunc=signore;
}

/*
	Specify the function that is to be called with pointers to all
	the printout strings.
*/
void RGEPoutfunc(void (*f)(char ))
{
	EPSoutfunc=f;
}

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

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

/*
*	Dump the contents of the buffer to the specified function.
*/
static void EPSdump(void )
{
	int x,y;
	int size=EPSymax*2;

	for(x=0;x<90;x++) {				/* init graphics mode */
		(*EPSoutfunc)(033);
		(*EPSoutfunc)('L');
		(*EPSoutfunc)((char)(size&255));
		(*EPSoutfunc)((char)(size>>8));		/* send a line of bit image data */
		for(y=0; y<size; y++) 
			(*EPSoutfunc)((EPSram[x]) [y]);
									/* go to next line */
		(*EPSoutfunc)(13);
		(*EPSoutfunc)(033);
		(*EPSoutfunc)('J');
		(*EPSoutfunc)(24);
	  }
	(*EPSoutfunc)(12); /* form feed */
}