//*******************************************************************
//	File:			corpsgui.cpp
//	Author:			Jeff Ruby
//	Agency:			U.S. Army Topographic Engineering Center
//	Last Modified:  1/11/95
//
//	This is the source file that is used to build a simple
//	graphical user interface.  This source file uses
//	keyboard.cpp to parse the keyboard.  This source file
//	was compiled with Borland Turbo C++ 3.0 and it uses
//	some of their built-in graphics routines.
//*******************************************************************
#include <conio.h>
#include <ctype.h>
#include <dos.h>
#include <graphics.h>
#include <iostream.h>
#include <stdio.h>
#include <string.h>
#include "corpsgui.h"
#include "corpskey.h"

//*********************************************************************
//  Window subroutines
//*********************************************************************
void default_windowbox(windowbox *ptr)
{
	ptr->Xstart = 1;
	ptr->Ystart = 1;
	ptr->Xend = 80;
	ptr->Yend = 25;

	ptr->background = BLUE;
	ptr->text = YELLOW;
	ptr->border = YELLOW;
	ptr->hilite = RED;
	ptr->titlecol = WHITE;
	ptr->shadow = OFF;
	ptr->bordertoggle = OFF;

	strcpy(ptr->title,"");
}

void MakeWindow(windowbox *ptr)
{
register i;
int Xstart,Ystart,Xend,Yend;

	Xstart = ptr->Xstart;
	Ystart = ptr->Ystart;
	Xend = ptr->Xend;
	Yend = ptr->Yend;

	if(ptr->shadow)
	{
		window(Xstart+2,Ystart+1,Xend+2,Yend+1);
		textbackground(BLACK);
		clrscr();
	}

	window(Xstart,Ystart,Xend,Yend);
	textbackground(ptr->background);
	textcolor(ptr->border);
	clrscr();

	if(ptr->bordertoggle)
	{
		gotoxy(1,1);
		for(i=1;i<(Yend-Ystart+1);i++)
		{
			gotoxy(1,i);
			cprintf("º");
			gotoxy(Xend-Xstart+1,i);
			cprintf("º");
		}

		gotoxy(1,Yend-Ystart+1);
		cprintf("È");

		for(i=2;i<(Xend-Xstart+1);i++)
			cprintf("Í");

		cprintf("¼");

		gotoxy(1,1);
		insline();
		cprintf("É");

		for(i=2;i<(Xend-Xstart+1);i++)
			cprintf("Í");

		cprintf("»");
	}

	WriteText(3,1,ptr,ptr->title);
}

void WriteText(int x, int y, windowbox *ptr, char *words)
{
register i=0;
int color;

	window(ptr->Xstart,ptr->Ystart,ptr->Xend,ptr->Yend);
	textbackground(ptr->background);

	if(strcmp(ptr->title,words)) color = ptr->text;
	else color = ptr->titlecol;

	gotoxy(x,y);
	while(i<strlen(words))
	{
		if(words[i] == '^')
		{
			textcolor(ptr->hilite);
			textbackground(ptr->background);
			i++;
			cprintf("%c",words[i]);
		}

		else
		{
			textcolor(color);
			textbackground(ptr->background);
			cprintf("%c",words[i]);
		}

		i++;
	}
}

void SetDimensions(windowbox *ptr,
		   int xstart,
		   int ystart,
		   int xend,
		   int yend)
{
	ptr->Xstart = xstart;
	ptr->Ystart = ystart;
	ptr->Xend = xend;
	ptr->Yend = yend;
}

void SetColors(windowbox *ptr,
		   int back,
		   int txt,
		   int bord,
		   int hi,
		   int title)
{
	ptr->background = back;
	ptr->text = txt;
	ptr->border = bord;
	ptr->hilite = hi;
	ptr->titlecol = title;
}

//*********************************************************************
//  Textline subroutines
//*********************************************************************
void default_textline(textline *ptr)
{
	ptr->xstart = 1;
	ptr->ystart = 1;
	ptr->xend = 10;
	strcpy(ptr->label,"");
	ptr->StdTxt = BLACK;
	ptr->StdHilt = RED;
	ptr->StdBack = LIGHTGRAY;
	ptr->ModTxt = YELLOW;
	ptr->ModHilt = WHITE;
	ptr->ModBack = BLUE;
	ptr->position = 0;
	ptr->numelements = 0;
	ptr->offset = 0;
}

void SetWindow(textline *ptr, int x, int y, int length, char *word)
{
	if(!length) length = strlen(word);
	ptr->xstart = x;
	ptr->ystart = y;
	ptr->xend = x + length;
	strcpy(ptr->label,word);
}

void SetWriteColors(textline *ptr, int text, int back, int hilite)
{
	ptr->StdTxt = text;
	ptr->StdHilt = hilite;
	ptr->StdBack = back;
}

void SetModColors(textline *ptr, int text, int back, int hilite)
{
	ptr->ModTxt = text;
	ptr->ModHilt = hilite;
	ptr->ModBack = back;
}

void WriteTextLine(textline *ptr)
{
char *tmp;

	tmp = new char[80];

	_setcursortype(_NORMALCURSOR);
	window(ptr->xstart,ptr->ystart,ptr->xend,ptr->ystart);
	textcolor(ptr->StdTxt);
	textbackground(ptr->StdBack);
	clrscr();
	gotoxy(1,2);
	for(int i=0;i<(ptr->xend)-(ptr->xstart);i++)
	{
		tmp[i] = ptr->label[i];
		if(ptr->label[i] == NULL) break;
	}

	tmp[i] = NULL;

	cprintf("%s",tmp);

	delete tmp;

	_setcursortype(_NOCURSOR);
	window(1,1,80,25);
}

void WriteModTextLine(textline *ptr)
{
char *tmp;

	tmp = new char[80];

	_setcursortype(_NORMALCURSOR);
	window(ptr->xstart,ptr->ystart,ptr->xend,ptr->ystart);
	textcolor(ptr->ModTxt);
	textbackground(ptr->ModBack);
	clrscr();
	gotoxy(1,2);
	for(int i=0;i<(ptr->xend)-(ptr->xstart);i++)
	{
		tmp[i] = ptr->label[i];
		if(ptr->label[i] == NULL) break;
	}

	tmp[i] = NULL;

	cprintf("%s",tmp);

	delete tmp;

	_setcursortype(_NOCURSOR);
	textcolor(ptr->StdTxt);
	textbackground(ptr->StdBack);
	window(1,1,80,25);
}

void WriteTmp(textline *ptr)
{
char tmp[80];

	window(ptr->xstart,ptr->ystart,ptr->xend,ptr->ystart);
	clrscr();
	gotoxy(1,2);
	if(ptr->position == ptr->xend - ptr->xstart + ptr->offset + 1)
			ptr->offset++;
	else if(ptr->position == ptr->offset)
		if(ptr->position>0) ptr->offset--;
	for(int i=ptr->offset;i<ptr->xend-ptr->xstart+ptr->offset+1;i++)
	{
		tmp[i-(ptr->offset)] = ptr->label[i];
		if(ptr->label[i] == NULL) break;
	}

	tmp[i] = NULL;

	cprintf("%s",tmp);

	gotoxy(ptr->position-ptr->offset+1,1);
}

int ModifyTxt(textline *ptr)
{
enum {FALSE,TRUE};
char oldname[80];
int insert=0;
int BreakLoop=0;
int i=0;
int FirstKey = TRUE;
int key=0;


	_setcursortype(_NORMALCURSOR);
	window(ptr->xstart,ptr->ystart,ptr->xend,ptr->ystart);
	textcolor(ptr->ModTxt);
	textbackground(ptr->ModBack);
	clrscr();
	gotoxy(1,2);

	SetParms(ptr);
	strcpy(oldname,ptr->label);

	do
	{
		key = GetKey();
			switch (key)
			{
				case BACKSPACE:  // backspace
					if(ptr->position>0)
					{
						for(i=0;i<ptr->numelements;i++)
						  if(i>=ptr->position-1)
								ptr->label[i] = ptr->label[i+1];
						ptr->position--;
						ptr->numelements--;
					}

					break;
				case TAB:   BreakLoop = 1;
							break;
				case ENTER: BreakLoop = 1;
							break;
				case ESC:   BreakLoop = 1;
							break;
				case 127:   strcpy(ptr->label,"");
							SetParms(ptr);
							break;
				case UP:    BreakLoop = 1;
							break;
				case DOWN:  BreakLoop = 1;
							break;
				case PG_UP: BreakLoop = 1;
							break;
				case PG_DN: BreakLoop = 1;
							break;
				case LEFT:  if(ptr->position>0) ptr->position--;
							break;
				case RIGHT: if(ptr->position<ptr->numelements-1)
									ptr->position++;
							break;
				case HOME:  ptr->position = 0;
							ptr->offset = 0;
							break;
				case END:   ptr->position = strlen(ptr->label);
							if(ptr->position>ptr->xend - ptr->xstart)
								ptr->offset = ptr->position -
									(ptr->xend - ptr->xstart);
							else ptr->offset = 0;
							break;
				case INSERT:    if(insert){
									insert = 0;
									_setcursortype(_NORMALCURSOR);
								}
								else{
									insert = 1;
									_setcursortype(_SOLIDCURSOR);
								}
								break;

				case DELETE:    if(ptr->position<ptr->numelements-1)
								{
									for(i=0;i<ptr->numelements;i++)
										if(i>=ptr->position)
										   ptr->label[i] = ptr->label[i+1];
									ptr->numelements--;
								}
								break;
				case CTRL_END:
								BreakLoop = 1;
								break;
				case CTRL_HOME: strcpy(ptr->label,oldname);
								SetParms(ptr);
								break;
				default:
					if(key>256) break;
					if(FirstKey)
					{
						ptr->label[0] = key;
						ptr->label[1] = '\0';
						SetParms(ptr);
					}
					else if(!insert)
					{
						ptr->label[ptr->position] = key;
						if(ptr->position==ptr->numelements-1)
						{
							ptr->label[ptr->position+1] = NULL;
							ptr->numelements++;
						}
						ptr->position++;
					}
					else
					{
					  for(i=ptr->numelements;i>=0;i--)
						if(i>ptr->position)
								ptr->label[i] = ptr->label[i-1];

					  ptr->label[ptr->position] = key;
					  ptr->numelements++;
					  ptr->position++;
					}
					break;
			}

		FirstKey = FALSE;
		WriteTmp(ptr);
		if(ptr->position>77)
		{
			BreakLoop = 1;
			cout<<"\a";
		}
	}while(!BreakLoop);

	WriteTextLine(ptr);
	_setcursortype(_NOCURSOR);
	window(1,1,80,25);
	gotoxy(10,10);
	return(key);
}

void SetParms(textline *ptr)
{
register i;
char tmp[80];

	ptr->position = strlen(ptr->label);
	if(ptr->position>ptr->xend-ptr->xstart)
		ptr->offset = ptr->position - (ptr->xend - ptr->xstart);
	else ptr->offset = 0;
	ptr->numelements = strlen(ptr->label)+1;

	for(i=ptr->offset;i<ptr->xend-ptr->xstart+ptr->offset+1;i++)
	{
		tmp[i-ptr->offset] = ptr->label[i];
		if(ptr->label[i] == NULL) break;
	}

	tmp[i] = NULL;

	cprintf("%s",tmp);
}

//*********************************************************************
//  Box subroutines
//*********************************************************************
int BuildScroll(int xs, int ys, int yrows,char *title,
					int Back, int Text, int Border, int Title,
					int ModBack, int ModText, char *list,
					int NumElems, int SingleSize,int First)
{
int length=0,i=0,found=0;
int WindowPos,CurFirstElem,NewList,Return,ReturnValue;
char *before=NULL;
windowbox *wintmp=NULL;
textline *texttmp=NULL;

	length = strlen(title)+1;

	yrows = yrows>NumElems ? NumElems:yrows;
	if(ys+yrows>23) yrows = 23 - ys;

	for(i=0;i<NumElems;i++)
		length = length>strlen(list+(i*SingleSize)) ?
						length:strlen(list+(i*SingleSize));

	before = new char[(yrows+3)*(length+4)*2+96];

	wintmp = new windowbox;

	gettext(xs,ys,xs+length+4,ys+yrows+2,before);

	default_windowbox(wintmp);
	SetDimensions(wintmp,xs,ys,xs+length+2,ys+yrows+1);
	SetColors(wintmp,Back,Text,Border,Text,Title);
	wintmp->bordertoggle = ON;
	wintmp->shadow = ON;
	strcpy(wintmp->title,title);

	MakeWindow(wintmp);

	delete wintmp;

	texttmp = new textline[yrows];

	for(i=0;i<yrows;i++)
	{
		SetWindow(&texttmp[i],xs+1,ys+i+1,length,list+(i*SingleSize));
		SetWriteColors(&texttmp[i],Text,Back,Text);
		SetModColors(&texttmp[i],ModText,ModBack,ModText);
		WriteTextLine(&texttmp[i]);
	}

	if(First>NumElems){
		CurFirstElem = 0;
		WindowPos = 1;
	}
	else if(First<NumElems-yrows){
		CurFirstElem = First;
		WindowPos = 1;
	}
	else{
		CurFirstElem = NumElems - yrows;
		WindowPos = First - (NumElems - yrows);
		if(NumElems>yrows) WindowPos++;
	}

	NewList = 1;

	do
	{
		if(NewList)
			for(i=0;i<yrows;i++)
			{
				SetWindow(&texttmp[i],xs+1,ys+i+1,length,
					list+((CurFirstElem+i)*SingleSize));
				SetWriteColors(&texttmp[i],Text,Back,Text);
				SetModColors(&texttmp[i],ModText,ModBack,ModText);
				WriteTextLine(&texttmp[i]);
			}

		WriteModTextLine(&texttmp[WindowPos-1]);
		NewList = 1;
		Return = GetKey();
		WriteTextLine(&texttmp[WindowPos-1]);
		switch(Return)
		{
			case ESC:           ReturnValue = 0;
								break;
			case DOWN:          if(WindowPos<yrows){
									WindowPos++;
									NewList=0;
								}
								else if(CurFirstElem<NumElems-yrows)
										CurFirstElem++;
								break;
			case UP:            if(WindowPos>1){
									WindowPos--;
									NewList=0;
								}
								else if(CurFirstElem>0) CurFirstElem--;
								break;
			case PAGE_DOWN:     if(CurFirstElem+yrows<NumElems-yrows)
									CurFirstElem += yrows;
								else if(CurFirstElem == NumElems-yrows)
									WindowPos=yrows;
								else CurFirstElem = NumElems - yrows;
								break;
			case PAGE_UP:       if(CurFirstElem-yrows>0)
									CurFirstElem -= yrows;
								else if(CurFirstElem==0) WindowPos=1;
								else CurFirstElem = 0;
								break;
			case END:           CurFirstElem = NumElems-yrows;
								WindowPos = yrows;
								break;
			case HOME:          CurFirstElem = 0;
								WindowPos = 1;
								break;
			case ENTER:         ReturnValue = CurFirstElem+WindowPos;
								break;
			default:            found = 0;
								for(i=CurFirstElem+WindowPos;i<NumElems;i++)
									if((tolower(*(list+(i*SingleSize))) == Return)
										||(toupper(*(list+(i*SingleSize))) == Return))
									{
										found = 1;
										CurFirstElem = i;
										WindowPos = 1;
										break;
									}
								if(!found) break;

								if(CurFirstElem<yrows){
									WindowPos = CurFirstElem + 1;
									CurFirstElem = 0;
								}
								else if(CurFirstElem>NumElems-yrows){
									WindowPos = CurFirstElem -
												(NumElems-yrows) + 1;
									CurFirstElem = NumElems - yrows;
								}
								break;
		}
	}while(Return!=ENTER&&Return!=ESC);

	puttext(xs,ys,xs+length+4,ys+yrows+2,before);

	delete texttmp;

	delete before;

	return ReturnValue;
}

int BuildText(int xs, int ys, char *title,
					int Back, int Text, int Border, int Title,
					int ModBack, int ModText, char *stat, char *dynm,
					int dynmlen, int NumElems, int StatSize, int DynmSize)
{
int statlength=0,length,line=0,i=0;
int current=0,choice=0;
char *before;
windowbox *wintmp;
textline *texttmp;

	length = strlen(title)+1;

	for(i=0;i<NumElems;i++)
		statlength = statlength>strlen(stat+(i*StatSize)) ?
						statlength:strlen(stat+(i*StatSize));

	length = statlength+dynmlen;

	before = new char[(NumElems+3)*(length+4)*2+96];

	wintmp = new windowbox;

	gettext(xs,ys,xs+length+4,ys+NumElems+2,before);

	default_windowbox(wintmp);
	SetDimensions(wintmp,xs,ys,xs+length+2,ys+NumElems+1);
	SetColors(wintmp,Back,Text,Border,Text,Title);
	wintmp->bordertoggle = ON;
	wintmp->shadow = ON;
	strcpy(wintmp->title,title);

	MakeWindow(wintmp);

	delete wintmp;

	texttmp = new textline[NumElems];

	line = ys;

	for(i=0;i<NumElems;i++)
	{
		SetWindow(&texttmp[i],xs+1,++line,length,stat+(i*StatSize));
		SetWriteColors(&texttmp[i],Text,Back,Text);
		SetModColors(&texttmp[i],ModText,ModBack,ModText);
		WriteTextLine(&texttmp[i]);
	}

	delete texttmp;

	texttmp = new textline[NumElems];

	line = ys;

	for(i=0;i<NumElems;i++)
	{
		SetWindow(&texttmp[i],xs+statlength+1,++line,dynmlen,
						dynm+(i*DynmSize));
		SetWriteColors(&texttmp[i],Text,Back,Text);
		SetModColors(&texttmp[i],ModText,ModBack,ModText);
		WriteTextLine(&texttmp[i]);
	}

	current = 0;

	do
	{
		switch(choice=ModifyTxt(&texttmp[current]))
		{
			case UP:    current = current>0 ? current-1:NumElems-1;
						break;
			case DOWN:  current = current==NumElems-1 ? 0:current+1;
						break;
			case TAB:   current = current==NumElems-1 ? 0:current+1;
						break;
			case ENTER: current++;
						break;
			case ESC:   puttext(xs,ys,xs+length+4,ys+NumElems+2,before);
						return ESC;
			case PG_UP: current = 0;
						break;
			case PG_DN: current = NumElems-1;
						break;
			case HOME:  current = 0;
						break;
			case END:   current = NumElems-1;
						break;
			default:    break;
		}
		if(current==NumElems&&choice==ENTER) break;
	}while(choice!=ESC);

	for(i=0;i<NumElems;i++)
		strcpy(dynm+(i*DynmSize),texttmp[i].label);

	puttext(xs,ys,xs+length+4,ys+NumElems+2,before);

	delete before;
	delete texttmp;

	return choice;
}