/*
*	RSpc.c
*
*   real screen interface for Gaige Paulsen's 
*   Virtual screen driver
*
*   Tim Krauskopf
*
*	Date		Notes
*	--------------------------------------------
*	11/25/86	Start -TKK
*	6/89		code cleanup for 2.3 release -QAK
*/

/*
* Includes
*/
#ifdef MOUSE
#include "mouse.h"
#endif
#ifdef __TURBOC__
#include "turboc.h"
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <bios.h>		/* for printer functions */
#ifdef MSC
#ifdef __TURBOC__
#include <alloc.h>
#else
#include <malloc.h>
#endif
#endif
#include "whatami.h"
#include "windat.h"
#include "vskeys.h"
#include "hostform.h"
#include "nkeys.h"
#include "externs.h"
#include "keymap.h"
#include "map_out.h"

/*
*	Global Variables
*/
extern struct config def;
extern int numline;				/* numline of lines in display */
extern int beep_notify;         /* musical note display flag */

#ifdef NOT
#ifndef FTP
extern int _Sftpstat;
extern int _Sftpname;
#endif
#endif

/*
*	Local Variables
*/
static int lastatt=255,			/* last attribute value written to screen*/
	lastw=255,
	thevis=0;					/* which window is visible */

int transtable[]={      /*  Graphics translation set  */
	 32,  4,177,  9, 12, 13, 10,248,
	241, 10, 10,217,191,218,192,197,
	196,196,196,196, 95,195,180,193,
	194,179,243,242,227,168,156,250,
	 32, 32, 32, 32, 32, 32, 32, 32,
	 32, 32, 32, 32 };


/***************************************************************************/
/*   map_output:
*	   Takes a character and converts it to the IBM PC extended character
*   set which, in the outputtable array, is mapped to the output mapping
*   set up in telnet.out
*/
#define map_output(ch)  ((int)outputtable[ch-95])

/***************************************************************************/
/*   translate:
*	   Takes a character and converts it to the IBM PC extended character
*   set which, in the transtable array, is mapped to the VT100 graphics
*   characters, with minor conflicts.
*/
#define translate(ch)   ((int)((ch>94) ? transtable[ch-95] : ch))

#ifdef NOT_USED
/*************************************************************************/
/*
*	RSokmem()
*
*	returns whether memory is ok (QAK ?)
*/
unsigned int RSokmem(int size)
{
#ifdef MSC
#if defined (__TURBOC__) | defined(__WATCOMC__)
	return(1);
#else
	return(_freect(size));
#endif
#else
	return(1);
#endif
}
#endif

/*************************************************************************/
/*
*	RSbell()
*
*	rings a bell
*/
void RSbell(int w)
{
/*
*  might add something to indicate which window
*/
	n_sound(1000,12);		/* PC bell routine */
    if (beep_notify) {
        screens[w]->sstat=14;
        statline();
    }
}

/*************************************************************************/
/*
*	RSvis()
*
*	sets the visible window to be the window number passed to it
*/
void RSvis(int w)
{
	thevis=w;				/* this is visible window */
}

void RSinitall() {}

void RSinsstring(int w,int x,int y,int attrib,int len,char *s)
{
/* Needed for possible future functionality */
	w=w;
	x=x;
	y=y;
	attrib=attrib;
	len=len;
	s=s;
}

void RSdelchars(int w,int x,int y,int n)
{
/* Needed for possible future functionality */
	w=w;
	x=x;
	y=y;
	n=n;
}

void RSbufinfo(int w,int numlines,int top,int bottom)
{
/* Needed for possible future functionality */
	w=w;
	numlines=numlines;
	top=top;
	bottom=bottom;
}

void RSdrawsep(int w,int y,int data)
{
/* Needed for possible future functionality */
	w=w;
	y=y;
	data=data;
}

void RSmargininfo(int w,int x,int data)
{
/* Needed for possible future functionality */
	w=w;
	x=x;
	data=data;
}

void RSdelcols(int w,int n)
{
/* Needed for possible future functionality */
	w=w;
	n=n;
}

void RSinscols(int w,int n)
{
/* Needed for possible future functionality */
	w=w;
	n=n;
}


/*************************************************************************/
void RScursoff(int w)
{
	w=w;
		/* do nothing, MAC routine */
}

/*************************************************************************/
/*
*	RScurson()
*
*	move the cursor to a x,y position on the real screen
*/
void RScurson(int w,int y,int x)
{
	if(w!=thevis)
		return;							/* not visible */
/*
*  this is really the cursor positioning routine.  If cursor is turned off,
*  then it needs to be turned back on.
*/
	n_cur(x,y);
/*  add code to save cursor position for a given window */
}

/*************************************************************************/
/*
*	RSdraw()
*
*	put a string at a position on the real screen
*/

/* Contribution from njtaylor@cix.compulink.co.uk */  /* rmg 930917 */
/* First time the characters are
translated to IBM Character set, If Help Screen displayed on the re-draw of
the screen the characters are translated a secord time to different characters
The draw routine, has been updated to use a local character string draw_char 
for the translations, leaving the characters passed via the argument unchanged.
*/

static unsigned char draw_char[133];

void RSdraw(int w,int y,int x,int a,int len,unsigned char *ptr)
{
	int i;

	if(w!=thevis) {	/*  indicate that something happened */
		x=n_row();
		y=n_col();
		if(screens[w]->sstat!='*') {
			if(screens[w]->sstat==47)
				screens[w]->sstat=92;
			else
                if(screens[w]->sstat!=14)
                    screens[w]->sstat=47;
		  }
		statline();
		n_cur(x,y);							/* restore cursor where belongs */
		return;
	  }
/*
* call my own draw routine
*/
  if(w!=lastw || a!=lastatt)    /* need to parse attribute bit */
		RSsetatt(a,w);
	n_cur(x,y);
	if(VSisgrph(lastatt))
	{
		for(i=0; i<len; i++)
			draw_char[i]=(char)translate((int)ptr[i]);
		ptr = draw_char;
	}
	else {		/* ok, we're not in graphics mode, check whether we are mapping the output for this session */
		if(current->mapoutput) {	/* check whether we should map the characters output for this session */
			for(i=0; i<len; i++)	/* go through the entire line, mapping the characters output to the screen */
        draw_char[i]=outputtable[(unsigned char)ptr[i]];
			ptr = draw_char;
		  }	/* end if */
	  }	/* end else */
	if(Scmode())
		n_cheat(ptr,len);
	else
		n_draw(ptr,len); 
}

/*************************************************************************/
/*
*	RSsetatt()
*
*	set the attribute for real screen printing
*/
void RSsetatt(int a,int w)
{
	int c;

	if(VSisundl(a))
		c=screens[w]->colors[1];
	else
		if(VSisrev(a))
			c=screens[w]->colors[2];
		else
			c=screens[w]->colors[0];
	if(VSisblnk(a))
		c |= 128;				/* set blink bit */
	if(VSisbold(a))
		c |= 8;					/* set brightness bit */
	n_color(c);
	lastatt=a;
	lastw=w;
}

/*************************************************************************/
/*
*	RSdellines()
*
*	blank out a section of a series of lines
*/
void RSdellines(int w,int t,int b,int n,int select)
{
	int c;

	if(w!=thevis || n<1)
		return;							/* not visible */
	c=n_color(screens[w]->colors[0]);
	n_scrup(n,t,0,b,79);
	n_color(c);
	select=select;
}

/*************************************************************************/
/*
*	RSerase
*
*	blank out a reactangular section of the screen
*/
void RSerase(int w,int y1,int x1,int y2,int x2)
{
	int c;

	if(w!=thevis)
		return;							/* not visible */
	c=n_color(screens[w]->colors[0]);
	n_scrup(0,x1,y1,x2,y2);
	n_color(c);
}

/*************************************************************************/
/*
*	RSinslines()
*
*	scroll down a section of the screen in order to fit lines above them
*/
void RSinslines(int w,int t,int b,int n,int select)
{
	int c;

	if(w!=thevis || n<1)
		return;							/* not visible */
	c=n_color(screens[w]->colors[0]);
	n_scrdn(n,t,0,b,79);
	n_color(c);
	select=select;
}

/*************************************************************************/
/*
*	RSsendstring()
*
*	send a string over the network
*/
void RSsendstring(int w,char *ptr,int len)
{
	netwrite(screens[w]->pnum,ptr,len);
}


/*	Keyboard translations from the PC to VT100
*		Tim Krauskopf			Sept. 1986
*
*	original: ISP 1984
*	Re-written to handle arbitrary keyboard re-mapping,
*		 Quincey Koziol		Aug. 1990
*/

/***************************************************************************/
/*  takes a key value and checks whether it is a mapped key,
*		then checks whether it is a 'special' key (i.e. vt100 keys, and
*		maybe other kermit verbs), pass the characters on to the
*		TCP port in pnum.
*/
void vt100key(unsigned int c)
{
	key_node *temp_key;		/* pointer to the key map node which matches the character code */

	if(!IS_KEY_MAPPED(c)) {		/* if the key is not mapped, just send it */
    if(c<128 || (current->ibinary))       /* make certain it is just an ascii char which gets sent, unless we are transmitting binary data */
    netwrite(current->pnum,(char *)&c,1);
  } /* end if */
	else {		/* key is mapped */
   if(IS_KEY_SPECIAL(c)) {   /* check whether this is a special key code (i.e. a kermit verb) */
			if((temp_key=find_key(c))!=NULL)	/* get the pointer to the correct key mapping node */
				VSkbsend(current->vs,(unsigned char)(*temp_key).key_data.vt100_code,(int)!(current->echo));	/* send the vt100 sequence */
		  }	/* end if */
		else {		/* just pass along the string the key is mapped to */
			if((temp_key=find_key(c))!=NULL) {	/* get the pointer to the correct key mapping node */
				if((*temp_key).key_data.key_str!=NULL) {	/* verify that the string has been allocated */
					RSsendstring(current->vs,(*temp_key).key_data.key_str,strlen((*temp_key).key_data.key_str));
					if(!(current->echo))
						VSwrite(current->vs,(*temp_key).key_data.key_str,strlen((*temp_key).key_data.key_str));
				  }	/* end if */
			  }	/* end if */
		  }	/* end else */
	  }	/* end else */
}   /* end vt100key() */

/***********************************************************************/
/*  non-blocking RSgets()
*   This routine will continually add to a string that is re-submitted
*   until a special character is hit.  It never blocks.
*
*   As long as editing characters (bksp, Ctrl-U) and printable characters
*   are pressed, this routine will update the string.  When any other special
*   character is hit, that character is returned.  
*/
static char bk[]={8,' ',8};

int RSgets(int w,char *s,int lim,char echo)
{
	int c,count,i;
	char *save;

	count=strlen(s);
	save=s;
	s+=count;
	while(0<(c=n_chkchar())) {
        switch(c) {                 /* allow certain editing chars */
			case 8:					/* backspace */
			case BACKSPACE:			/* backspace */
				if(count) {
                    if(echo)
						VSwrite(w,bk,3);
					count--;		/* one less character */
					s--;			/* move pointer backward */
                  } /* end if */
				break;

			case 21:
                if(echo)
					for(i=0; i<s-save; i++)
                        VSwrite(w,bk,3);
				s=save;
				break;

			case 13:
			case 9:
			case TAB:
				*s='\0';			/* terminate the string */
				return(c);

			default:
				if(count==lim) {			/* to length limit */
                    RSbell(w);
					*s='\0';				/* terminate */
					return(0);
				  }
                if(c>31 && c<127) { /* check for printable ASCII */
                    if(echo)
						VSwrite(w,(char *)&c,1);
					*s++=(char)c;			/* add to string */
					count++;				/* length of string */
				  }
				else {
                    if(c>0 && c<27) {   /* print ASCII control char */
                        c+=64;
                        if(echo) {
							VSwrite(w,"^",1);
							VSwrite(w,(char *)&c,1);
                          }
                        c-=64;
					  }
					*s='\0';			/* terminate the string */
					return(c);
				  }
			break;
		  }
	  }
	*s='\0';			/* terminate the string */
	return(c);
}

/***********************************************************************/
/*  non-blocking gets()
*   This routine will call netsleep while waiting for keypresses during
*   a gets.  Replaces the library gets.
*
*   As long as editing characters (bksp, Ctrl-U) and printable characters
*   are pressed, this routine will continue.  When any other special
*   character is hit, NULL is returned.  the return key causes a normal return.
*/
char *nbgets(char *s,int lim)
{
	int c,count,i;
	char *save;

	count=0;
	save=s;
	while(1) {
		c=n_chkchar();
		if(c<=0) {
			Stask();			/* keep communications going */
			continue;			/* check for a character immediately */
		  }
		switch (c) {				/* allow certain editing chars */
			case 8:					/* backspace */
			case BACKSPACE:			/* backspace */
				if(count) {
					n_putchar((char)8);
					n_putchar(' ');
					n_putchar((char)8);
					count--;		/* one less character */
					s--;			/* move pointer backward */
				  }
				break;

			case 13:					/* carriage return,=ok */
				n_puts("");
				*s='\0';				/* terminate the string */
				return((char *)save);	/* return ok */

			case 21:		/* ctrl-u */
				for(i=0; i<s-save; i++) {
					n_putchar(8);
					n_putchar(' ');
					n_putchar(8);
				  }
				s=save;
				break;

			default:
				if(c>31 && c<127) {
					if(count<lim) {
						n_putchar((char)c);
						*s++=(char)c;			/* add to string */
						count++;				/* length of string */
					  }
				  }
				else {
					n_puts("");
					*s='\0';			/* terminate the string */
					return((char *)NULL);
				  }
			break;
		  }
	  }
}

/************************************************************************/
/*  nbgetch
*   check the keyboard for a character, don't block to wait for it,
*   but don't return to the caller until it is there.
*/
int nbgetch(void)
{
	int c;

	while(0>=(c=n_chkchar())) 		/* there is a key? */
		Stask();					/* no key yet, update everything */
	return(c);
}

#ifdef NOT_USED
/************************************************************************/
/* nbget
*   demux at least one packet each time, check the keyboard for a key, 
*   return any key pressed to the caller.
*/
int nbget(void)
{
	int c;

	demux(0);				/* only one packet */
	if(0>=(c=n_chkchar()))
		return(-1);			/* no key ready */
	return(c);
}
#endif

#ifdef FTP
/***********************************************************************/
/* ftpstart
*  update status line with new file length remaining
*/
void ftpstart(char dir,char *buf)
{
	int r,c,cl;
	long int fpos;

	r=n_row();
	c=n_col();
	cl=n_color(current->colors[0]);
	if(dir)
		dir='<';
	else
		dir='>';
	Sftpname(&buf[100]);	/* get file name */
	Sftpstat(&fpos);		/* get position in file */
	n_cur(numline+1,49);
	sprintf(buf,"FTP %c %14s %10lu",dir,&buf[100],fpos);
	if(Scmode()) 
		n_cheat(buf,strlen(buf));
	else
		n_draw(buf,strlen(buf));
	n_color(cl);
	n_cur(r,c);
}
#endif /* FTP */