home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Club Amiga de Montreal - CAM
/
CAM_CD_1.iso
/
files
/
019.lha
/
Aterm
/
FKeys.c
< prev
next >
Wrap
C/C++ Source or Header
|
1986-11-10
|
7KB
|
257 lines
/* FKeys.c */
#include <exec/types.h>
#include <stdio.h>
#include <fcntl.h>
#include "ConsoleIO.h"
/* things for function keys */
#define NUMKEYS 10 /* number of function keys */
#define KEYSIZE 40 /* maximum length of any one string */
#define BUFSIZE KEYSIZE * NUMKEYS /* size of total buffer */
#define HEADER '\x70' /* first byte of file is version number (7.0) */
#define MAXOPTION 256 /* maximum length of option string */
#define CSI '\x9b' /* Command Sequence Introducer */
#define DEL 127
#define LDK 128
#define LDX 129
#define F10 130
extern UBYTE *KeyBuf;
/*********************************************************************
** Some routines concerned with the function keys **
*********************************************************************/
extern void SetOptions();
extern int GetOptions();
/************* Attempt to load a Function-Key file ******************/
BOOL LoadKeys(keyfile) /* returns (BOOL) success */
char *keyfile; /* the filename */
{
int fp;
int i;
short optsize;
BOOL filefound = FALSE;
BOOL goodfile = TRUE;
UBYTE c, opt[ MAXOPTION ];
if ( (fp = open(keyfile, O_RDONLY)) == -1)
return FALSE;
i = read( fp, &c, sizeof( c ) );
if ( i == sizeof( c ) && c == HEADER ) /* gotta be a valid key file! */
{
filefound = TRUE;
i = read( fp, &optsize, sizeof( optsize ) );
if ( i != sizeof( optsize ) ||
!((0 <= optsize) && (optsize < MAXOPTION)) )
goodfile = FALSE;
else if ( read( fp, opt, optsize ) != optsize )
goodfile = FALSE;
else
{
SetOptions( opt, optsize );
if ( read( fp, KeyBuf, BUFSIZE ) != BUFSIZE )
goodfile = FALSE;
}
}
close( fp );
if ( !goodfile )
{
PutString( "Key Buffer file has been corrupted...\n." );
PutString( " Function Keys May be Invalid.\n" );
}
return filefound; /* ahh, success? */
}
/**************Save Function-Key file *****************/
BOOL SaveFKeys(filename) /* returns (BOOL) success */
char *filename;
{
int fp;
BOOL goodfile = TRUE;
short optsize;
UBYTE c = HEADER, opt[ MAXOPTION ];
if ( ( fp = open( filename, O_WRONLY + O_CREAT )) == -1)
return FALSE;
if ( write( fp, &c, sizeof( c)) != sizeof( c ))
goodfile = FALSE;
else if ( ( optsize = GetOptions( opt, MAXOPTION )) > MAXOPTION)
{
PutString( "Can't Happen: Too many options to save.\n" );
goodfile = FALSE;
}
else if ( write( fp, &optsize, sizeof( optsize )) != sizeof( optsize ))
goodfile = FALSE;
else if ( write( fp, opt, optsize ) != optsize )
goodfile = FALSE;
else if ( write( fp, KeyBuf, BUFSIZE ) != BUFSIZE )
goodfile = FALSE;
close( fp );
if ( !goodfile )
PutString( "Error writing file.\n");
return goodfile;
}
/************ Print the function-key number **************/
/* format example: F7: */
static void PrintKeyNum(keynum)
int keynum;
{
keynum++;
PutChar('F');
if ((keynum == 10) || (keynum == 0))
PutString("10: ");
else
{
PutChar(keynum + '0');
PutString(": ");
}
}
/*********** Print a character from function-key string ************/
void keychar(key)
UBYTE key;
{
if ((key > 129) && (key < 140 ))
{
PutChar('<');
PrintKeyNum (key - 131);
PutString ("\b>");
}
else
{
if ((key < ' ') || (key > DEL)) /* control character */
{
switch (key)
{ case 0:
PutChar('0');
break;
case '\b':
PutString("<BS>");
break;
case '\t':
PutString("<TAB>");
break;
case '\n':
PutString("<NL>");
break;
case '\r':
PutString("<CR>");
break;
case 27:
PutString("<ESC>");
break;
case LDK:
PutString("<LOAD>");
break;
case LDX:
PutString("<LOADEX>");
break;
default:
PutChar('^');
PutChar(key + 0x40);
} /* end switch(key) */
} /* end if control character */
else PutChar(key);
} /* end if FKey execute */
}
/************ Display Function-Key contents **********/
void DoContents()
{
int x;
UBYTE c, *offset;
for (x=0; x < NUMKEYS; x++)
{
offset = KeyBuf + KEYSIZE * x;
PrintKeyNum( x );
while ( c = *offset++ )
keychar(c);
PutChar('\n');
}
}
/******* Define a function-key string *********/
void DefineString()
{
UBYTE c, character;
int keynum, count, offset, i;
PutString( "\x9b33m\nFunction-Key String Definition:\n\n");
if ( GetKey() != CSI )
{ PutString( "\naborted...\n\n\x9bm" );
return;
}
else
{
character = GetKey(); /* get the meat of the sequence */
while ( GetKey() != '~' ); /* wait for sequence to end */
}
if (!( (character >= '0') && (character <= '9') )) /* isdigit? */
{
PutString( "aborted...\n\n\x9bm" );
return;
}
else
{
keynum = character - '0';
PrintKeyNum( keynum );
offset = KEYSIZE * keynum; /* find correct spot in buffer */
i = 0;
while ( (character = GetKey()) != CSI ) /* get the string */
{ if (i<(KEYSIZE-1))
{
if(character == 127) /* DEL key is used as a special */
{ /* FKey 'CSI'. Takes the next */
character = GetKey(); /* character as the function to */
switch (character) /* be stored in the FKey string. */
{ case 'l':
character = LDK; /* <LOAD> -- loads another FKey */
break; /* definition file. */
case 'L':
character = LDX; /* <LOADEX> -- takes the next */
break; /* character as the FKey to be */
/* executed AFTER loading the */
/* specified file. ie... */
/* <LOADEX>1key.file */
/* will load key.file, then */
/* execute FKey #1 as defined in */
/* key.file */
/* NOTE: 0 = FKey 10 */
default :
if ((character >= '0') && (character <= '9'))
character += 82;
break;
} /* end case */
}
KeyBuf[offset + (i++) ] = character; /* store it */
keychar(character); /* display it, too */
}
}
while (GetKey() != '~' ); /* skip over rest of F-key */
while (i < KEYSIZE)
{
KeyBuf[offset+i] = '\0'; /* zero out the rest of */
i++; /* that string's buffer */
}
PutString("\n\n");
PutString("\x9bm");
} /* end else */
} /* end DefineString(); */