/*
*	tsrs.h
*
*****************************************************************************
*
*	Console functions for TSRs
*     	~~~~~~~~~~~~~~~~~~~~~~~~~~
*****************************************************************************
*
*     	Author           :  Rajesh _ThE gReAt
*	Built on         :  forgotten! (some time in 2k)
*	Last Modified on :  Friday, February 08, 2002, 3:55:44 PM
*
*	Known errors : Almost all functions access memory directly .
*		       Do not try to compile in any OS other than DOS.
*
*****************************************************************************
*	DISCLAIMER:
*****************************************************************************
*
*	Programmers may incorporate any or all code into their programs,
*	giving proper credit within the source. Publication of the
*	source routines is permitted so long as proper credit is given
*	to Rajesh _ThE gReAt.
*
*	Copyright (C) 2002, 2003 by Rajesh _ThE gReAt.  You may use this program, or
*	code or tables extracted from it, as desired without restriction.
*	I can not and will not be held responsible for any damage caused from
*	the use of this software.
*
*	Read license.txt from http://www.rajeshgoli.com/license.txt
*	                   or http://www.rajeshgoli.com/license.htm
*	before using / distributing / or any sort of use of my source
*	Also read my disclaimer http://www.rajeshgoli.com/disclaimer.htm
*	
*	YOU AGREE TO BE BOUND BY MY DISCLAIMER AND LICENSE BY IN ANY WAY
*	USING THIS FILE .
*
*****************************************************************************
* This source works with Turbo C 2.0 and Turbo C++ 3.0 and above.
*****************************************************************************
*	Rajesh _ThE gReAt is a synonym of Rajesh Goli
*	Source freely distributable
*****************************************************************************/

#ifndef __DOS_H
#include<dos.h>
#endif

#ifdef __TSR_H
#error Cant include both tsr.h and tsrs.h
#endif

#ifndef __TSRS_H
#define __TSRS_H
#else
#undef __TSRS_H
#define __TSRS_H
#endif

#define MALLOC_ERROR -5
#define DEFAULT_BKCOLOR 84
#define _BOX_

#ifndef NULL
#define NULL (void *)0
#endif

typedef unsigned char byte;

union REGS input,output;
struct SREGS sregisters;

int r,c,k;
byte far *scr = (byte far *)0xB8000000L;
byte *savedwin;

int destroy_buffer = 0;


/*	Function Prototypes		*/

void	writestring	(char * ,unsigned short  ,unsigned short  ,byte ,byte );
void	writechar	(char ,unsigned short  ,unsigned short ,byte ,byte );
void	_clrwin		(unsigned short ,unsigned short ,unsigned short ,unsigned short ,byte );
void	_savewin	(unsigned short ,unsigned short ,unsigned short ,unsigned short );
void	_restorewin	(unsigned short ,unsigned short ,unsigned short ,unsigned short );
void	_box		(unsigned short ,unsigned short  ,unsigned short ,unsigned short ,byte ,byte ,signed short ,unsigned short );
void	writecolor	(unsigned short ,unsigned short  ,byte );
void	box		(unsigned short ,unsigned short ,unsigned short ,unsigned short ,byte ,byte ,signed short ,int );
void	clrwin		(unsigned short ,unsigned short ,unsigned short ,unsigned short ,byte );
void	savewin_here	(byte *,unsigned short ,unsigned short ,unsigned short ,unsigned short );
void	restorewin_here	(byte *,unsigned short ,unsigned short ,unsigned short ,unsigned short );
int	savewin		(byte *,unsigned short ,unsigned short ,unsigned short ,unsigned short );
void	restorewin	(byte *,unsigned short ,unsigned short ,unsigned short ,unsigned short );
int destroybuf		(byte *);
unsigned attrbconv	(byte *,byte ,byte ,short );


void writestring(char *str,unsigned short row,unsigned short col,byte attrb,byte battrb)
{
	unsigned nowcolor;
	while(*str)
	{
		if( battrb != DEFAULT_BKCOLOR )
			writechar(*str,row,col,attrb,battrb);
		else
		{
			nowcolor = *( scr + col*160 + row*2 + 1);
			nowcolor = (nowcolor >> 4);
			nowcolor = (nowcolor & (~0x8));
			writechar(*str,row,col,attrb,nowcolor);
		}
		str++;
		col++;
	}
	return;
}


void writechar(char ch,unsigned short row,unsigned short col,byte attrb,byte battrb)
{
	byte atr;
	*(scr+(row*160)+(col*2)) = ch;
	attrbconv(&atr,attrb,battrb,0);
	*(scr+(row*160)+(col*2)+1) = atr;
	return;
}



/* Clears window                  */
void _clrwin(unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec,byte attrb)
{
	input.h.ah = 6;
	input.h.al = 0;
	input.h.ch = sr;
	input.h.cl = sc;
	input.h.dh = er;
	input.h.dl = ec;
	input.h.bh = attrb;
	
	int86(0x10,&input,&output);

	return;
}


void _savewin(unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec)
{
	for(k=0,r=sr;r<=er;r++)
	{
		for(c=sc;c<=ec;c++)
		{
			savedwin[k]=*(scr+(r*160)+(c*2));
			savedwin[k+1]=*(scr+(r*160)+(c*2)+1);
	
			k += 2;
		}
	}
	return;
}


void _restorewin(unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec)
{
	for(k=0,r=sr;r<=er;r++)
	{
		for(c=sc;c<=ec;c++)
		{
			*(scr+(r*160)+(c*2)) = savedwin[k];
			*(scr+(r*160)+(c*2)+1) = savedwin[k+1];
	
			k += 2;
		}
	}
	return;
}


void _box(unsigned short r1,unsigned short c1,unsigned short r2,unsigned short c2,byte attrb,byte battrb,signed short shadow,unsigned short clwin_or_not)
{
	int rr,cc;
	
	if(clwin_or_not)
		_clrwin(r1,c1,r2,c2,attrb);

	writechar(201,r1,c1,attrb,battrb);
	writechar(187,r1,c2,attrb,battrb);
	writechar(200,r2,c1,attrb,battrb);
	writechar(188,r2,c2,attrb,battrb);

	for(rr=r1+1;rr<r2;rr++)
	{
		writechar(186,rr,c1,attrb,battrb);
		writechar(186,rr,c2,attrb,battrb);
	}

	for(cc=c1+1;cc<c2;cc++)
	{
		writechar(205,r1,cc,attrb,battrb);
		writechar(205,r2,cc,attrb,battrb);
	}

	if(shadow != -1)
	{
		for(rr=r1+1;rr<=r2;rr++)
			writecolor(rr,c2+1,shadow);

		for(cc=c1+1;cc<=c2;cc++)
			writecolor(r2+1,cc,shadow);
	}
	return;
}


void writecolor(unsigned short row,unsigned short col,byte attrb)
{
	*(scr+(row*160)+(col*2)+1) = attrb;
	return;
}

void box(unsigned short r1,unsigned short c1,unsigned short r2,unsigned short c2,byte attrb,byte bk,signed short shadow,int clwin_or_not)
{

	unsigned short rr,cc;
	byte nowattrb,nowbattrb;

	nowattrb  = (*(scr+(r1*160)+(c1*2)+1)) & 0x0F;
	nowbattrb = (((*(scr+(r1*160)+(c1*2)+1)) >> 4) & 0x07);
	*(scr+(r1*160)+(c1*2)+1) &= ~8;

	if(clwin_or_not)
		clrwin(r1,c1,r2,c2,bk);
	
	textbackground(bk);
	textcolor(attrb);

	gotoxy(c1+1,r1+1);
	cprintf("%c",201);
	gotoxy(c2+1,r1+1);
	cprintf("%c",187);
	gotoxy(c1+1,r2+1);
	cprintf("%c",200);
	gotoxy(c2+1,r2+1);
	cprintf("%c",188);

	for(rr=r1+1;rr<r2;rr++)
	{
		gotoxy(c1+1,rr+1);
		cprintf("%c",186);
		gotoxy(c2+1,rr+1);
		cprintf("%c",186);
	}

	for(cc=c1+1;cc<c2;cc++)
	{
		gotoxy(cc+1,r1+1);
		cprintf("%c",205);
		gotoxy(cc+1,r2+1);
		cprintf("%c",205);
	}

	if(shadow!=-1)
	{
		textcolor(shadow);

		for(rr=r1+1;rr<=r2;rr++)
		{
			gotoxy(c2+1,rr);	
			cprintf("%c",219);
		}

		for(cc=c1+1;cc<=c2;cc++)
		{
			gotoxy(cc,r2+1);
			cprintf("%c",219);
		}
	}

	textcolor(nowattrb);
	textbackground(nowbattrb);

	return;
}

void clrwin(unsigned short row1,unsigned short col1,unsigned short row2, unsigned short col2,byte attrb)
{
	unsigned short row,col;
	textcolor(attrb);

	for(col = col1 ; col <= col2 ; col++)
	{
		for(row = row1 ; row <= row2 ; row++)
		{
			gotoxy(col,row);
			cprintf("%c",219);
		}
	}
	return;
}


void savewin_here(byte *vdubuf,unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec)
{
	for(k=0,r=sr;r<=er;r++)
	{
		for(c=sc;c<=ec;c++)
		{
			vdubuf[k]=*(scr+(r*160)+(c*2));
			vdubuf[k+1]=*(scr+(r*160)+(c*2)+1);
	
			k += 2;
		}
	}
	return;
}


void restorewin_here(byte *vdubuf,unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec)
{
	for(k=0,r=sr;r<=er;r++)
	{
		for(c=sc;c<=ec;c++)
		{
			*(scr+(r*160)+(c*2)) = vdubuf[k];
			*(scr+(r*160)+(c*2)+1) = vdubuf[k+1];
	
			k += 2;
		}
	}
	return;
}


int savewin(byte *vdubuf,unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec)
{
	long size;
	size = ( ((er-sr)*160)+((ec-sc)*2) ) * sizeof(char) ;
	vdubuf = (char *)malloc(size);
	if(vdubuf == NULL)
		return MALLOC_ERROR;
	for(k=0,r=sr;r<=er;r++)
	{
		for(c=sc;c<=ec;c++)
		{
			vdubuf[k]=*(scr+(r*160)+(c*2));
			vdubuf[k+1]=*(scr+(r*160)+(c*2)+1);
	
			k += 2;
		}
	}
	return 1;
}


void restorewin(byte *vdubuf,unsigned short sr,unsigned short sc,unsigned short er,unsigned short ec)
{
	for(k=0,r=sr;r<=er;r++)
	{
		for(c=sc;c<=ec;c++)
		{
			*(scr+(r*160)+(c*2)) = vdubuf[k];
			*(scr+(r*160)+(c*2)+1) = vdubuf[k+1];
	
			k += 2;
		}
	}
	if(destroy_buffer)
		destroybuf(vdubuf);
	return;
}



int destroybuf(byte *vdubuf)
{
	free(vdubuf);
	return 1;
}


/* The VDU memory has the following structure for colors
   Bbbbffff in each byte 
   where B is blink bit
   bbb are backgound color bits
   ffff are foreground color bits
   This macro sets it
*/
/* Traditionally a macro suffices
*/

#define our_attrb(attrb,fattrb,battrb,blink) \
(attrb) &= 0x00; \
(attrb) |= ((fattrb) & 0x0F) ; \
(attrb) |= (((battrb)<<4) & 0x70) ; \
(attrb) |= (((blink)<<7) & ~0x7F);

/*
typedef unsigned char byte;
*/

#define PBLINK 1
#define PFORE  2
#define PBAK   4

unsigned attrbconv(byte *attrb,byte fore_color,byte bak_color,short blink)
{
	unsigned return_value;

	/* Fill attrb with zero
	*/

	(*attrb) &= 0x00;

	/* attrb now contains 0000 0000
	*/

	/* fore_color  & 0x0F , make first 4 bits zero , is

	   dddd ffff &
	   0000 1111
	   _________

	   0000 ffff

	   while preserving the last 4 bits .
	   Thus fore_color = 0000 xxxx
	   xxxx = foreground color
	   Now OR it with attrb , thus attrb contains
	   
	   0000 0000 |
	   0000 ffff
	   _________

	   0000 ffff

	*/
	(*attrb) |= ((fore_color) & 0x0F);

	/* initially bak_color contains dddd dxxx
	   where d = 0 or 1 xxx = background color
	   bak_color << 4 move it 4 bits left 
	   now bakcolor contains
	   dxxx yyyy
	   d = dont care (0/1)
	   xxx = background color
	   yyyy = filled bits y = 0 or y = 1 depending on compiler
	   dxxx yyyy & 0x70
	   is , 

	   dxxx yyyy &
	   0111 0000
	   _________
	   0xxx 0000

	   now this is ORed with attrb , thus
	   attrb = 0bbb ffff

	   0000 ffff |
	   0bbb 0000
	   _________

	   0bbb ffff
	*/
	(*attrb) |= ( ((bak_color)<<4) & 0x70 );

	/* Blink is either 0 or 1
	   blink << 7 , move it 7 bits to left
	   blink initially is
	   dddd dddB
	   d = dont care ,
	   B = blink bit
	   blink << 7 results in
	   Byyy yyyy
	   y = filled bit y = 0 or y = 1 depending on compiler
	   0x7F = 0111 1111
	   ones complement of this is
	   ~0x7F = 1000 0000
	   Byyy yyyy & ~0x7F is

	   Byyy yyyy &
	   1000 0000
	   _________
	   B000 0000

	   now this is ORed with attrb this yeilds in
	   
	   0bbb ffff |
	   B000 0000
	   _________

	   Bbbb ffff which is required
	*/	   
	(*attrb) |= (((blink)<<7) & ~0x7F);

	/* Compute error code to return
	   returns PBLINK + PFORE if blink
	   blink and fore color are suspicious
	   and so forth

	   No value is illegal for these arguments
	   they are but suspicious if out of bounds

	   returns zero on success
	*/

	return_value = 0;
	if(blink != 0 && blink != 1)
		return_value += PBLINK;
	if(fore_color > 15)
		return_value += PFORE;
	if(bak_color > 7)
		return_value += PBAK;
	return return_value;
}