/*
	strmflow.c

	sf1.bat = cl /AL strmflow.c julday vimage3 graphlib

*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "mouseg.h"
#include "vimage.h"
#include "font.h"

#define BUFF       0
#define D_GREY     1
#define M_GREY     2
#define L_GREY     3
#define WHITE      4
#define RED        5
#define ORANGE     6
#define YELLOW     7
#define M_BUFF     8
#define CYAN       9
#define BLUE      10
#define L_BUFF    11
#define BUFF2     12
#define BROWN     13
#define D_BLUE    14
#define BLACK     15

int day_1[2][12]=
{
	{  0,31,61,92,123,151,182,212,243,273,304,335},
	{  0,31,61,92,123,152,183,213,244,274,305,336}
};
int day_2[2][13]=
{
	{ 30,60,91,122,150,181,211,242,272,303,334,364},
	{ 30,60,91,122,151,182,212,243,273,304,335,365}
};
char *MName[12]=
{	"October","November","December","January","February","March",
	"April","May","June","July","August","September"
};
struct Color Vcolor[16]=
{
	{ 105, 90, 75},
	{  46, 46, 46},
	{ 128,128,128},
	{ 191,191,191},
	{ 255,255,255},
	{ 255,  0,  0},
	{ 255,128,  0},
	{ 191,191,  0},
	{ 110, 95, 78},
	{   0,191,191},
	{  40, 40,255},
	{ 128,110, 91},
	{  95, 81, 67},
	{  96, 28, 14},
	{   0, 30, 90},
	{   0,  0,  0}
};

int ScreenXs,ScreenYs;
int Mouse=0;
float Data[31][12];
float Flow[366];
struct stat
{
	char name[50];
	float area,elev;
	float lat,lon;
	int numyr,yr1,yrlast;
	float maxflow,minflow,msngval;
	float momaxmean,mominmean;
}S;
unsigned char Buffer[1024];

int plot_data();
int plot_file(char *name,FILE *fp);
int plot_daily(int xc,int yc,int xs,int ys,FILE *fp,int yr1,int yr2,char iop);
int make_binary();
int process_adv(char *name,FILE *fpadv);
long jday(int mo,int da,int yr);
int set_lut();
int video_off();
int video_on();
int plot_month(int xc,int yc,int xs,int ys,FILE *fp,int yr1,int yr2);
int xor_line(int plane,int x1,int y1,int x2,int y2,unsigned char *buffer);
int plot_map(int xs,int ys);
int plot_line(char *name,int color,float maxlat,float minlon,float pix);

main(int agrc,char *argv[])

{
	char ans;

	if(mouse_initialize(4))
	{
		printf("Mouse initialized.\n\n");
		Mouse=4;	/* sensitivity set to maximum (1 is minimum) */
	}
	else
	{
		printf(
"\n\n\n\nNO MOUSE FOUND -- YOU MUST HAVE A MOUSE TO RUN THIS PROGRAM\n\n\n");
		exit(0);
	}
	mouse_vertical_range(0,ScreenYs-1);
	mouse_horizontal_range(0,ScreenXs-1);
	do
	{
		printf("   b -- make binary files\n");
		printf("   p -- plot\n");
		printf("\n   x -- exit program\n\n");
		ans=getch();
		if(ans=='b')
			make_binary();
		if(ans=='p')
			plot_data();
	}while(ans!='x'&&ans!=27);
}

/**********************************************************************
**
**
**
**********************************************************************/

int plot_data()

{
	int i,j,k;
	int num=0;
	FILE *fp;
	char name[100],string[100];

	while((num=get_file_name("*.bsf",name,num))>=0)
	{
		fp=fopen(name,"rb");
		if(fp)
		{
			plot_file(name,fp);
			fclose(fp);
		}
		else
			printf("Could not open '%s' to read data.\n\n",name);
	}
}

/**********************************************************************
**
**
**
**********************************************************************/

int plot_file(char *name,FILE *fp)

{
	int i,j,k;
	int xc1=319,yc1= 15,xs1=320,ys1=120;
	int xc2=319,yc2=135,xs2=320,ys2=120;
	int xc3=  0,yc3=312,xs3=640,ys3=140,yr1,yr2;
	char ans,string[100];
	char iop='l';

	fread((char *)&S,sizeof(struct stat),1,fp);
	video_on();
	plot_map(310,310);
	yr1=(S.yrlast+S.yr1)/2-1;
	yr2=(S.yrlast+S.yr1)/2+1;
	plot_daily(xc1,yc1,xs1,ys1,fp,S.yr1,S.yrlast,iop);
	plot_daily(xc3,yc3,xs3,ys3,fp,yr1,yr2,iop);
	plot_month(xc2,yc2,xs2,ys2,fp,S.yr1,S.yrlast);
	plot_font_h(L_GREY,320,260,S.name,2,Font);
	sprintf(string,"Drainage Area = %0.1f Elevation = %0.1f",S.area,S.elev);
	plot_font_h(L_GREY,320,275,string,2,Font);
	sprintf(string,"Lat = %0.5f Lon = %0.5f",S.lat,S.lon);
	plot_font_h(L_GREY,320,290,string,2,Font);
	plot_font_h(L_GREY,0,464,
	"<--> Change years  Up=less Dn=more  l=log n=normal",
		2,Font);
	do
	{
		ans=getch();
		if(ans=='l'&&iop=='n')
		{
			iop='l';
			plot_daily(xc1,yc1,xs1,ys1,fp,S.yr1,S.yrlast,iop);
			plot_daily(xc3,yc3,xs3,ys3,fp,yr1,yr2,iop);
		}
		if(ans=='n'&&iop=='l')
		{
			iop='n';
			plot_daily(xc1,yc1,xs1,ys1,fp,S.yr1,S.yrlast,iop);
			plot_daily(xc3,yc3,xs3,ys3,fp,yr1,yr2,iop);
		}
		if(ans==0)
		{
			ans=getch();
			if(ans==77&&yr2<S.yrlast)
			{
				yr1+=1;
				yr2+=1;
			}
			if(ans==75&&yr1>S.yr1)
			{
				yr1-=1;
				yr2-=1;
			}
			if(ans==72&&yr2>yr1)
				yr2-=1;
			if(ans==80)
			{
				yr1-=1;
				yr2+=1;
			}
			if(yr2<yr1)
				yr2=yr1;
			if(yr1<S.yr1)
				yr1=S.yr1;
			if(yr2>S.yrlast)
				yr2=S.yrlast;
			plot_daily(xc3,yc3,xs3,ys3,fp,yr1,yr2,iop);
		}
	}while(ans!=27);
	video_off();
}

/**********************************************************************
**
**
**
**********************************************************************/

int plot_map(int xs,int ys)

{
	int i,j,k;
	char string[100],name[100];
	int color;
	double pix,lat,lon;
	int screenxs=ScreenXs,screenys=ScreenYs;
	FILE *fplin,*fp,*fphdr;

	ScreenXs=xs;
	ScreenYs=ys;
	fplin=fopen("hydro.lin","rt");
	if(!fplin)
	{
		ScreenXs=screenxs;
		ScreenYs=screenys;
		return(-1);
	}
	fscanf(fplin,"%lf%lf%lf",&pix,&lat,&lon);
	while(fscanf(fplin,"%s%d",name,&color)==2)
	{
		plot_line(name,color,lat,lon,pix);
	}
	ScreenXs=screenxs;
	ScreenYs=screenys;
}

/**********************************************************************
**
**
**
**********************************************************************/

int plot_line(char *name,int color,float maxlat,float minlon,float pix)

{
	int i,j,k;
	int secnum,numpt,numsec,doit;
	int ix,iy,ixo,iyo;
	FILE *fp,*fphdr;
	char string[100];
	double lat;
	float dely=111.0/pix,delx;
	float minlat=maxlat-(float)ScreenYs/dely;
	float maxlon;
	float latlon[2],mll[4],mnln,mxln,mnlt,mxlt;
	long offset;

	lat=(maxlat+minlat)/2.0;
	delx=dely*cos(lat);
	maxlon=minlon+(float)ScreenXs/delx;
	sprintf(string,"%s.hdr",name);
	fphdr=fopen(string,"rb");
	if(!fphdr)
		return(0);
	sprintf(string,"%s.bin",name);
	fp=fopen(string,"rb");
	if(!fp)
	{
		fclose(fphdr);
		return(-2);
	}
	fread((char *)&numsec,sizeof(int),1,fphdr);
	fread((char *)&numsec,sizeof(int),1,fp);
	for(j=0;j<numsec;j++)
	{
		fread((char *)&offset,sizeof(long),1,fphdr);
		fread((char *)mll,sizeof(float),4,fphdr);
		doit=1;
		mnln=mll[0];mxln=mll[1];mnlt=mll[2];mxlt=mll[3];
		if(mnln>maxlon||mnlt>maxlat||mxln<minlon||mxlt<minlat)
			doit=0;
		if(doit==1)
		{
			fseek(fp,offset,SEEK_SET);
			fread((char *)&numpt,sizeof(int),1,fp);
			fread((char *)mll,sizeof(float),4,fp);
			for(i=0;i<numpt;i++)
			{
				fread((char *)latlon,sizeof(float),2,fp);
				if(doit==1)
				{
					ix=(latlon[1]-minlon)*delx;
					iy=(maxlat-latlon[0])*dely;
					if(i!=0)
						plotln(0,ixo,iyo,ix,iy,color);
					ixo=ix;iyo=iy;
				}
			}
		}
	}
	fclose(fp);
	fclose(fphdr);
}


/**********************************************************************
**
**
**
**********************************************************************/

int plot_month(int xc,int yc,int xs,int ys,FILE *fp,int yr1,int yr2)

{
	int i,j,k;
	int ix,iy,size=2,ixo,iyo;
	float x,y;
	float delyr,delmo,delda,mean,num;
	double dval,srange;
	float range,min,dely=200000;
	char string[100];
	int leap,year,numyr;

	ys-=15;
	numyr=yr2-yr1+1;
	if(numyr>25)
		size=3;
	delyr=(float)xs/(float)numyr;
	delmo=delyr/12.0;
	delda=delyr/366.0;
	min=S.mominmean;
	range=(S.momaxmean-S.mominmean)/(float)(ys-1);
	paint_box(0,BUFF,Buffer,xc,yc,xs,ys+15);
	ixo=iyo=-1;
	for(i=0;i<numyr;i++)
	{
		x=(float)(i+1)*delyr;
		ix=x+xc;
		plotln(0,ix,yc,ix,yc+ys-1,L_BUFF);
		if(numyr<25||(S.yr1+i)%5==0)
		{
			iy=S.yr1+i;
			iy%=100;
			sprintf(string,"%d",iy);
			x=(float)i*delyr+delyr/2.0;
			ix=(int)x-15/size+xc;
			plot_font_h(L_GREY,ix,yc+ys+3,string,size,Font);
		}
	}
	box(0,xc,yc,M_GREY,xs-1,ys-1);
	srange=S.momaxmean-S.mominmean;
	if(srange<600000)dely=100000;
	if(srange<400000)dely= 50000;
	if(srange<120000)dely= 20000;
	if(srange<60000)dely=10000;
	if(srange<40000)dely= 5000;
	if(srange<12000)dely= 2000;
	if(srange<6000)dely=1000;
	if(srange<4000)dely= 500;
	if(srange<1200)dely= 200;
	if(srange<600)dely=100;
	if(srange<400)dely= 50;
	if(srange<120)dely= 20;
	if(srange<60)dely=10;
	if(srange<40)dely= 5;
	if(srange<12)dely= 2;
	if(srange<6)dely=1;
	dval=0.0;
	do
	{
		if(dval>S.mominmean)
		{
			iy=(float)(yc+ys)-
				(dval-min)/range;
			plotln(0,xc,iy,xc+xs-1,iy,L_BUFF);
			sprintf(string,"%0.0lf",dval);
			plot_font_h(L_GREY,xc+3,iy-4/size,string,3,Font);
			sprintf(string,"%10.0lf",dval);
			plot_font_h(L_GREY,xc+xs-53,iy-4/size,string,3,Font);
		}
		dval+=dely;
	}while(dval<S.momaxmean);
	plot_font_h(L_GREY,xc+2,yc+2,"monthly mean",size,Font);
	rewind(fp);
	fread((char *)&S,sizeof(struct stat),1,fp);
	for(i=0;i<S.numyr;i++)
	{
		fread((char *)&year,sizeof(int),1,fp);
		fread((char *)Flow,sizeof(float),366,fp);
		for(j=0;j<12;j++)
		{
			leap=year%4==0&&year%100!=0||year%400==0;
			num=0.0;
			mean=0.0;
			for(k=day_1[leap][j];k<=day_2[leap][j];k++)
			{
				if(Flow[k]!=S.msngval)
				{
					num+=1;
					mean+=Flow[k];
				}
			}
			if(num>0.0)
			{
				mean/=num;
				x=(float)(year-yr1)*delyr+(float)j*delmo+delmo/2;
				ix=x+xc;
				iy=(float)(yc+ys)-
					(mean-S.mominmean)/(S.momaxmean-S.mominmean)*(float)ys;
				if(ixo>=0)
					plotln(0,ixo,iyo,ix,iy,D_BLUE);
				ixo=ix;
				iyo=iy;
			}
		}		
	}
}

/**********************************************************************
**
**
**
**********************************************************************/

int plot_daily(int xc,int yc,int xs,int ys,FILE *fp,int yr1,int yr2,char iop)

{
	int i,j,k,da;
	int ix,iy,size=2,ixo,iyo;
	float x,y;
	float delyr,delda,delmo,mean,num;
	float range,min,srange,dely=200000;
	char string[100];
	int leap,year,numyr,yearo=-1;
	double dval;

	ys-=15;
	if(S.minflow<=0.0)
		iop='n';
	if(iop=='l')
	{
		min=log((double)S.minflow);
		range=(log((double)S.maxflow)-log((double)S.minflow))/(float)(ys-1);
	}
	else
	{
		min=S.minflow;
		range=(S.maxflow-S.minflow)/(float)(ys-1);
	}
	numyr=yr2-yr1+1;
	if(numyr>25)
		size=3;
	delyr=(float)xs/(float)numyr;
	delda=delyr/366.0;
	delmo=delyr/12.0;
	paint_box(0,BUFF,Buffer,xc,yc,xs,ys+15);

	for(i=0;i<numyr;i++)
	{
		x=(float)(i+1)*delyr;
		ix=x+xc;
		plotln(0,ix,yc,ix,yc+ys-1,L_BUFF);
		if(numyr<25||(yr1+i)%5==0)
		{
			iy=yr1+i;
			iy%=100;
			sprintf(string,"%d",iy);
			x=(float)i*delyr+delyr/2.0;
			ix=(int)x-15/size+xc;
			plot_font_h(L_GREY,ix,yc+ys+3,string,size,Font);
		}
		if(numyr<6)
		{
			leap=year%4==0&&year%100!=0||year%400==0;
			for(j=0;j<12;j++)
			{
				ix=(float)i*delyr+(float)day_2[leap][j]*delda;
				if(j<11)
					plotln(0,ix,yc,ix,yc+ys-1,M_BUFF);
				sprintf(string,"%c",MName[j][0]);
				ix=(float)i*delyr+(float)day_2[leap][j]*delda-delmo/2-7/size;
				plot_font_h(M_GREY,ix,yc+3,string,size,Font);
			}
		}
	}
	if(iop=='l')
	{
		dval=0.1;
		do
		{
			if(dval>S.minflow)
			{
				iy=(float)(yc+ys)-
					(log(dval)-min)/range;
				plotln(0,xc,iy,xc+xs-1,iy,L_BUFF);
				sprintf(string,"%0.0lf",dval);
				plot_font_h(L_GREY,xc+3,iy-4/size,string,3,Font);
				sprintf(string,"%10.0lf",dval);
				plot_font_h(L_GREY,xc+xs-53,iy-4/size,string,3,Font);
			}
			dval*=10;
		}while(dval<S.maxflow);
	}
	else
	{
		srange=S.maxflow-S.minflow;
		if(srange<600000)dely=100000;
		if(srange<400000)dely= 50000;
		if(srange<120000)dely= 20000;
		if(srange<60000)dely=10000;
		if(srange<40000)dely= 5000;
		if(srange<12000)dely= 2000;
		if(srange<6000)dely=1000;
		if(srange<4000)dely= 500;
		if(srange<1200)dely= 200;
		if(srange<600)dely=100;
		if(srange<400)dely= 50;
		if(srange<120)dely= 20;
		if(srange<60)dely=10;
		if(srange<40)dely= 5;
		if(srange<12)dely= 2;
		if(srange<6)dely=1;
		dval=0.0;
		do
		{
			if(dval>S.minflow)
			{
				iy=(float)(yc+ys)-
					(dval-min)/range;
				plotln(0,xc,iy,xc+xs-1,iy,L_BUFF);
				sprintf(string,"%0.0lf",dval);
				plot_font_h(L_GREY,xc+3,iy-4/size,string,3,Font);
				sprintf(string,"%10.0lf",dval);
				plot_font_h(L_GREY,xc+xs-53,iy-4/size,string,3,Font);
			}
			dval+=dely;
		}while(dval<S.maxflow);
	}
	box(0,xc,yc,M_GREY,xs-1,ys-1);
	if(iop=='l')
		plot_font_h(L_GREY,xc+2,yc+2+30/size,"ln daily",size,Font);
	else
		plot_font_h(L_GREY,xc+2,yc+2+30/size,"daily",size,Font);
	rewind(fp);
	fread((char *)&S,sizeof(struct stat),1,fp);
	ixo=iyo=-1;
	for(i=0;i<S.numyr;i++)
	{
		fread((char *)&year,sizeof(int),1,fp);
		if(yearo>0&&year-yearo>1)
			ixo=-1;
		yearo=year;
		fread((char *)Flow,sizeof(float),366,fp);
		if(year>=yr1&&year<=yr2)
		{
			da=0;
			for(j=0;j<12;j++)
			{
				leap=year%4==0&&year%100!=0||year%400==0;
				for(k=day_1[leap][j];k<=day_2[leap][j];k++)
				{
					if(Flow[k]!=S.msngval)
					{
						x=(float)(year-yr1)*delyr+(float)da*delda+delda/2.0;
						ix=x+xc;
						if(iop=='l')
							iy=(float)(yc+ys)-
								(log((double)Flow[k])-min)/range;
						else
							iy=(float)(yc+ys)-
								(Flow[k]-min)/range;
						if(ixo>=0)
							plotln(0,ixo,iyo,ix,iy,D_BLUE);
						ixo=ix;
						iyo=iy;
					}
					da+=1;
				}
			}		
		}
	}
}




/**********************************************************************
**
**
**
**********************************************************************/

int make_binary()

{
	int i,j,k;
	int num=0,hit;
	char string[250],name[100],str1[50];
	FILE *fpadv,*fpbsf,*fpnam;

	while((num=get_file_name("*.adv",name,num))>=0)
	{
		fpadv=fopen(name,"rt");
		if(fpadv)
		{
			for(k=0;k<strlen(name);k++)
				if(name[k]=='.')
					name[k]='\0';
			fpnam=fopen("hydro.name","rt");
			if(!fpnam)
			{
				printf(
				"Could not open 'hydro.nam' (made by hygrf.c) to read names.\n");
			}
			else
			{
				hit=0;
				while(fgets(string,250,fpnam))
				{
					sscanf(string,"%s",str1);
					if(strcmpi(str1,name)==0)
					{
						sscanf(string,"%s%s%f%f%f%f",
							str1,S.name,&S.lat,&S.lon,&S.area,&S.elev);
						printf("%s\n",S.name);
						printf("lat = %9.5f %10.5f\n",S.lat,S.lon);
						printf("area = %8.1f elev = %10.1f\n",S.area,S.elev);
						hit=1;
						break;
					}
				}
				if(hit==0)
					printf("No MATCH found for '%s'\n",name);
				fclose(fpnam);
			}
			process_adv(name,fpadv);
			fclose(fpadv);
		}
		else
			printf("Could not open '%s' to read data.\n\n",name);
	}

}


/**********************************************************************
**
**
**
**********************************************************************/

int process_adv(char *name,FILE *fpadv)

{
	int i,j,k,c=0;
	char string[200],cr=0xd;
	int eof=0,yrs=0;
	int mo,da,yr;
	long jd;
	FILE *fpbsf;
	float num,mean;
	int leap,year;

	S.numyr=0;
	S.yrlast=S.yr1=0;
	S.maxflow=S.minflow=S.msngval=-1.0;
	sprintf(string,"%s.bsf",name);
	fpbsf=fopen(string,"wb");
	if(!fpbsf)
	{
		printf("Could not open '%s' to write binary data.\n",string);
		exit(0);
	}
	fwrite((char *)&S,sizeof(struct stat),1,fpbsf);
	do
	{
		for(k=0;k<366;k++)
			Flow[k]=-1.0;
		for(i=0;i<31;i++)
		{
			if(!fgets(string,200,fpadv))
			{
				eof=1;
				break;
			}
			string[ 13]='\0';
			sscanf(string+9,"%d",&yr);
			if(S.yr1==0)
				S.yr1=yr;
			string[ 16]='\0';
			sscanf(string+14,"%d",&da);
			printf("%4d %2d%c",yr,da,cr);
			for(j=0;j<12;j++)
			{
				string[17+j*8+7]='\0';
				if(sscanf(string+17+j*8,"%f",&Data[i][j])<1)
					Data[i][j]=S.msngval;
				if(j<3)
					jd=jday(j+10,i+1,yr-1);
				else
					jd=jday(j-2,i+1,yr);
				k=jd%1000-1;
				if(k<366)
				{
					Flow[k]=Data[i][j];
					if(S.maxflow<0.0)
						S.maxflow=S.minflow=Flow[k];
					if(Flow[k]>S.maxflow)
						S.maxflow=Flow[k];
					if(Flow[k]<S.minflow)
						S.minflow=Flow[k];
				}
			}
		}
		if(eof==0)
		{
			fwrite((char *)&yr,sizeof(int),1,fpbsf);
			fwrite((char *)Flow,sizeof(float),366,fpbsf);
			for(j=0;j<12;j++)
			{
				leap=year%4==0&&year%100!=0||year%400==0;
				num=0.0;
				mean=0.0;
				for(k=day_1[leap][j];k<=day_2[leap][j];k++)
				{
					if(Flow[k]!=S.msngval)
					{
						num+=1;
						mean+=Flow[k];
					}
				}
				if(num>0.0)
				{
					mean/=num;
					if(c==0&&j==0)
					{
						S.mominmean=mean;
						S.momaxmean=mean;
					}
					else
					{
						if(mean>S.momaxmean)
							S.momaxmean=mean;
						if(mean<S.mominmean)
							S.mominmean=mean;
					}
				}
			}		
			yrs+=1;
		}
		c+=1;
	}while(eof==0);
	S.numyr=yrs;
	S.yrlast=yr;
	printf("There %d years of data.\n%d thru %d.\n",
		S.numyr,S.yr1,S.yrlast);
	printf("Min Flow = %0.1f Max Flow = %0.1f\n",S.minflow,S.maxflow);
	printf("MONTHLY:\n");
	printf("Min Flow = %0.1f Max Flow = %0.1f\n",
		S.mominmean,S.momaxmean);
	rewind(fpbsf);
	fwrite((char *)&S,sizeof(struct stat),1,fpbsf);
	fclose(fpbsf);
	return(yrs);
}



/**********************************************************************
**
**
**
**********************************************************************/

long jday(int mo,int da,int yr)

{
	long tday;

	tday=yr%100;
	tday*=1000;
	tday+=day_of_year(yr,mo,da);
	return(tday);
}

/********************************************************************
**
**
**
********************************************************************* */

int set_lut()

{
	int i;
	struct Color lut[256];

	for(i=16;i<256;i++)
	{
		lut[i].r=i;
		lut[i].g=i;
		lut[i].b=i;
	}
	for(i=0;i<16;i++)
	{
		lut[i].r=Vcolor[i].r;
		lut[i].g=Vcolor[i].g;
		lut[i].b=Vcolor[i].b;
	}
	WritePalette(lut); 
}

/**********************************************************************
**
**
**
**********************************************************************/

int video_off()
{
	SetVideoMode(0);
}

/**************************************************************************
**
**
**
************************************************************************* */

int video_on()

{
	int i,row;

	i=GetVideoBoardID();
	if(i==0)
		VideoType='E';
	else if(i==1&&(VideoType=='X'||VideoType=='Y'))
		VideoType='V';
	if(VideoType=='X')
	{
		row=SetVideoMode(480,&B_Id);
		if(B_Id.color==256&&B_Id.row==480)
		{
			ScreenXs=640;
			ScreenYs=480;
		}
		else if(B_Id.color==256&&B_Id.row==400)
			VideoType='Y';
		else
			VideoType='V';
	}
	if(VideoType=='Y')
	{
		row=SetVideoMode(400,&B_Id);
		if(B_Id.row<400)
			VideoType='V';
		else
		{
			ScreenXs=640;
			ScreenYs=row;
		}
	}
	if(VideoType=='V')
	{
		row=SetVideoMode(0x12,&B_Id);
		if(B_Id.row!=480||row!=480||B_Id.color!=16||B_Id.col!=640)
			VideoType='E';
		else
		{
			ScreenXs=640;
			ScreenYs=480;
		}
	}
	if(VideoType=='S')
	{
		row=SetVideoMode(0x13,&B_Id);
		if(B_Id.row!=200)
		{
			SetVideoMode(0,&B_Id);
			printf("Could not boot color board.\n");
			exit(0);
		}
		ScreenXs=320;
		ScreenYs=200;
	}
	if(VideoType=='E')
	{
		row=SetVideoMode(0x10,&B_Id);
		if(B_Id.row!=350||row<350||B_Id.col!=640)
		{
			SetVideoMode(0,&B_Id);
			printf("Could not boot color board.\n");
			exit(0);
		}
		ScreenXs=640;
		ScreenYs=350;
	}
	if(B_Id.row<0)
	{
		SetVideoMode(0,&B_Id);
		printf("Could not boot board -- row = %d\n\n",row);
		exit(0);
	}
	set_lut();
}

/***********************************************************************
**
**
**
**
************************************************************************/

int xor_line(int plane,int x1,int y1,int x2,int y2,unsigned char *buffer)

{
	int i,j;
	int xs,ys,size;

	xs=x2-x1+1;
	ys=y2-y1+1;
	if(xs<0)
		xs*=-1;
	if(ys<0)
		ys*=-1;
	size=xs;
	if(ys>xs)
		size=ys;
	ReadLine(y1,x1,y2,x2,Buffer);
	for(j=0;j<size;j++)
		Buffer[j]^=0xff;
	PlotLine(y1,x1,y2,x2,Buffer);
}