//////////////////////////////////////////////////////////////////////
//																	//
//						GDEMO.CPP Graph Demo Program              	//
//						Copyright (C) 2000 Hemodynamics ag			//
//						Demo and example program for the use of		//
//						the CGraph graphics library					//
//																	//
//////////////////////////////////////////////////////////////////////

////////////////////////////////// Standard C++ headers:
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#include <conio.h>
#include <stat.h>
#include <fcntl.h>
#include <dos.h>
#include <dir.h>
#include <mem.h>
#include <alloc.h>
#include <string.h>

////////////////////////////////// User defined header:

#include "cgraph.h"				// Graphics library

////////////////////////////////// User defined constants:
#define	ESC 27
#define	F1 187
#define	F2 188
#define	F3 189
#define	F4 190
#define	F5 191
#define	F6 192
#define	F7 193
#define	F8 194

#define ymsg 225			// position for general message


//////////////////////////////////////////////////////////////////////
//																	//
//						Forward declarations:                      	//
//																	//
//////////////////////////////////////////////////////////////////////
int  	keypressed();
int  	readkeypressed();
byte 	indexget(byte index);
void 	indexset(byte index,byte value);

//////////////////////////////////////////////////////////////////////
//																	//
//							GLOBALS:                            	//
//																	//
//////////////////////////////////////////////////////////////////////


CGraph 	dc;					// Graphics object (device context)


//////////////////////////////////////////////////////////////////////////
//                                  									//
//				GENERAL FUNCTIONS AND PROCEDURES:						//
//																		//
//////////////////////////////////////////////////////////////////////////


void cleardisplay() { dc.rectfill(0,0,MAXX,MAXY,dc.getbkcolor()); }



int keypressed()
{
	int res;
	res=( kbhit()) & 255;
	return res;
}//----------------------------------------------- keypressed

int readkeypressed()
{
	int i,sel;
	sel=getch();
	if (!sel)
	{
		i=getch();
		if (i) sel=i+128;					// Marker for extended codes
	}
	return sel;
}//------------------------------------------- readkeypressed


//////////////////////////////////////////////////////////////////
//                                  							//
//				Elan BIOS FUNCTIONS AND PROCEDURES:				//
//																//
//////////////////////////////////////////////////////////////////
byte indexget(byte index)
{
	byte a;
	_asm {
		mov al,index
		out 0x22,al
		in al,0x23
		mov a,al
	}
	return a;
}//----------------------------------------indexget

void indexset(byte index,byte value)
{
	_asm {
		mov al,index
		out 0x22,al
		mov al,value
		out 0x23,al
	}
}//----------------------------------------indexget

void elansetup(void) // 	Special setup of Elan chip:
{
	indexset(0xDE,0x00);					// enable r/w of graphics registers
	indexset(0x40,indexget(0x40)&0xb8); 	// set normal highspeed operation
}//------------------------------------------------------ elansetup


//////////////////////////////////////////////////////////////////
//                                  							//
//    		   		AT EXIT CLEANUP PROCEDURE:					//
//																//
//////////////////////////////////////////////////////////////////

void prgexit()//////////////////////////// Cleans up after program
{
	graphsetup(GRAPHOFF);	// restore old display mode
	dc.graphexit();			// clean up after use
}//------------------------------------------- prgexit()


//////////////////////////////////////////////////////////////////
//                                  							//
//			    	 EXAMPLES OF GRAPHICS OPERATIONS:			//
//																//
//////////////////////////////////////////////////////////////////




void demoscreen()
{
	byte temp,f0;
	int i,j,x,dx,x1,y,sel;
	cleardisplay();   						// Clears entire screen
	temp=dc.setcolor(dc.getbkcolor()^15); 	// Use as drawing color
// Draw frame around text:
	dc.rectround(23,17,312,144);
	dc.rectround(26,20,309,141);
// Draw rectangle with grayscale display:
	for (i=0;i<16;i++) dc.rectfill(24+i*18,150,42+i*18,230,i);
	dc.rect(23,150,312,230);
// Demonstrate use of large font:
	f0=dc.setfont(3);
	dc.textout(40,28,"LARGE FONT 12X16");
// Medium (default) font:
	dc.setfont(2);
	dc.textout(40,60,"Medium Font used as default\nThis font has an 8x14 Matrix");
// Small font:
	dc.setfont(1);
	dc.textout(40,98,"         THE SMALL FONT: 1234567890");
	dc.setfont(2);
	dc.textout(40,108,"Press F1..F8 for Demos; X to Exit");
	dc.textout(40,123,"(Hitting any key stops Animation)");
	dc.setfont(f0);
	for (i=0;i<200;i++)   // Horizontal animation of bitmap clip
	{
		delay(40);
		dx=i+1;
		x=310-i;
		if (dx>130)
		{
			dx=130;
			for (j=0;j<16;j++)
			{
				x1=24+j*18;
				if ((x+dx)<x1) dc.rectfill(x1,150,18+x1,230,j);
			}
		}
		dc.rectblt(168,110,dx,60,x,160);
		dc.rect(23,150,312,230);
		sel=keypressed();
		if (sel) break;
	}
	if (!sel)
	{
		for (i=-20;i<=72;i++) // Vertical amimation of clip
		{
			delay(50);
			if (i>0)
			{
				y=226-i;
				dc.rectblt(0,168,284,i,26,y);
				dc.rect(23,150,312,230);
			}
			sel=keypressed();
			if (sel) break;
		}
	}
	dc.rectblt(0,168,284,72,26,226-72);
	if (sel) sel=readkeypressed();
	dc.setcolor(temp);   					// Restore color
	dc.textout(40,123," ------------------------------- ");
}//------------------------------------------------------ demoscreen()


//////////////////////////////////////////////////////////////////
//                                  							//
//			 KEY PRESS COMMAND DECODE AND EXECUTE:				//
//																//
//////////////////////////////////////////////////////////////////

void F1cmd(void)// Demo fast routine for vertical lines:
{
   int i;
   for (i=0;i<320;i++)
   {
		dc.setcolor(i);
		dc.liney(i,10,220);
   }
	dc.setfont(2);
	dc.textout(0,225,"  Vertical Lines of different grays  ");
}//---------------------------------------------------- F1cmd()

void F2cmd(void)// Horizontal lines:
{
   int i;
   for (i=0;i<240;i++)
   {
		dc.setcolor(i);
		dc.linex(10,i,310);
   }
	dc.textout(0,225,"  Horizontal Lines of different grays  ");
}//---------------------------------------------------- F2cmd()

void F3cmd(void)// Using the rect routine
{
	int i;
   for (i=0;i<120;i++)
   {
		dc.setcolor(15-i/4);
		dc.rect(i,i,319-i,239-i);
   }
	dc.textout(0,225," Rectangles of different grays  ");
}//---------------------------------------------------- F4cmd()


void F4cmd(void)           // Draw line vector example:
{
	int x,y,x0,y0,dx0,dy0,count;
	count=0;
	x0=160;
	y0=120;
	dx0=159;
	dy0=119;
	cleardisplay();
	while ((dx0>8) && (dy0>6))
	{
		for (x=x0-dx0;x<x0+dx0;x++)			// 12 o'clock quadrant
		{
			dc.setcolor((count/16)&15);
			count++;
			dc.moveto(x0,y0);
			dc.lineto(x,y0-dy0);
		}
		for (y=y0-dy0;y<y0+dy0;y++)			// 3 o'clock quadrant
		{
			dc.setcolor((count/16)&15);
			count++;
			dc.moveto(x0,y0);
			dc.lineto(x0+dx0,y);
		}
		for (x=x0+dx0;x>x0-dx0;x--)			// 6 o'clock quadrant
		{
			dc.setcolor((count/16)&15);
			count++;
			dc.moveto(x0,y0);
			dc.lineto(x,y0+dy0);
		}
		for (y=y0+dy0;y>y0-dy0;y--)			// 9 o'clock quadrant
		{
			dc.setcolor((count/16)&15);
			count++;
			dc.moveto(x0,y0);
			dc.lineto(x0-dx0,y);
		}
		dx0=dx0-3-dx0/8;                        	// Decrement vector
		dy0=dy0-2-dy0/8;							// Endpoints
	}
	dc.writeint(40,ymsg," Drawing Vectors, Total of: ",count,10);
}//---------------------------------------------------- F6cmd()

void F5cmd(void)//////////////// Demo of scale drawing routines
{
	int x1,x2,y0,y1,y2,hscale,vscale;
	int dx,dy,i;
	byte temp;
	x1=40;
	x2=312;
	y0=120;
	y1=16;
	y2=220;
	hscale=50;
	vscale=250;

	dx=10000;dy=0;

	cleardisplay();
	temp=dc.setcolor(dc.getbkcolor()^15);
	dc.rect(x1,y1,x2,y2);
	dc.scalex(x1,y2,x2,hscale,0);       // x-axis
	dc.scaley(x1,y0,y1,y2,vscale);      // y-axis
	dc.linex(x1,y0,x2);					// zeroline
	dc.textout(x1,0," X-Y Scale routines ");

	dc.setcolor(12);
	dc.linex(x1,y0,x2);					// zeroline

	dc.setcolor(4);
	for (i=0;i<2200;i++)   	// Use 2nd order differential equation
	{                       // in phase plane
		dx=dx-dx/500+dy/20;
		dy=dy-dx/20;
		dc.setpixel(170+dx/80,120+dy/100);
	}
	dc.setcolor(temp);
}//---------------------------------------------------- F3cmd()



void F6cmd(void) 				// 16 grayscale Bitmap example
{
	int i;
	char st[255];
	dc.getbitmap("C.BMA"); 		// Get new bitmap
	dc.putbitmap();             // Showit
	dc.getbitmap("A.BMA");      // Restore default bitmap
	if (dc.getbkcolor()<7)
	{
		dc.setcolor(0);
		dc.setbkcolor(15);
		dc.invertcolors();
	}
	strcpy(st," Atlantis landing at Edwards ");
	for (i=312;i>40;i--)
	{
		delay(5);
		dc.textout(i,224,st);
	}
}//---------------------------------------------------- F5cmd()


void F7cmd(void)                      // Inverted color example
{
	dc.invertcolors();
	demoscreen();
}//---------------------------------------------------- F7cmd()

void F8cmd(void)// Switch to DOS character mode example
{
	char st[255];
	strcpy (st,"\r\nNow we have switched to good(?) \r\nold(!) DOS character output.\r\n");
	strcat (st,"Do not forget the CR and LF\r\ncharacters if your display\r\n");
	strcat (st,"requires a decent format\r\n");
	strcat (st,"\r\n\r\n- Press any key to return to graphics -\r\n");
	graphsetup(GRAPHOFF);  // Switch to DOS character mode
	printf(st);            // Output via DOS
	while (!keypressed()) delay(100);
	if (readkeypressed());
	graphsetup(GRAPHON);   // Back to graphics mode
	demoscreen();
}//---------------------------------------------------- F8cmd()




//////////////////////////////////////////////////////////////////
//                                  							//
//			    			MAIN:								//
//																//
//////////////////////////////////////////////////////////////////

void main(void)///////////////////////////////////////////////////
{
	int sel,				// Pressed Keycode (extended)
		count;				// Counter used for delays
	bool runprgm;
	
	runprgm=true;
	sel=0;
	count=0;

	elansetup();			// setup of special registers in elan chip
	atexit(&prgexit);		// register the cleanup procedure

// Initializing and setting up for Elan400 graphics:
	graphsetup(GRAPHON);	// setup graphics 16 grayscale mode
	cleardisplay();
	dc.getbitmap("A.BMA"); 	// load standard graphics bitmap
	dc.setcolor(0);			// Set drawing color
	dc.setbkcolor(15);		// Set background color
	cleardisplay();

	demoscreen();			// Show start demo screen


	while (runprgm)/////////////////////////// Main program loop
	{
		sel=0;
		count=0;
		while ((!sel)&&(count<200))
		{
			delay(100);
			sel=keypressed();				// Check if key has been pressed
			count++;
		}//----------------------------------- Online idle loop


		if (sel) sel=readkeypressed();		// Read extended keycode
		switch (sel)
		{
// Show different demos:
		 case F1:	F1cmd();					break;
		 case F2:	F2cmd();					break;
		 case F3: 	F3cmd();					break;
		 case F4:	F4cmd();					break;
		 case F5:	F5cmd();					break;
		 case F6:	F6cmd();					break;
		 case F7:	F7cmd();					break;
		 case F8: 	F8cmd();					break;

// Exit codes:
		 case ESC:  runprgm=false;				break;
		 case 'Q':  runprgm=false;				break;
		 case 'q':  runprgm=false;				break;
		 case 'x':  runprgm=false;				break;
		 case 'X':  runprgm=false;				break;
		}

	} // ------------------------- end main program loop
	exit(0);					// Cleanup
}// ------------------------------------------------- main()