Thread View: mod.amiga.sources
1 messages
1 total messages
Started by doc
Tue, 22 Jul 1986 20:59
vt100 emulator v1.1 (by Dave Wecker)
Author: doc
Date: Tue, 22 Jul 1986 20:59
Date: Tue, 22 Jul 1986 20:59
2813 lines
75824 bytes
75824 bytes
Here is a shell archive of the latest vt100 emulator by Dave Wecker.
He has fixed up alot of stuff and added alot of wanted features. I will
be first in saying "Thanx Dave" for all you've done so far!
# This is a shell archive.
# Remove everything above and including the cut line.
# Then run the rest of the file through sh.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: Shell Archiver
# Run the following text with /bin/sh to create:
# README
# Makefile
# make.scr
# colors.c
# init.c
# kermit.c
# remote.c
# vt100.c
# window.c
# xmodem.c
# vt100.h
# This archive created: Tue Jul 22 15:27:49 1986
# By: Craig Norborg (Purdue University Computing Center)
cat << \SHAR_EOF > README
This archive contains a vt100 emulator with KERMIT and XMODEM file transfer
protocols by Dave Wecker (Based on AmigaTerm).
Releases:
---------
v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
v1.0 860712 DBW - First version released
Release Notes:
--------------
v1.1 860720 DBW - Added command line switches (all optional):
1> vt100 [-s baud] [-f hex] [-b hex] [-c typ] [-t] [-i]
-s baud = Set speed (baud rate).
-f hex = Set foreground color (rgb hex number).
-b hex = Set background color (rgb hex number).
-c typ = Create window according to "typ":
0 = use WORKBENCH screen
1 = CUSTOM interlaced (1/2 screen)
2 = CUSTOM interlaced (full screen)
-t = Text mode for KERMIT (LF <--> CRLF)
-i = Image mode for KERMIT (no translation)
Defaults are:
1> vt100 -s 2400 -f a00 -b 200 -c 2 -i
- Added environment variables for all defaults. This allows
you to setup a custom environment by defining any of the
following:
vt100_speed - default baud rate
vt100_fg - default foreground color
vt100_bg - default background color
vt100_cust - create window of specified type
vt100_text - do KERMIT transfers in CRLF mode
vt100_image - do KERMIT transfers in image mode
A sample set of lines (in startup-sequence) could be:
set vt100_speed=1200 vt100_cust=0
set vt100_fg=666 vt100_bg=005 vt100_image=1
Which would give you a terminal emulator running at 1200
baud in the workbench screen with a white foreground and
a blue background (with KERMIT transfers in image mode)
any time you ran vt100. NOTE: command line switches
override any defaults set by environment variables.
- Menu item added to allow full control over colors while
running the emulator (using a palette editor).
- Using borderless window to allow full 80 columns (without
having to go to a smaller font).
- Erased part of the title bar so that a full 24 lines will
fit on a non interlaced workbench window (this is a
temporary kludge for now).
- Got rid of the un-necessary resize gadget.
- Made the custom screen half height and moved the window
accordingly (when cust = 1).
v1.0 860712 DBW - Initial (early) release.
Known problems:
---------------
- Alot of reports that KERMIT is sick. This will be the
next thing fixed.
- Several people said that everything but "larn" works.
Since I don't have "larn", what I really need to be sent
is the escape sequence(s) that do not work correctly.
I will be happy to fix the problem if it is specified
with a little more detail.
Installation:
-------------
The files in this archive may be extracted by the bourne shell (/bin/sh) or
the shar program using the "unshar switch (-u)", contact me if you need a
copy of this version of shar.
Files:
------
README - this file
makefile - a script that can be handed to "execute" to create
the emulator (switches are for MANX AZTEC-C).
vt100.h - include file used by all other modules
window.c - manager for window and keyboard
vt100.c - main module, handles menus
remote.c - handle remote characters (vt100 emulation)
kermit.c - kermit protocol (to transfer text files on VMS
select the CRLF option on the transfer mode menu,
otherwise use image mode).
init.c - startup code
xmodem.c - xmodem protocol that understands AMIGA binary and
text file formats (automatically).
colors.c - palette editor for foreground and background colors
Contact:
--------
Please send bugs/comments/suggestions to:
Dave Wecker at ENET: COOKIE::WECKER
ARPA: wecker%cookie.dec.com@decwrl.dec.com
USENET: decvax!decwrl!cookie.dec.com!wecker
SHAR_EOF
cat << \SHAR_EOF > Makefile
# *** Note *** Compilation will go faster if you have the libraries in
# RamDisk. This makefile lets the user decide if they wish to have it there
# or not
#
SRC = vt100.c init.c window.c xmodem.c remote.c kermit.c colors.c
OBJ = vt100.o init.o window.o xmodem.o remote.o kermit.o colors.o
HDR = vt100.h
all: vt100
vt100: $(OBJ)
ln -v -w -o vt100 $(OBJ) -lc
vt100.syms: vt100.h
echo
vt100.o: vt100.c vt100.h
cc +Hvt100.syms vt100.c
init.o: init.c vt100.syms vt100.h
cc +Ivt100.syms init.c
window.o: window.c vt100.syms vt100.h
cc +Ivt100.syms window.c
xmodem.o: xmodem.c vt100.syms vt100.h
cc +Ivt100.syms xmodem.c
remote.o: remote.c vt100.syms vt100.h
cc +Ivt100.syms remote.c
kermit.o: kermit.c vt100.syms vt100.h
cc +Ivt100.syms kermit.c
colors.o: colors.c vt100.syms vt100.h
cc +Ivt100.syms colors.c
SHAR_EOF
cat << \SHAR_EOF > make.scr
. Script to build vt100 terminal emulator
. v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
. v1.0 860712 DBW - First version released
. ----------
. Type "execute makefile" to build the emulator
. ----------
echo "cc +Hvt100.syms vt100.c"
cc +Hvt100.syms vt100.c
. ----------
echo "cc +Ivt100.syms init.c"
cc +Ivt100.syms init.c
. ----------
echo "cc +Ivt100.syms window.c"
cc +Ivt100.syms window.c
. ----------
echo "cc +Ivt100.syms xmodem.c"
cc +Ivt100.syms xmodem.c
. ----------
echo "cc +Ivt100.syms remote.c"
cc +Ivt100.syms remote.c
. ----------
echo "cc +Ivt100.syms kermit.c"
cc +Ivt100.syms kermit.c
. ----------
echo "cc +Ivt100.syms colors.c"
cc +Ivt100.syms colors.c
. ----------
if not exists ram:c.lib
echo "Copying c.lib to ram"
copy df0:lib/c.lib ram:
set CLIB=ram:
endif
echo "Linking vt100"
ln -v -w -o vt100 vt100.o init.o window.o xmodem.o remote.o kermit.o colors.o -lc
. ----------
echo "Done!"
SHAR_EOF
cat << \SHAR_EOF > colors.c
/***********************************************************************
* vt100 terinal emulator - COLOR map setting program
* (code from MicroSmith's PALETTE tool)
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
***********************************************************************/
#define MODULE_COLORS 1
#include "vt100.h"
#define NL 0
#define PLX 165 /* Palette Window Size */
#define PLY 84
#define PGAD 0 /* You can offset the gadgets here */
#define PGHI PGAD+CTSIZ /* Offset frm color selectors */
struct IntuiText rtxt = {1,0,JAM2,-9,2,NL,(UBYTE *)"R",NL};
struct IntuiText gtxt = {1,0,JAM2,-9,2,NL,(UBYTE *)"G",NL};
struct IntuiText btxt = {1,0,JAM2,-9,2,NL,(UBYTE *)"B",NL};
struct Image r_img, g_img, b_img;
struct PropInfo r_prop,g_prop,b_prop;
struct Gadget blue_gad = {
NL, 17,67, 90,11, GADGHCOMP, GADGIMMEDIATE | RELVERIFY,
PROPGADGET,(APTR)&b_img, NL,
&btxt, NL,(APTR)&b_prop, PGHI+3, NL };
struct Gadget green_gad = {
&blue_gad, 17,51, 90,11, GADGHCOMP, GADGIMMEDIATE | RELVERIFY,
PROPGADGET,(APTR)&g_img, NL,
>xt, NL,(APTR)&g_prop, PGHI+4, NL };
struct Gadget red_gad = {
&green_gad, 17,35, 90,11, GADGHCOMP, GADGIMMEDIATE | RELVERIFY,
PROPGADGET,(APTR)&r_img, NL,
&rtxt, NL,(APTR)&r_prop, PGHI+5, NL };
struct IntuiText oktxt = {1,0,JAM2,8,2,NL,(UBYTE *)" OK ",NL};
struct IntuiText cntxt = {1,0,JAM2,0,2,NL,(UBYTE *)"Cancel",NL};
struct IntuiText retxt = {1,0,JAM2,4,2,NL,(UBYTE *)"Reset",NL};
char frog[] = "hex";
struct IntuiText hxtxt = {1,0,JAM2,136,19,NL,(UBYTE *)frog,NL};
struct Gadget re_gad = {
&red_gad, 110,67, 54,11, GADGHCOMP, RELVERIFY,
BOOLGADGET, NL, NL,
&retxt, NL,NL, PGHI+2, NL };
struct Gadget cn_gad = {
&re_gad, 110,51, 54,11, GADGHCOMP, RELVERIFY,
BOOLGADGET, NL, NL,
&cntxt, NL,NL, PGHI+1, NL };
struct Gadget ok_gad = {
&cn_gad, 110,35, 54,11, GADGHCOMP, RELVERIFY,
BOOLGADGET, NL, NL,
&oktxt, NL,NL, PGHI, NL };
struct Image m3C[CTSIZ] = {
{0,0,16,16,1, NL ,0,0,NL }, /* Colors */
{0,0,16,16,1, NL ,0,1,NL } };
struct Gadget palg[CTSIZ] = {
{ &palg[1], 3, 3, 16,16, GADGHBOX | GADGIMAGE, RELVERIFY,
BOOLGADGET, (APTR)&m3C[0], NL,NL,NL,NL, PGAD+0, NL},
{ &ok_gad, 19,3, 16,16, GADGHBOX | GADGIMAGE, RELVERIFY,
BOOLGADGET, (APTR)&m3C[1], NL,NL,NL,NL, PGAD+1, NL} };
/* Used to open a Window */
struct NewWindow NewCmod = {
40,30, PLX,PLY, 0,1,
MOUSEBUTTONS | MOUSEMOVE | MENUVERIFY | MENUPICK | GADGETUP |
GADGETDOWN | CLOSEWINDOW | ACTIVEWINDOW,
ACTIVATE | SMART_REFRESH,
&palg[0],NL, NL, /* FirstGadget, CheckMark, Title */
NL,NL, /* MUST SET SCREEN AFTER OPENSCREEN!!! */
PLX,PLY,PLX,PLY, CUSTOMSCREEN }; /* MinW, MinH, MaxW, MaxH */
/********************************************************************
* palette(window)
* This is the meat. This routine opens the palette window and
* retains control until the user selects the OK or CANCEL gadget.
* The calling argment is a window pointer. That window
* is expected to have opened an IDCMP port, which palette uses.
********************************************************************/
palette(calling_window)
struct Window *calling_window;
{
struct Window *cW; /* Palette window handle */
register struct IntuiMessage *imsg;
register struct Gadget *igad;
register int class,cursel;
BOOL keepon,munge;
USHORT backup[CTSIZ]; /* This table restores calling colors... */
static char hxtab[16] = { '0','1','2','3','4','5','6','7','8',
'9','a','b','c','d','e','f' };
for ( cursel=CTSIZ-1; cursel >= 0; cursel--)
backup[cursel] = mycolortable[cursel];
cursel = 0;
r_prop.Flags = g_prop.Flags = b_prop.Flags = FREEHORIZ | AUTOKNOB;
r_prop.HorizBody = g_prop.HorizBody = b_prop.HorizBody = 0x1000;
/* Get screen from calling window */
NewCmod.Screen = calling_window->WScreen; /* NEED TO SET SCREEN!!! */
if ( ! (cW = (struct Window *)OpenWindow(&NewCmod)) ) {
return(FALSE); /* Oops... */
}
for ( munge = keepon = TRUE; keepon; ) {
if ( munge ) {
/* RJ will proably cringe if he see's this, but it is proably */
/* safe to modify the HorizPot values this way, UNLESS the */
/* gadgets were being fiddled with when you do it. Here that */
/* is quite unlikely, since another gadget was juthat */
/* is quite unlikely, since another gadget was just activated */
/* to cause the munge flag to be set... */
r_prop.HorizPot = (mycolortable[cursel] & 0xf00) << 4;
g_prop.HorizPot = (mycolortable[cursel] & 0x0f0) << 8;
b_prop.HorizPot = mycolortable[cursel] << 12;
RefreshGadgets(&red_gad,cW,NL);
munge = FALSE;
hxtxt.FrontPen = cursel ^ 15;
hxtxt.BackPen = cursel;
}
while ( ! (imsg=(struct IntuiMessage *)GetMsg(cW->UserPort)) ) {
class = mycolortable[cursel] = ((r_prop.HorizPot >> 4) & 0xf00) +
((g_prop.HorizPot >> 8) & 0xf0) + (b_prop.HorizPot >>12);
LoadRGB4(myviewport,mycolortable,CTSIZ);
frog[0] = hxtab[class >> 8];
frog[1] = hxtab[ (class >> 4) & 0x0f];
frog[2] = hxtab[class & 0x0f];
PrintIText(cW->RPort,&hxtxt,0,0);
/* Proably, should do a WaitPort(cW->UserPort); */
/* I didn't, so the color updates faster. */
/* In a multitasking environment, the system is */
/* being gronked... */
}
igad =(struct Gadget *) imsg->IAddress;
if ( (class = imsg->Class) == MENUVERIFY ) {
imsg->Code = MENUCANCEL; /* Don't Let Em Out! */
DisplayBeep(NL);
}
ReplyMsg(imsg);
switch ( class ) {
case GADGETUP:
case GADGETDOWN:
if ((igad->GadgetID >= PGAD)&&(igad->GadgetID < PGAD+CTSIZ)) {
cursel = igad->GadgetID - PGAD;
munge = TRUE;
}
else switch ( igad->GadgetID ) {
case PGHI+1: /* Cancel */
for ( class =0 ; class<CTSIZ; class++)
mycolortable[class] = backup[class];
LoadRGB4(myviewport,mycolortable,CTSIZ);
case PGHI: /* OK */
keepon = FALSE;
break;
case PGHI+2: /* Reset */
for (class = 0; class < CTSIZ; class++)
mycolortable[class] = default_color[class];
LoadRGB4(myviewport,mycolortable,CTSIZ);
munge = TRUE;
break;
}
}
}
cW->UserPort = NL;
CloseWindow(cW);
return(TRUE);
}
SHAR_EOF
cat << \SHAR_EOF > init.c
/***************************************************************
* vt100 - terminal emulator - initialization
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
***************************************************************/
#define MODULE_INIT 1
#include "vt100.h"
#define BADCH ((int)'?')
#define EMSG ""
#define tell(s) {fputs(*nargv,stderr);fputs((s),stderr); \
fputc(optopt,stderr);fputc('\n',stderr);return(BADCH);}
#define USAGE "Usage: vt100 [-s baudrate] [-f hexcolor] [-b hexcolor] [-c type] [-t] [-i]\n"
#define OPTSTRING "s:f:b:c:ti"
extern char *index(),*getenv();
int optind = 1, /* index into parent argv vector */
optopt; /* character checked for validity */
char *optarg; /* argument associated with option */
/*
* get option letter from argument vector
*/
int getopt(nargc, nargv, ostr)
int nargc;
char **nargv, *ostr;
{
register char *oli; /* option letter list index */
static char *place = EMSG; /* option letter processing */
if (!*place) { /* update scanning pointer */
if (optind >= nargc ||
*(place = nargv[optind]) != '-' || !*++place) return(EOF);
if (*place == '-') { /* found "--" */
++optind;
return EOF;
}
} /* option letter okay? */
if ((optopt=(int)*place++)==(int)':' || !(oli=index(ostr,optopt))) {
if (!*place) ++optind;
tell(": illegal option -- ");
}
if (*++oli != ':') { /* don't need argument */
optarg = NULL;
if (!*place) ++optind;
}
else { /* need an argument */
if (*place) optarg = place; /* no white space */
else if (nargc <= ++optind) { /* no arg */
place = EMSG;
tell(": option requires an argument -- ");
}
else {
optarg = nargv[optind]; /* white space */
}
place = EMSG;
++optind;
}
return optopt; /* dump back option letter */
}
InitDefaults(argc,argv)
int argc;
char **argv;
{
short errflg = 0;
char *s,C;
/* first get any environment variables */
if ((s = getenv("vt100_speed")) != NULL)
if (sscanf(s,"%d",&speed) != 1)
speed = 2400;
if ((s = getenv("vt100_fg")) != NULL)
if (sscanf(s,"%x",&default_color[1]) != 1)
default_color[1] = 0xA00;
if ((s = getenv("vt100_bg")) != NULL)
if (sscanf(s,"%x",&default_color[0]) != 1)
default_color[0] = 0x200;
if ((s = getenv("vt100_cust")) != NULL)
if (sscanf(s,"%d",&cust) != 1)
cust = 2;
if (getenv("vt100_text") != NULL) imagemode = 0;
if (getenv("vt100_image") != NULL) imagemode = 1;
/* now check any command line switches */
while(EOF != (C = getopt(argc, argv, OPTSTRING)) &&
errflg == 0) {
switch(C) {
case 's':
if (sscanf(optarg,"%d",&speed) != 1) ++errflg;
break;
case 'f':
if (sscanf(optarg,"%x",&default_color[1]) != 1) ++errflg;
break;
case 'b':
if (sscanf(optarg,"%x",&default_color[0]) != 1) ++errflg;
break;
case 'c':
if (sscanf(optarg,"%d",&cust) != 1) ++errflg;
break;
case 't':
imagemode = 0;
break;
case 'i':
imagemode = 1;
break;
default:
++errflg;
break;
}
}
if (errflg != 0) {
puts(USAGE);
exit(TRUE);
}
}
InitDevs()
{
int i;
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", INTUITION_REV);
if( IntuitionBase == NULL )
{
puts("can't open intuition\n");
exit(TRUE);
}
GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",GRAPHICS_REV);
if( GfxBase == NULL )
{
puts("can't open graphics library\n");
exit(TRUE);
}
if (cust == 0) {
NewWindow.TopEdge = 0L;
NewWindow.Screen = NULL;
NewWindow.Type = WBENCHSCREEN;
}
else {
if (cust == 2) {
NewScreen.TopEdge = 0L;
NewScreen.Height = 400L;
}
if ((myscreen = (struct Screen *)OpenScreen(&NewScreen)) == NULL) {
puts("can't open screen!!\n");
exit(TRUE);
}
NewWindow.Screen = myscreen;
}
if(( mywindow = (struct Window *)OpenWindow(&NewWindow) ) == NULL)
{
puts("cant open window\n");
if (cust != 0) CloseScreen( myscreen );
exit(TRUE);
}
myviewport = (struct ViewPort *)ViewPortAddress(mywindow);
mycolormap = (struct ColorMap *)GetColorMap(CTSIZ);
mycolortable = (USHORT *)mycolormap->ColorTable;
Prefs = (struct Preferences *)
AllocMem((long)sizeof(*Prefs),MEMF_PUBLIC|MEMF_CLEAR);
if (!GetPrefs(Prefs,(long)sizeof(*Prefs))) {
orig_color[0] = Prefs->color0;
orig_color[1] = Prefs->color1;
}
FreeMem(Prefs,(long)sizeof(*Prefs));
for (i = 0; i < CTSIZ; i++) mycolortable[i] = default_color[i];
LoadRGB4(myviewport,mycolortable,CTSIZ);
Read_Request = (struct IOExtSer *)
AllocMem((long)sizeof(*Read_Request),MEMF_PUBLIC|MEMF_CLEAR);
Read_Request->io_SerFlags = SERF_SHARED | SERF_XDISABLED;
Read_Request->IOSer.io_Message.mn_ReplyPort = CreatePort("Read_RS",0);
if(OpenDevice(SERIALNAME,NULL,Read_Request,NULL))
{
puts("Cant open Read device\n");
FreeColorMap( mycolormap );
CloseWindow( mywindow );
if (cust != 0) CloseScreen( myscreen );
DeletePort(Read_Request->IOSer.io_Message.mn_ReplyPort);
FreeMem(Read_Request,(long)sizeof(*Read_Request));
exit(TRUE);
}
Read_Request->IOSer.io_Command = CMD_READ;
Read_Request->IOSer.io_Length = 1;
Read_Request->IOSer.io_Data = (APTR) &rs_in[0];
Write_Request = (struct IOExtSer *)AllocMem((long)sizeof(*Write_Request),MEMF_PUBLIC|MEMF_CLEAR);
Write_Request->io_SerFlags = SERF_SHARED | SERF_XDISABLED;
Write_Request->IOSer.io_Message.mn_ReplyPort = CreatePort("Write_RS",0);
if(OpenDevice(SERIALNAME,NULL,Write_Request,NULL))
{
puts("Cant open Write device\n");
FreeColorMap( mycolormap );
CloseWindow( mywindow );
if (cust != 0) CloseScreen( myscreen );
DeletePort(Write_Request->IOSer.io_Message.mn_ReplyPort);
FreeMem(Write_Request,(long)sizeof(*Write_Request));
DeletePort(Read_Request->IOSer.io_Message.mn_ReplyPort);
FreeMem(Read_Request,(long)sizeof(*Read_Request));
exit(TRUE);
}
Write_Request->IOSer.io_Command = CMD_WRITE;
Write_Request->IOSer.io_Length = 1;
Write_Request->IOSer.io_Data = (APTR) &rs_out[0];
Read_Request->io_SerFlags = SERF_SHARED | SERF_XDISABLED;
Read_Request->io_Baud = speed;
Read_Request->io_ReadLen = 8;
Read_Request->io_WriteLen = 8;
Read_Request->io_CtlChar = 1L;
Read_Request->IOSer.io_Command = SDCMD_SETPARAMS;
DoIO(Read_Request);
Read_Request->IOSer.io_Command = CMD_READ;
}
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the File menu topic. */
/*****************************************************************/
InitFileItems()
{
short n;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<FILEMAX; n++ )
{
FileItem[n].NextItem = &FileItem[n+1];
FileItem[n].LeftEdge = 0;
FileItem[n].TopEdge = 11 * n;
FileItem[n].Width = 135;
FileItem[n].Height = 11;
FileItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHBOX;
FileItem[n].MutualExclude = 0;
FileItem[n].ItemFill = (APTR)&FileText[n];
FileItem[n].SelectFill = NULL;
FileItem[n].Command = 0;
FileItem[n].SubItem = NULL;
FileItem[n].NextSelect = 0;
FileText[n].FrontPen = 0;
FileText[n].BackPen = 1;
FileText[n].DrawMode = JAM2; /* render in fore and background */
FileText[n].LeftEdge = 0;
FileText[n].TopEdge = 1;
FileText[n].ITextFont = NULL;
FileText[n].NextText = NULL;
}
FileItem[FILEMAX-1].NextItem = NULL;
/* initialize text for specific menu items */
FileText[0].IText = (UBYTE *)"Ascii Capture";
FileText[1].IText = (UBYTE *)"Ascii Send";
FileText[2].IText = (UBYTE *)"Xmodem Receive";
FileText[3].IText = (UBYTE *)"Xmodem Send";
FileText[4].IText = (UBYTE *)"Kermit Receive";
FileText[5].IText = (UBYTE *)"Kermit Send";
return( 0 );
}
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the BaudRate menu topic. */
/*****************************************************************/
InitRSItems()
{
short n;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<RSMAX; n++ )
{
RSItem[n].NextItem = &RSItem[n+1];
RSItem[n].LeftEdge = 0;
RSItem[n].TopEdge = 11 * n;
RSItem[n].Width = 85;
RSItem[n].Height = 11;
RSItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHBOX | CHECKIT;
RSItem[n].MutualExclude = (~(1 << n));
RSItem[n].ItemFill = (APTR)&RSText[n];
RSItem[n].SelectFill = NULL;
RSItem[n].Command = 0;
RSItem[n].SubItem = NULL;
RSItem[n].NextSelect = 0;
RSText[n].FrontPen = 0;
RSText[n].BackPen = 1;
RSText[n].DrawMode = JAM2; /* render in fore and background */
RSText[n].LeftEdge = 0;
RSText[n].TopEdge = 1;
RSText[n].ITextFont = NULL;
RSText[n].NextText = NULL;
}
RSItem[RSMAX-1].NextItem = NULL;
/* select baud item chekced */
switch (speed) {
case 300: n = 0; break;
case 1200: n = 1; break;
case 2400: n = 2; break;
case 4800: n = 3; break;
case 9600: n = 4; break;
default: n = 2;
}
RSItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHBOX | CHECKIT | CHECKED;
/* initialize text for specific menu items */
RSText[0].IText = (UBYTE *)" 300";
RSText[1].IText = (UBYTE *)" 1200";
RSText[2].IText = (UBYTE *)" 2400";
RSText[3].IText = (UBYTE *)" 4800";
RSText[4].IText = (UBYTE *)" 9600";
return( 0 );
}
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the Transfer Mode menu topic. */
/*****************************************************************/
InitXFItems()
{
short n;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<XFMAX; n++ )
{
XFItem[n].NextItem = &XFItem[n+1];
XFItem[n].LeftEdge = 0;
XFItem[n].TopEdge = 11 * n;
XFItem[n].Width = 85;
XFItem[n].Height = 11;
XFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHBOX | CHECKIT;
XFItem[n].MutualExclude = (~(1 << n));
XFItem[n].ItemFill = (APTR)&XFText[n];
XFItem[n].SelectFill = NULL;
XFItem[n].Command = 0;
XFItem[n].SubItem = NULL;
XFItem[n].NextSelect = 0;
XFText[n].FrontPen = 0;
XFText[n].BackPen = 1;
XFText[n].DrawMode = JAM2; /* render in fore and background */
XFText[n].LeftEdge = 0;
XFText[n].TopEdge = 1;
XFText[n].ITextFont = NULL;
XFText[n].NextText = NULL;
}
XFItem[XFMAX-1].NextItem = NULL;
/* IMAGE mode checked */
XFItem[1].Flags = ITEMTEXT | ITEMENABLED | HIGHBOX | CHECKIT | CHECKED;
imagemode = 1;
/* initialize text for specific menu items */
XFText[0].IText = (UBYTE *)" CR LF";
XFText[1].IText = (UBYTE *)" image";
return( 0 );
}
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the Color menu topic. */
/*****************************************************************/
InitCMItems()
{
short n;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<CMMAX; n++ )
{
CMItem[n].NextItem = &CMItem[n+1];
CMItem[n].LeftEdge = 0;
CMItem[n].TopEdge = 11 * n;
CMItem[n].Width = 85;
CMItem[n].Height = 11;
CMItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHBOX;
CMItem[n].MutualExclude = 0;
CMItem[n].ItemFill = (APTR)&CMText[n];
CMItem[n].SelectFill = NULL;
CMItem[n].Command = 0;
CMItem[n].SubItem = NULL;
CMItem[n].NextSelect = 0;
CMText[n].FrontPen = 0;
CMText[n].BackPen = 1;
CMText[n].DrawMode = JAM2; /* render in fore and background */
CMText[n].LeftEdge = 0;
CMText[n].TopEdge = 1;
CMText[n].ITextFont = NULL;
CMText[n].NextText = NULL;
}
CMItem[CMMAX-1].NextItem = NULL;
/* initialize text for specific menu items */
CMText[0].IText = (UBYTE *)"Colors";
CMText[1].IText = (UBYTE *)"Reset";
return( 0 );
}
/**********************************************************************/
/* The following function initializes the Menu structure array with */
/* appropriate values for our simple menu strip. Review the manual */
/* if you need to know what each value means. */
/**********************************************************************/
InitMenu()
{
menu[0].NextMenu = &menu[1];
menu[0].LeftEdge = 5;
menu[0].TopEdge = 0;
menu[0].Width = 50;
menu[0].Height = 10;
menu[0].Flags = MENUENABLED;
menu[0].MenuName = "File"; /* text for menu-bar display */
menu[0].FirstItem = &FileItem[0]; /* pointer to first item in list */
menu[1].NextMenu = &menu[2];
menu[1].LeftEdge = 65;
menu[1].TopEdge = 0;
menu[1].Width = 85;
menu[1].Height = 10;
menu[1].Flags = MENUENABLED;
menu[1].MenuName = "BaudRate"; /* text for menu-bar display */
menu[1].FirstItem = &RSItem[0]; /* pointer to first item in list */
menu[2].NextMenu = &menu[3];
menu[2].LeftEdge = 160;
menu[2].TopEdge = 0;
menu[2].Width = 85;
menu[2].Height = 10;
menu[2].Flags = MENUENABLED;
menu[2].MenuName = "Xfer Mode"; /* text for menu-bar display */
menu[2].FirstItem = &XFItem[0]; /* pointer to first item in list */
menu[3].NextMenu = NULL;
menu[3].LeftEdge = 260;
menu[3].TopEdge = 0;
menu[3].Width = 110;
menu[3].Height = 10;
menu[3].Flags = MENUENABLED;
menu[3].MenuName = "Change Colors"; /* text for menu-bar display */
menu[3].FirstItem = &CMItem[0]; /* pointer to first item in list */
return( 0 );
}
SHAR_EOF
cat << \SHAR_EOF > kermit.c
/*************************************************************
* vt100 terminal emulator - KERMIT protocol support
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
*************************************************************/
#define MODULE_KERMIT 1
#include "vt100.h"
#define MAXPACKSIZ 94 /* Maximum msgpkt size */
#define SOH 1 /* Start of header */
#define CR 13 /* ASCII Carriage Return */
#define LF 10 /* ASCII line feed */
#define SP 32 /* ASCII space */
#define DEL 127 /* Delete (rubout) */
#define MAXTRY 10 /* Times to retry a msgpkt */
#define MYQUOTE '#' /* Quote character I will use */
#define MYRPTQ '~' /* Repeat quote character */
#define MYPAD 0 /* Number of padding characters I will need */
#define MYPCHAR 0 /* Padding character I need (NULL) */
#define MYEOL '\n' /* End-Of-Line character I need */
#define MYTIME 10 /* Seconds after which I should be timed out */
#define MAXTIM 60 /* Maximum timeout interval */
#define MINTIM 2 /* Minumum timeout interval */
#define tochar(ch) ((ch) + ' ')
#define unchar(ch) ((ch) - ' ')
#define ctl(ch) ((ch) ^ 64 )
/* Global Variables */
short
size, /* Size of present data */
osize, /* Size of last data entry */
rpsiz, /* Maximum receive msgpkt size */
spsiz, /* Maximum send msgpkt size */
timint, /* Time interval to wait */
pad, /* How much padding to send */
n, /* Packet number */
numtry, /* Times this msgpkt retried */
oldtry, /* Times previous msgpkt retried */
rptflg, /* are we doing repeat quoting */
first, /* is this the first time in a file */
rpt; /* current repeat count */
char
next, /* what is the next character */
t, /* current character */
state, /* Present state of the automaton */
padchar, /* Padding character to send */
eol, /* End-Of-Line character to send */
quote, /* Quote character in incoming data */
rptq, /* Quote character for repeats */
ackpkt[MAXPACKSIZ+10], /* ACK/NAK packet buffer */
msgpkt[MAXPACKSIZ+10], /* Message Packet buffer */
filnam[40]; /* remote file name */
FILE *fp; /* file for send/receive */
doksend(file)
char *file;
{
short retval;
if ((fp = fopen(file,"r")) == NULL) {
emits("Cannot open send file\n");
return FALSE;
}
emits("Remote file name [local name]: ");
filename(filnam);
if (filnam[0] == 0) strcpy(filnam,file);
timeout = FALSE;
emits("\nType <ESC> to abort transfer\n");
retval = sendsw();
emits("\n");
fclose(fp);
return(retval);
}
dokreceive(file)
char *file;
{
short retval;
if ((fp = fopen(file,"w")) == NULL) {
emits("Cannot open file\n");
return FALSE;
}
emits("Remote file name [local name]: ");
filename(filnam);
if (filnam[0] == 0) strcpy(filnam,file);
timeout = FALSE;
emits("\nType <esc> to abort transfer\n");
retval = recsw();
emits("\n");
fclose(fp);
return(retval);
}
sendsw()
{
char sinit(), sfile(), sdata(), seof(), sbreak();
state = 'S';
n = 0;
numtry = 0;
while(TRUE) {
switch(state) {
case 'S': state = sinit(); break;
case 'F': state = sfile(); break;
case 'D': state = sdata(); break;
case 'Z': state = seof(); break;
case 'B': state = sbreak(); break;
case 'C': return(TRUE);
case 'A': return(FALSE);
default: return(FALSE);
}
}
}
char sinit()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
spar(msgpkt);
spack('S',n,9,msgpkt);
switch(rpack(&len,&num,ackpkt)) {
case 'N': return(state);
case 'Y': if (n != num) return(state);
rpar(ackpkt);
if (eol == 0) eol = '\n';
if (quote == 0) quote = '#';
numtry = 0;
n = (n+1)%64;
return('F');
case 'E': return('A');
case FALSE:return(state);
default: return('A');
}
}
char sfile()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
spack('F',n,strlen(filnam),filnam);
switch(rpack(&len,&num,ackpkt)) {
case 'N':
num = (--num<0 ? 63:num);
if (n != num) return(state);
case 'Y':
if (n != num) return(state);
numtry = 0;
n = (n+1)%64;
first = 1;
size = getpkt();
return('D');
case 'E':
return('A');
case FALSE: return(state);
default: return('A');
}
}
char sdata()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
spack('D',n,size,msgpkt);
switch(rpack(&len,&num,ackpkt)) {
case 'N':
num = (--num<0 ? 63:num);
if (n != num) return(state);
case 'Y':
if (n != num) return(state);
numtry = 0;
n = (n+1)%64;
if ((size = getpkt()) == 0) return('Z');
return('D');
case 'E':
return('A');
case FALSE: return(state);
default: return('A');
}
}
char seof()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
spack('Z',n,0,msgpkt);
switch(rpack(&len,&num,ackpkt)) {
case 'N':
num = (--num<0 ? 63:num);
if (n != num) return(state);
case 'Y':
if (n != num) return(state);
numtry = 0;
n = (n+1)%64;
return('B');
case 'E':
return('A');
case FALSE: return(state);
default: return('A');
}
}
char sbreak()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
spack('B',n,0,msgpkt);
switch (rpack(&len,&num,ackpkt)) {
case 'N':
num = (--num<0 ? 63:num);
if (n != num) return(state);
case 'Y':
if (n != num) return(state);
numtry = 0;
n = (n+1)%64;
return('C');
case 'E':
return('A');
case FALSE: return(state);
default: return ('A');
}
}
recsw()
{
char rinit(), rfile(), rdata();
state = 'R';
n = 0;
numtry = 0;
while(TRUE) {
switch(state) {
case 'R': state = rinit(); break;
case 'F': state = rfile(); break;
case 'D': state = rdata(); break;
case 'C': return(TRUE);
case 'A': return(FALSE);
}
}
}
char rinit()
{
int len, num;
if (numtry++ > MAXTRY) return('A');
spack('R',n,strlen(filnam),filnam);
switch(rpack(&len,&num,msgpkt)) {
case 'S':
rpar(msgpkt);
spar(msgpkt);
spack('Y',n,9,msgpkt);
oldtry = numtry;
numtry = 0;
n = (n+1)%64;
return('F');
case 'E':
return('A');
case FALSE:
spack('N',n,0,0);
return(state);
default:
return('A');
}
}
char rfile()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
switch(rpack(&len,&num,msgpkt)) {
case 'S':
if (oldtry++ > MAXTRY) return('A');
if (num == ((n==0) ? 63:n-1)) {
spar(msgpkt);
spack('Y',num,9,msgpkt);
numtry = 0;
return(state);
}
else return('A');
case 'Z':
if (oldtry++ > MAXTRY) return('A');
if (num == ((n==0) ? 63:n-1)) {
spack('Y',num,0,0);
numtry = 0;
return(state);
}
else return('A');
case 'F':
if (num != n) return('A');
spack('Y',n,0,0);
oldtry = numtry;
numtry = 0;
n = (n+1)%64;
return('D');
case 'B':
if (num != n) return ('A');
spack('Y',n,0,0);
return('C');
case 'E':
return('A');
case FALSE:
spack('N',n,0,0);
return(state);
default:
return ('A');
}
}
char rdata()
{
int num, len;
if (numtry++ > MAXTRY) return('A');
switch(rpack(&len,&num,msgpkt)) {
case 'D':
if (num != n) {
if (oldtry++ > MAXTRY) return('A');
if (num == ((n==0) ? 63:n-1)) {
spack('Y',num,6,msgpkt);
numtry = 0;
return(state);
}
else return('A');
}
decode();
spack('Y',n,0,0);
oldtry = numtry;
numtry = 0;
n = (n+1)%64;
return('D');
case 'F':
if (oldtry++ > MAXTRY) return('A');
if (num == ((n==0) ? 63:n-1)) {
spack('Y',num,0,0);
numtry = 0;
return(state);
}
else return('A');
case 'Z':
if (num != n) return('A');
spack('Y',n,0,0);
n = (n+1)%64;
return('C');
case 'E':
return('A');
case FALSE:
spack('N',n,0,0);
return(state);
default:
return('A');
}
}
spack(type,num,len,data)
char type, *data;
short num, len;
{
short i;
char chksum, buffer[100];
register char *bufp;
if (type != 'Y' && type != 'N') {
if (num == 0) emits("\n");
emit(type);
}
bufp = buffer;
for (i=1; i<=pad; i++) sendchar(padchar);
*bufp++ = SOH;
*bufp++ = tochar(len+3);
chksum = tochar(len+3);
*bufp++ = tochar(num);
chksum += tochar(num);
*bufp++ = type;
chksum += type;
for (i=0; i<len; i++) {
*bufp++ = data[i];
chksum += data[i];
}
chksum = (((chksum&0300) >> 6)+chksum)&077;
*bufp++ = tochar(chksum);
*bufp++ = '\r';
*bufp++ = '\n';
*bufp = 0;
sendstring(buffer);
}
rpack(len,num,data)
short *len, *num;
char *data;
{
short i, done;
char t, type, cchksum, rchksum;
while (t != SOH) {
t = readchar();
if (timeout) return(FALSE);
}
done = FALSE;
while (!done) {
t = readchar();
if (timeout) return(FALSE);
if (t == SOH) continue;
cchksum = t;
*len = unchar(t)-3;
t = readchar();
if (timeout) return(FALSE);
if (t == SOH) continue;
cchksum = cchksum + t;
*num = unchar(t);
t = readchar();
if (timeout) return(FALSE);
if (t == SOH) continue;
cchksum = cchksum + t;
type = t;
for (i=0; i<*len; i++) {
t = readchar();
if (timeout) return(FALSE);
if (t == SOH) continue;
cchksum = cchksum + t;
data[i] = t;
}
data[*len] = 0;
t = readchar();
if (timeout) return(FALSE);
rchksum = unchar(t);
t = readchar();
if (timeout) return(FALSE);
if (t == SOH) continue;
done = TRUE;
}
if (type != 'Y' && type != 'N') {
if (*num == 0) emits("\n");
emit(type);
}
cchksum = (((cchksum&0300) >> 6)+cchksum)&077;
if (cchksum != rchksum) return(FALSE);
return(type);
}
getpkt() {
short i,eof;
static char leftover[6] = { '\0', '\0', '\0', '\0', '\0', '\0' };
if (first == 1) {
first = 0;
*leftover = '\0';
t = getc(fp);
if (t == EOF) {
first = 1;
return(size = 0);
}
}
else if (first == -1) {
first = 1;
return(size = 0);
}
for (size = 0; (msgpkt[size] = leftover[size]) != '\0'; size++) ;
*leftover = '\0';
rpt = 0;
eof = 0;
while (!eof) {
next = getc(fp);
if (next == EOF) {
first = -1;
eof = 1;
}
osize = size;
encode(t);
t = next;
if (size == spsiz-3) return(size);
if (size > spsiz-3) {
for (i = 0; (leftover[i] = msgpkt[osize+i]) != '\0'; i++) ;
size = osize;
msgpkt[size] = '\0';
return(size);
}
}
return(size);
}
encode(a)
char a;
{
short a7,b8;
if ((!imagemode) && a == '\n') {
rpt = 0;
msgpkt[size++] = quote;
msgpkt[size++] = ctl('\r');
if (size <= spsiz-3) osize = size;
msgpkt[size++] = quote;
msgpkt[size++] = ctl('\n');
return;
}
if (rptflg) {
if (a == next && (first == 0)) {
if (++rpt < 94) return;
else if (rpt == 94) {
msgpkt[size++] = rptq;
msgpkt[size++] = tochar(rpt);
rpt = 0;
}
}
else if (rpt == 1) {
rpt = 0;
encode(a);
if (size <= spsiz-3) osize = size;
rpt = 0;
encode(a);
return;
}
else if (rpt > 1) {
msgpkt[size++] = rptq;
msgpkt[size++] = tochar(++rpt);
rpt = 0;
}
}
a7 = a & 0177;
b8 = a & 0200;
if ((a7 < SP) || (a7==DEL)) {
msgpkt[size++] = quote;
a = ctl(a);
}
if (a7 == quote) msgpkt[size++] = quote;
if ((rptflg) && (a7 == rptq)) msgpkt[size++] = quote;
msgpkt[size++] = a;
msgpkt[size] = '\0';
}
decode()
{
USHORT a, a7, b8;
char *buf;
buf = msgpkt;
rpt = 0;
while ((a = *buf++) != '\0') {
if (rptflg) {
if (a == rptq) {
rpt = unchar(*buf++);
a = *buf++;
}
}
if (a == quote) {
a = *buf++;
a7 = a & 0177;
if ((a7 >= 0100 && a7 <= 0137) || a7 == '?') a = ctl(a);
}
if (rpt == 0) rpt = 1;
if ((!imagemode) && a == '\r') continue;
for (; rpt > 0; rpt--) putc(a, fp);
}
return(0);
}
spar(data)
char data[];
{
data[0] = tochar(MAXPACKSIZ);
data[1] = tochar(MYTIME);
data[2] = tochar(MYPAD);
data[3] = ctl(MYPCHAR);
data[4] = tochar(MYEOL);
data[5] = MYQUOTE;
data[6] = 'N';
data[7] = '1';
data[8] = MYRPTQ;
data[9] = '\0';
}
rpar(data)
char data[];
{
spsiz = unchar(data[0]);
timint = unchar(data[1]);
pad = unchar(data[2]);
padchar = ctl(data[3]);
eol = unchar(data[4]);
quote = data[5];
rptflg = 0;
if (data[6] == 0) return;
if (data[7] == 0) return;
if (data[8] == 0) return;
rptq = data[8];
rptflg = ((rptq > 040 && rptq < 0100) || (rptq > 0140 && rptq < 0177));
}
SHAR_EOF
cat << \SHAR_EOF > remote.c
/****************************************************
* vt100 emulator - remote character interpretation
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
****************************************************/
#define MODULE_REMOTE 1
#include "vt100.h"
static USHORT top = MINY;
static USHORT bot = MAXY;
static USHORT savx = MINX;
static USHORT savy = MINY;
static USHORT savmode = 0;
static USHORT nlmode = 0;
static USHORT alt = 0;
static USHORT savalt = 0;
static USHORT a[2] = { 0, 0 };
static USHORT sa[2] = { 0, 0 };
static short inesc = -1;
static short p1,p2,numpar;
static char escseq[40];
/************************************************
* function to handle remote characters
*************************************************/
doremote(c)
char c;
{
if (c == 27 || inesc >= 0) { doesc(c); return; }
if (c == 10 || c == 11 || c == 12) {
if (nlmode) doindex('E'); else doindex('D');
return;
}
if (c == 13) {
if (!nlmode) emit(c);
return;
}
if (c == 15) { alt = 0; return; }
if (c == 14) { alt = 1; return; }
if (a[alt] && c > 94 && c < 127) { doalt(c); return; }
emit(c);
}
doesc(c)
char c;
{
if (inesc < 0) { inesc = 0; return; }
if (c == 27 || c == 24) { inesc = -1; return; }
if (inesc == 0) {
if (c == '[' || c == '#' || c == '(' || c == ')') {
numpar = 0;
escseq[inesc++] = c;
return;
}
if (c == 'D' || c == 'E' || c == 'M') {
inesc = -1;
doindex(c);
return;
}
if (c == '7') {
inesc = -1;
savx = x; savy = y; savmode = curmode; savalt = alt;
sa[0] = a[0]; sa[1] = a[1];
return;
}
if (c == '8') {
inesc = -1;
x = savx; y = savy; alt = savalt; curmode = savmode;
a[0] = sa[0]; a[1] = sa[1];
return;
}
if (c == 'c') {
inesc = -1;
top = MINY; bot = MAXY; savx = MINX; savy = MINY;
a[0] = 0; a[1] = 0; sa[0] = 0; sa[1] = 0;
emit(12); return;
}
inesc = -1;
return;
}
if (inesc == 1 && escseq[0] == '#') { inesc = -1; return; }
if (inesc == 1 && escseq[0] == '(') {
inesc = -1;
if (c == '0' || c == '2') a[0] = 1; else a[0] = 0;
return;
}
if (inesc == 1 && escseq[0] == ')') {
inesc = -1;
if (c == '0' || c == '2') a[1] = 1; else a[1] = 0;
return;
}
if ((c >= '0' && c <= '9') || c == ';' || c == '?') {
if (inesc == 1) numpar = 1;
if (c == ';') numpar++;
escseq[inesc++] = c;
return;
}
escseq[inesc] = '\000';
inesc = -1; p1 = -1; p2 = -1;
if (escseq[1] == '?') return;
switch (numpar) {
case 1: sscanf(escseq,"[%d", &p1); break;
case 2: sscanf(escseq,"[%d;%d", &p1,&p2); break;
case 3: sscanf(escseq,"[%d;%d;%d", &p1,&p2,&p2); break;
case 4: sscanf(escseq,"[%d;%d;%d;%d",&p1,&p2,&p2,&p2); break;
}
if (c >= 'A' && c <= 'D') {
if (p1 <= 0) p1 = 1;
switch (c) {
case 'A': y -= 8*p1; if (y<top) y = top; break;
case 'B': y += 8*p1; if (y>bot) y = bot; break;
case 'C': x += 8*p1; if (x>MAXX) x = MAXX; break;
case 'D': x -= 8*p1; if (x<MINX) x = MINX; break;
}
return;
}
if (c == 'H' || c == 'f') {
if (p1 <= 0) p1 = 1;
if (p2 <= 0) p2 = 1;
y = (--p1*8)+MINY; x = (--p2*8)+MINX;
if (y > MAXY) y = MAXY;
if (x > MAXX) x = MAXX;
if (y < MINY) y = MINY;
if (x < MINX) x = MINX;
return;
}
if (c == 'r') {
if (p1 <= 0) p1 = 1;
if (p2 <= 0) p2 = 24;
top = (--p1*8)+MINY; bot = (--p2*8)+MINY;
if (top < MINY) top = MINY;
if (bot > MAXY) bot = MAXY;
if (top > bot) { top = MINY; bot = MAXY; }
return;
}
if (c == 'm') {
if (p2 >= 0) p1 = p2;
if (p1 <= 0) curmode = 0; else curmode = 1;
return;
}
if (c == 'K') {
doerase();
return;
}
if (c == 'J') {
if (p1 < 0) p1 = 0;
SetAPen(mywindow->RPort,0L);
if (p1 == 0) RectFill(mywindow->RPort,
(long)MINX,(long)(y+2),(long)(MAXX+7),(long)(bot+2));
else if (p1 == 1) RectFill(mywindow->RPort,
(long)MINX,(long)(top-7),(long)(MAXX+7),(long)(y-7));
else RectFill(mywindow->RPort,
(long)MINX,(long)(top-7),(long)(MAXX+7),(long)(bot+2));
SetAPen(mywindow->RPort,1L);
doerase(); return;
}
if (c == 'h') {
if (p1 == 20) nlmode = 1;
return;
}
if (c == 'l') {
if (p1 == 20) nlmode = 0;
return;
}
if (c == 'x') {
sendchar(27); sendstring("[3;1;8;64;64;1;0x"); return;
}
if (c == 'n') {
if (p1 == 6) {
sendchar(27);
sprintf(escseq,"[%d;%dR",((y-MINY)/8)+1,((x-MINX)/8)+1);
sendstring(escseq); return;
}
sendchar(27); sendstring("[0n"); return;
}
if (c == 'c') {
sendchar(27); sendstring("[?1;0c"); return;
}
}
doindex(c)
char c;
{
inesc = -1;
if (c != 'M') {
if (y > bot) { top = MINY; bot = MAXY; y = bot; }
if (y == bot) {
ScrollRaster(mywindow->RPort,0L,8L,MINX,(long)(top-6),
(long)(MAXX+7),(long)(bot+1));
y -= 8;
}
if (c == 'E') x = MINX;
y += 8;
}
else {
if (y < top) { top = MINY; bot = MAXY; y = top; }
if (y == top) {
ScrollRaster(mywindow->RPort,0L,-8L,(long)MINX,(long)(top-7),
(long)(MAXX+7),(long)(bot+1));
y += 8;
}
y -= 8;
}
return;
}
doalt(c)
char c;
{
short oldx,newx;
inesc = -1;
oldx = x; emit(' '); newx = x;
x = oldx;
SetAPen(mywindow->RPort,1L);
switch (c) {
case 'j':
case 'm':
case 'v': doline(4,-8,4,-4);
if (c=='j') doline(0,-4,4,-4);
else if (c=='m') doline(4,-4,8,-4);
else doline(0,-4,8,-4);
break;
case 'k':
case 'l':
case 'w': doline(4,-4,4,0);
if (c=='k') doline(0,-4,4,-4);
else if (c=='l') doline(4,-4,8,-4);
else doline(0,-4,8,-4);
break;
case 'n':
case 'q': doline(0,-4,8,-4);
if (c=='n') doline(4,-8,4,0);
break;
case 't':
case 'u':
case 'x': doline(4,-8,4,0);
if (c=='t') doline(4,-4,8,-4);
else if (c=='u') doline(0,-4,4,-4);
break;
}
x = newx;
}
doline(x1,y1,x2,y2) {
RectFill(mywindow->RPort,(long)(x+x1),(long)(y+y1),
(long)(x+x2),(long)(y+y2));
}
doerase()
{
inesc = -1;
if (p1 < 0) p1 = 0;
SetAPen(mywindow->RPort,0L);
if (p1 == 0) RectFill(mywindow->RPort,(long)x,(long)(y-6),
(long)(MAXX+7),(long)(y+1));
else if (p1 == 1) RectFill(mywindow->RPort,
(long)MINX,(long)(y-6),(long)(x+7),(long)(y+1));
else RectFill(mywindow->RPort,
(long)MINX,(long)(y-6),(long)(MAXX+7),(long)(y+1));
SetAPen(mywindow->RPort,1L);
return;
}
SHAR_EOF
cat << \SHAR_EOF > vt100.c
/************************************************************************
* vt100 terminal emulator with xmodem transfer capability
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
* use <esc> to abort xmodem or kermit transfers
*
* written by Michael Mounier
* new version by Dave Wecker
************************************************************************/
/* all includes defines and globals */
#define MODULE_MAIN 1
#include "vt100.h"
/******************************************************/
/* Main Program */
/* */
/* This is the main body of the program. */
/******************************************************/
main(argc,argv)
int argc;
char **argv;
{
ULONG class;
USHORT code,menunum,itemnum;
int KeepGoing,capture,send,maxwait,i;
char c,name[32];
FILE *tranr,*trans;
InitDefaults(argc,argv);
InitDevs();
InitFileItems();
InitRSItems();
InitXFItems();
InitCMItems();
InitMenu();
SetMenuStrip(mywindow,&menu[0]);
KeepGoing = TRUE;
capture=FALSE;
send=FALSE;
x = MINX ; y = MINY; curmode = 0;
SetAPen(mywindow->RPort,1L);
cursoron();
cursoroff();
emit(12);
BeginIO(Read_Request);
while( KeepGoing )
{
/* wait for window message or serial port message */
cursoron();
Wait((1L << Read_Request->IOSer.io_Message.mn_ReplyPort->mp_SigBit) |
(1L << mywindow->UserPort->mp_SigBit));
cursoroff();
if (send)
{
if ((c=getc(trans)) != EOF)
{
if (c == '\n') c = '\r';
sendchar(c);
}
else
{
fclose(trans);
emits("\nFile Sent\n");
send=FALSE;
}
}
maxwait = 0;
while (CheckIO(Read_Request) && maxwait++ < 20)
{
WaitIO(Read_Request);
c=rs_in[0] & 0x7f;
BeginIO(Read_Request);
doremote(c);
if (capture && c != 10) {
if (c == 13) c = 10;
putc(c , tranr);
}
}
while( NewMessage=(struct IntuiMessage *)GetMsg(mywindow->UserPort) )
{
class = NewMessage->Class;
code = NewMessage->Code;
ReplyMsg( NewMessage );
switch( class )
{
case CLOSEWINDOW:
KeepGoing = FALSE;
break;
case RAWKEY:
c = toasc(code);
break;
case NEWSIZE:
emit(12);
break;
case MENUPICK:
if ( code != MENUNULL )
{
menunum = MENUNUM( code );
itemnum = ITEMNUM( code );
switch( menunum )
{
case 0:
switch( itemnum )
{
case 0:
if (capture == TRUE)
{
capture=FALSE;
fclose(tranr);
emits("\nEnd File Capture\n");
}
else
{
emits("\nAscii Capture:");
filename(name);
if ((tranr=fopen(name,"w")) == 0)
{
capture=FALSE;
emits("\nError Opening File\n");
break;
}
capture=TRUE;
}
break;
case 1:
if (send == TRUE)
{
send=FALSE;
fclose(trans);
emits("\nFile Send Cancelled\n");
}
else
{
emits("\nAscii Send:");
filename(name);
if ((trans=fopen(name,"r")) == 0)
{
send=FALSE;
emits("\nError Opening File\n");
break;
}
send=TRUE;
}
break;
case 2:
emits("\nXmodem Receive:");
filename(name);
if (XMODEM_Read_File(name))
{
emits("\nRecieved File\n");
emit(8);
}
else
{
close(fd);
emits("Xmodem Receive Failed\n");
emit(8);
}
break;
case 3:
emits("\nXmodem Send:");
filename(name);
if (XMODEM_Send_File(name))
{
emits("\nSent File\n");
emit(8);
}
else
{
close(fd);
emits("\nXmodem Send Failed\n");
emit(8);
}
break;
case 4:
emits("\nKermit Receive local name:");
filename(name);
if (dokreceive(name))
{
emits("\nRecieved File\n");
emit(8);
}
else
{
close(fd);
emits("Kermit Receive Failed\n");
emit(8);
}
break;
case 5:
emits("\nKermit Send local name:");
filename(name);
if (doksend(name))
{
emits("\nSent File\n");
emit(8);
}
else
{
close(fd);
emits("\nKermit Send Failed\n");
emit(8);
}
break;
}
break;
case 1:
AbortIO(Read_Request);
switch( itemnum )
{
case 0:
Read_Request->io_Baud = 300;
break;
case 1:
Read_Request->io_Baud = 1200;
break;
case 2:
Read_Request->io_Baud = 2400;
break;
case 3:
Read_Request->io_Baud = 4800;
break;
case 4:
Read_Request->io_Baud = 9600;
break;
}
Read_Request->IOSer.io_Command = SDCMD_SETPARAMS;
DoIO(Read_Request);
Read_Request->IOSer.io_Command = CMD_READ;
BeginIO(Read_Request);
break;
case 2:
switch( itemnum )
{
case 0:
imagemode = 0;
break;
case 1:
imagemode = 1;
break;
}
break;
case 3:
switch (itemnum) {
case 0:
palette(mywindow);
break;
case 1:
for (i = 0; i< CTSIZ; i++)
mycolortable[i] = default_color[i];
LoadRGB4(myviewport,mycolortable,CTSIZ);
break;
}
} /* end of switch ( menunum ) */
} /* end of if ( not null ) */
} /* end of switch (class) */
} /* end of while ( newmessage )*/
} /* end while ( keepgoing ) */
/* It must be time to quit, so we have to clean
* up and exit.
*/
for (i = 0; i< CTSIZ; i++) mycolortable[i] = orig_color[i];
LoadRGB4(myviewport,mycolortable,CTSIZ);
CloseDevice(Read_Request);
DeletePort(Read_Request->IOSer.io_Message.mn_ReplyPort);
FreeMem(Read_Request,(long)sizeof(*Read_Request));
CloseDevice(Write_Request);
DeletePort(Write_Request->IOSer.io_Message.mn_ReplyPort);
FreeMem(Write_Request,(long)sizeof(*Write_Request));
ClearMenuStrip( mywindow );
FreeColorMap( mycolormap );
CloseWindow( mywindow );
if (cust != 0) CloseScreen( myscreen );
exit(FALSE);
} /* end of main */
SHAR_EOF
cat << \SHAR_EOF > window.c
/****************************************************
* vt100 emulator - window/keyboard support
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
****************************************************/
#define MODULE_WINDOW 1
#include "vt100.h"
/*************************************************
* function to get file name
*************************************************/
filename(name)
char name[];
{
char c;
ULONG class;
USHORT code;
int keepgoing,i;
keepgoing = TRUE;
i=0;
while (keepgoing) {
while( NewMessage=(struct IntuiMessage *)GetMsg(mywindow->UserPort) )
{
class = NewMessage->Class;
code = NewMessage->Code;
ReplyMsg( NewMessage );
if (class=RAWKEY)
{
c = toasc(code);
name[i]=c;
if (name[i] != 0)
{
if (name[i] == 13)
{
name[i]=0;
keepgoing = FALSE;
}
else
{
if (name[i] == 8)
{
i -=2;
if (i < -1)
i = -1;
else
{
emit(8);
emit(32);
emit(8);
}
}
else
emit(c);
}
i += 1;
}
}
} /* end of new message loop */
} /* end of god knows what */
emit(13);
emit(10);
} /* end of function */
/*************************************************
* function to print a string
*************************************************/
emits(string)
char string[];
{
int i;
char c;
i=0;
while (string[i] != 0)
{
c=string[i];
if (c == 10) emit(13);
emit(c);
i += 1;
}
}
/*************************************************
* function to output ascii chars to window
*************************************************/
emit(c)
char c;
{
Move(mywindow->RPort,(long)x,(long)y);
c &= 0x7F;
switch( c )
{
case '\t':
x += 64 - ((x-MINX) % 64);
break;
case 10: /* lf */
y += 8;
break;
case 13: /* cr */
x = MINX;
break;
case 8: /* backspace */
x -= 8;
if (x < MINX) x = MINX;
break;
case 12: /* page */
x = MINX;
y = MINY;
SetAPen(mywindow->RPort,0L);
RectFill(mywindow->RPort,(long)MINX,
(long)(MINY-7),(long)(MAXX+7),(long)(MAXY+1));
SetAPen(mywindow->RPort,1L);
break;
case 7: /* bell */
ClipBlit(mywindow->RPort,0L,0L,mywindow->RPort,0L,0L,
MAXX,MAXY,0x50L);
ClipBlit(mywindow->RPort,0L,0L,mywindow->RPort,0L,0L,
MAXX,MAXY,0x50L);
break;
default:
if (c < ' ' || c > '~') break;
if (curmode) {
Text(mywindow->RPort," ",1L);
Move(mywindow->RPort,(long)x,(long)y);
SetDrMd(mywindow->RPort,(long)INVERSVID);
Text(mywindow->RPort,&c,1L);
SetDrMd(mywindow->RPort,(long)JAM2);
}
else Text(mywindow->RPort,&c,1L);
x += 8;
} /* end of switch */
while (x > MAXX) x -= 8;
while (y > MAXY) {
y -= 8;
x = MINX;
ScrollRaster(mywindow->RPort,0L,8L,(long)MINX,
(long)(MINY-7),(long)(MAXX+7),(long)(MAXY+1));
}
}
/******************************
* Manipulate cursor
******************************/
cursoroff()
{
SetDrMd(mywindow->RPort,COMPLEMENT);
SetAPen(mywindow->RPort,3L);
RectFill(mywindow->RPort,
(long)(x-1),(long)(y-8),(long)(x+8),(long)(y+2));
SetAPen(mywindow->RPort,1L);
SetDrMd(mywindow->RPort,(long)JAM2);
}
cursoron()
{
SetDrMd(mywindow->RPort,COMPLEMENT);
SetAPen(mywindow->RPort,3L);
RectFill(mywindow->RPort,
(long)(x-1),(long)(y-8),(long)(x+8),(long)(y+2));
SetAPen(mywindow->RPort,1L);
SetDrMd(mywindow->RPort,(long)JAM2);
}
/************************************************
* function to take raw key data and convert it
* into ascii chars
**************************************************/
toasc(code)
USHORT code;
{
static int ctrl = FALSE;
static int shift = FALSE;
static int capsl = FALSE;
char c;
static char keys[75] = {
'`' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , '0' , '-' ,
'=' , '\\' , 0 , '0' , 'q' , 'w' , 'e' , 'r' , 't' , 'y' , 'u' , 'i' , 'o' ,
'p' , '[' , ']' , 0 , '1' , '2' , '3' , 'a' , 's' , 'd' , 'f' , 'g' , 'h' ,
'j' , 'k' , 'l' , ';' , '\'' , 0 , 0 , '4' , '5' , '6' , 0 , 'z' , 'x' , 'c' , 'v' ,
'b' , 'n' , 'm' , 44 , '.' , '/' , 0 , '.' , '7' , '8' , '9' , ' ' , 8 ,
'\t' , 13 , 13 , 27 , 127 , 0 , 0 , 0 , '-' } ;
switch ( code )
{
case 98: capsl = TRUE; c = 0;break;
case 226: capsl = FALSE;c = 0;break;
case 99: ctrl = TRUE; c = 0;break;
case 227: ctrl = FALSE; c = 0;break;
case 96:
case 97: shift = TRUE; c = 0;break;
case 224:
case 225: shift = FALSE;c = 0;break;
case 0x50: c=0; sendchar(27); sendstring("OP"); break;
case 0x51: c=0; sendchar(27); sendstring("OQ"); break;
case 0x52: c=0; sendchar(27); sendstring("OR"); break;
case 0x53: c=0; sendchar(27); sendstring("OS"); break;
case 0x0f: c=0; sendchar(27); sendstring("Op"); break;
case 0x1d: c=0; sendchar(27); sendstring("Oq"); break;
case 0x1e: c=0; sendchar(27); sendstring("Or"); break;
case 0x1f: c=0; sendchar(27); sendstring("Os"); break;
case 0x2d: c=0; sendchar(27); sendstring("Ot"); break;
case 0x2e: c=0; sendchar(27); sendstring("Ou"); break;
case 0x2f: c=0; sendchar(27); sendstring("Ov"); break;
case 0x3d: c=0; sendchar(27); sendstring("Ow"); break;
case 0x3e: c=0; sendchar(27); sendstring("Ox"); break;
case 0x3f: c=0; sendchar(27); sendstring("Oy"); break;
case 0x43: c=0; sendchar(27); sendstring("OM"); break;
case 0x4a: c=0; sendchar(27); sendstring("Ol"); break;
case 0x5f: c=0; sendchar(27); sendstring("Om"); break;
case 0x3c: c=0; sendchar(27); sendstring("On"); break;
case 0x4c: c = 0; sendchar(27); sendstring("[A"); break;
case 0x4d: c = 0; sendchar(27); sendstring("[B"); break;
case 0x4e: c = 0; sendchar(27); sendstring("[C"); break;
case 0x4f: c = 0; sendchar(27); sendstring("[D"); break;
default:
if (code < 75) c = keys[code];
else c = 0;
}
/* add modifiers to the keys */
if (c != 0) {
if (shift) {
if ((c <= 'z') && (c >= 'a')) c -= 32;
else
switch( c ) {
case '[': c = '{'; break;
case ']': c = '}'; break;
case '\\': c = '|'; break;
case '\'': c = '"'; break;
case ';': c = ':'; break;
case '/': c = '?'; break;
case '.': c = '>'; break;
case ',': c = '<'; break;
case '`': c = '~'; break;
case '=': c = '+'; break;
case '-': c = '_'; break;
case '1': c = '!'; break;
case '2': c = '@'; break;
case '3': c = '#'; break;
case '4': c = '$'; break;
case '5': c = '%'; break;
case '6': c = '^'; break;
case '7': c = '&'; break;
case '8': c = '*'; break;
case '9': c = '('; break;
case '0': c = ')'; break;
default: break;
}
}
else if (capsl && (c <= 'z') && (c >= 'a')) c -= 32;
}
if (ctrl) {
if (c >= '`' && c <= 127) c -= 96;
else if (c >= '@' && c <= '_') c -= 64;
}
if (c != 0) sendchar(c);
return(c);
}
SHAR_EOF
cat << \SHAR_EOF > xmodem.c
/*************************************************************
* vt100 terminal emulator - XMODEM protocol support
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
*************************************************************/
#define MODULE_XMODEM 1
#include "vt100.h"
/************************************************************
* Send a string (using sendchar below)
************************************************************/
sendstring(s)
char *s;
{
char c;
while ((c = *s++) != '\000') sendchar(c);
}
/**************************************************************/
/* send char and read char functions for the xmodem function */
/************************************************************/
sendchar(ch)
int ch;
{
rs_out[0] = ch;
DoIO(Write_Request);
}
readchar()
{
unsigned char c;
int rd,ch;
rd = FALSE;
while (rd == FALSE)
{
Wait((1L << Read_Request->IOSer.io_Message.mn_ReplyPort->mp_SigBit) | ( 1L << mywindow->UserPort->mp_SigBit));
if(CheckIO(Read_Request))
{
WaitIO(Read_Request);
ch=rs_in[0];
rd = TRUE;
BeginIO(Read_Request);
}
if (NewMessage=(struct IntuiMessage *)GetMsg(mywindow->UserPort))
if ((NewMessage->Class) == RAWKEY)
if ((NewMessage->Code) == 69)
{
emits("\nUser Cancelled Transfer");
break;
}
}
if (rd == FALSE)
{
timeout = TRUE;
emits("\nTimeout Waiting For Character\n");
}
c = ch;
return(c);
}
/**************************************/
/* xmodem send and recieve functions */
/************************************/
XMODEM_Read_File(file)
char *file;
{
int firstchar, sectnum, sectcurr, sectcomp, errors, errorflag;
unsigned int checksum, j, bufptr,i;
char numb[10];
bytes_xferred = 0L;
if ((fd = creat(file, 0)) < 0)
{
emits("Cannot Open File\n");
return FALSE;
}
else
emits("Receiving File\n\nType <ESC> to abort transfer\n");
timeout=FALSE;
sectnum = errors = bufptr = 0;
sendchar(NAK);
firstchar = 0;
while (firstchar != EOT && errors != ERRORMAX)
{
errorflag = FALSE;
do /* get sync char */
{
firstchar = readchar();
if (timeout == TRUE)
return FALSE;
}
while (firstchar != SOH && firstchar != EOT);
if (firstchar == SOH)
{
emits("Getting Block ");
sprintf(numb, "%d", sectnum);
emits(numb);
emits("...");
sectcurr = readchar();
if (timeout == TRUE)
return FALSE;
sectcomp = readchar();
if (timeout == TRUE)
return FALSE;
if ((sectcurr + sectcomp) == 255)
{
if (sectcurr == (sectnum + 1 & 0xff))
{
checksum = 0;
for (j = bufptr; j < (bufptr + SECSIZ); j++)
{
bufr[j] = readchar();
if (timeout == TRUE)
return FALSE;
checksum = (checksum + bufr[j]) & 0xff;
}
if (checksum == readchar())
{
errors = 0;
sectnum++;
bufptr += SECSIZ;
bytes_xferred += SECSIZ;
emits("verified\n");
if (bufptr == BufSize)
{
if (write(fd, bufr, BufSize-128) == EOF)
{
emits("\nError Writing File\n");
return FALSE;
}
bufptr = 128;
for (j = 0; j < 128; j++)
bufr[j] = bufr[(BufSize-128)+j];
}
sendchar(ACK);
}
else
{
errorflag = TRUE;
if (timeout == TRUE)
return FALSE;
}
}
else
{
if (sectcurr == (sectnum & 0xff))
{
emits("\nReceived Duplicate Sector\n");
sendchar(ACK);
}
else
errorflag = TRUE;
}
}
else
errorflag = TRUE;
}
if (errorflag == TRUE)
{
errors++;
emits("\nError\n");
sendchar(NAK);
}
} /* end while */
if ((firstchar == EOT) && (errors < ERRORMAX))
{
sendchar(ACK);
while (bufptr > 0 && (bufr[--bufptr] == 0x00 ||
bufr[bufptr] == 0x1A)) ;
write(fd, bufr, ++bufptr);
close(fd);
return TRUE;
}
return FALSE;
}
XMODEM_Send_File(file)
char *file;
{
int sectnum, bytes_to_send, size, attempts, c, i;
unsigned checksum, j, bufptr;
char numb[10];
timeout=FALSE;
bytes_xferred = 0;
if ((fd = open(file, 0)) < 0) {
emits("Cannot Open Send File\n");
return FALSE;
}
else
emits("Sending File\n\nType <ESC> to abort transfer\n");
attempts = 0;
sectnum = 1;
/* wait for sync char */
j=1;
while (((c = readchar()) != NAK) && (j++ < ERRORMAX));
if (j >= (ERRORMAX))
{
emits("\nReceiver not sending NAKs\n");
return FALSE;
}
while ((bytes_to_send = read(fd, bufr, BufSize)) && attempts != RETRYMAX)
{
if (bytes_to_send == EOF)
{
emits("\nError Reading File\n");
return FALSE;
}
bufptr = 0;
while (bytes_to_send > 0 && attempts != RETRYMAX)
{
attempts = 0;
do
{
sendchar(SOH);
sendchar(sectnum);
sendchar(~sectnum);
checksum = 0;
size = SECSIZ <= bytes_to_send ? SECSIZ : bytes_to_send;
bytes_to_send -= size;
for (j = bufptr; j < (bufptr + SECSIZ); j++)
if (j < (bufptr + size))
{
sendchar(bufr[j]);
checksum += bufr[j];
}
else
{
sendchar(0);
}
sendchar(checksum & 0xff);
attempts++;
c = readchar();
if (timeout == TRUE)
return FALSE;
}
while ((c != ACK) && (attempts != RETRYMAX));
bufptr += size;
bytes_xferred += size;
emits("Block ");
sprintf(numb, "%d", sectnum);
emits(numb);
emits(" sent\n");
sectnum++;
}
}
close(fd);
if (attempts == RETRYMAX)
{
emits("\nNo Acknowledgment Of Sector, Aborting\n");
return FALSE;
}
else
{
attempts = 0;
do
{
sendchar(EOT);
attempts++;
}
while ((readchar() != ACK) && (attempts != RETRYMAX) && (timeout == FALSE));
if (attempts == RETRYMAX)
emits("\nNo Acknowledgment Of End Of File\n");
}
return TRUE;
}
SHAR_EOF
cat << \SHAR_EOF > vt100.h
/*********************************************************************
* a terminal program that has ascii and xmodem transfer capability
*
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
* use esc to abort xmodem transfer
*
* written by Michael Mounier
* new version by Dave Wecker 860621
************************************************************************/
/* compiler directives to fetch the necessary header files */
#include <exec/types.h>
#include <exec/exec.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <graphics/gfxbase.h>
#include <graphics/gfx.h>
#include <graphics/text.h>
#include <graphics/regions.h>
#include <graphics/copper.h>
#include <graphics/gels.h>
#include <devices/serial.h>
#include <devices/keymap.h>
#include <hardware/blit.h>
#include <stdio.h>
#include <ctype.h>
#include <libraries/dos.h>
#include <functions.h>
#undef NULL
#define NULL ((void *)0)
#define INTUITION_REV 1L
#define GRAPHICS_REV 1L
/* things for xmodem send and recieve */
#define SECSIZ 0x80
#define TTIME 10 /* number of seconds for timeout */
#define BufSize 0x1000 /* Text buffer */
#define ERRORMAX 10 /* Max errors before abort */
#define RETRYMAX 10 /* Maximum retrys before abort */
#define SOH 1 /* Start of sector char */
#define EOT 4 /* end of transmission char */
#define ACK 6 /* acknowledge sector transmission */
#define NAK 21 /* error in transmission detected */
#define FILEMAX 6 /* number of file menu items */
#define RSMAX 5 /* speed menu items */
#define XFMAX 2 /* transfer mode items */
#define CMMAX 2 /* number of color menu items */
#define MAXMENU 4 /* total number of menu entries */
#define DPTH 1L
#define SCRNT 197L
#define SCRNH 205L
#define WDTH 640L
#define WINDT 3L
#define HGHT 200L
#define BCOL 0L
#define CTSIZ 2L
#define MINX 0L
#define MAXX 632L
#define MINY 14L
#define MAXY 198L
extern struct MsgPort *CreatePort();
#ifdef MODULE_MAIN
char bufr[BufSize];
int fd, timeout = FALSE;
long bytes_xferred;
int imagemode = TRUE;
struct IntuitionBase *IntuitionBase;
struct GfxBase *GfxBase;
struct NewScreen NewScreen = {
0,SCRNT,WDTH,SCRNH,DPTH, /* left, top, width, height, depth */
0,1,(HIRES|LACE), /* DetailPen, BlockPen, ViewModes */
CUSTOMSCREEN,NULL, /* Type, Font */
(UBYTE *)"VT100 Terminal Screen", /* Title */
NULL,NULL }; /* Gadgets, Bitmap */
struct NewWindow NewWindow = {
0,WINDT,WDTH,HGHT, /* left, top, width, height */
0,1, /* detailpen, blockpen */
MENUPICK | CLOSEWINDOW | RAWKEY | NEWSIZE,
SMART_REFRESH | REPORTMOUSE | ACTIVATE | BORDERLESS |
WINDOWCLOSE | WINDOWDEPTH | WINDOWDRAG, /* Flags */
NULL,NULL, /* FirstGadget, CheckMark */
(UBYTE *)
"VT100 Terminal Window ",
NULL, /* set screen after open screen */
NULL, /* bitmap */
WDTH, HGHT, WDTH, HGHT,/* minw, minh, maxw, maxh */
CUSTOMSCREEN /* Type */
};
struct Screen *myscreen; /* ptr to applications screen */
struct Window *mywindow; /* ptr to applications window */
struct ViewPort *myviewport;
struct ColorMap *mycolormap;
USHORT *mycolortable;
struct IntuiMessage *NewMessage; /* msg structure for GetMsg() */
struct Preferences *Prefs; /* preferences from GetPrefs() */
struct MenuItem FileItem[FILEMAX];
struct IntuiText FileText[FILEMAX];
struct MenuItem RSItem[RSMAX];
struct IntuiText RSText[RSMAX];
struct MenuItem XFItem[XFMAX];
struct IntuiText XFText[XFMAX];
struct MenuItem CMItem[CMMAX];
struct IntuiText CMText[CMMAX];
struct Menu menu[MAXMENU];
struct IOExtSer *Read_Request;
char rs_in[2];
struct IOExtSer *Write_Request;
char rs_out[2];
short x,y,curmode;
/*************************** defaults ***********************************/
USHORT orig_color[CTSIZ] = {0x004,0x666};
USHORT default_color[CTSIZ] = {0x200,0xA00};
short speed = 2400;
short cust = 2;
#else /* not MODULE_MAIN */
extern char bufr[BufSize];
extern int fd, timeout;
extern long bytes_xferred;
extern int imagemode;
extern struct IntuitionBase *IntuitionBase;
extern struct GfxBase *GfxBase;
extern struct NewScreen NewScreen;
extern struct NewWindow NewWindow;
extern struct Screen *myscreen;
extern struct Window *mywindow;
extern struct ViewPort *myviewport;
extern struct ColorMap *mycolormap;
extern USHORT *mycolortable;
extern struct IntuiMessage *NewMessage;
extern struct Preferences *Prefs;
extern struct MenuItem FileItem[FILEMAX];
extern struct IntuiText FileText[FILEMAX];
extern struct MenuItem RSItem[RSMAX];
extern struct IntuiText RSText[RSMAX];
extern struct MenuItem XFItem[XFMAX];
extern struct IntuiText XFText[XFMAX];
extern struct MenuItem CMItem[CMMAX];
extern struct IntuiText CMText[CMMAX];
extern struct Menu menu[MAXMENU];
extern struct IOExtSer *Read_Request;
extern char rs_in[2];
extern struct IOExtSer *Write_Request;
extern char rs_out[2];
extern short x,y,curmode;
extern USHORT orig_color[CTSIZ];
extern USHORT default_color[CTSIZ];
extern short speed;
extern short cust;
#endif /* not MODULE_MAIN */
#ifndef MODULE_INIT
extern InitDefaults(),InitDevs(),InitFileItems(),InitRSItems(),
InitXFItems(),InitCMItems(),InitMenu();
#endif
#ifndef MODULE_WINDOW
extern filename(),emits(),emit(),cursoroff(),cursoron(),toasc();
#endif
#ifndef MODULE_XMODEM
extern sendchar(), sendstring(), readchar(),
XMODEM_Read_File(), XMODEM_Send_File();
#endif
#ifndef MODULE_REMOTE
extern doremote();
#endif
#ifndef MODULE_KERMIT
extern doksend(),dokreceive();
#endif
#ifndef MODULE_COLORS
extern palette();
#endif
SHAR_EOF
# End of shell archive
exit 0
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads