home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Fred Fish Collection 1.5
/
ffcollection-1-5-1992-11.iso
/
ff_disks
/
300-399
/
ff330.lzh
/
Vt100
/
Src.lzh
/
Src
/
init.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-03-01
|
26KB
|
877 lines
static char rcsid[] = "$RCSfile: init.c,v $ $Revision: 1.4 $";
/***************************************************************
* vt100 - terminal emulator - initialization
* :ts=8
*
* $Log: init.c,v $
* Revision 1.4 89/12/12 22:13:56 acs
* 1) Strip excess blanks from the rest of the menu items.
* 2) No checkmark on "---" parity item (ParItem[5]).
*
* Revision 1.3 89/12/11 20:48:16 acs
* 1) Remove extraneous spaces at end of menu items.
* 2) Increase width of checked menu items by CHECKWIDTH instead of by
* the width of 2 characters.
* 3) Don't highlight the "---" separating the new Strip item from the
* other items in the Parity menu.
* 4) A little better initialization of the Utility items.
*
* Revision 1.2 89/11/06 21:25:22 acs
* 1) Add new Parity menu item: Strip to remove parity from data destined
* for the display.
* 2) Add RCS id and change log.
*
* v2.9 ACS - Support new cmds EXT. Use S and R for Send and Receive menu
* items instead of ^ and V. AREXX support.
* v2.8a 880331 ACS - Allow lines 0 in init file to *really* mean
* "use all available lines".
* v2.7 870825 ACS - Allow execution of all script files specified on
* command line (companion to changes in script.c).
* Rolled menu init into one routine (do_menu_init()).
* v2.6 870227 DBW - bug fixes for all the stuff in v2.5
* v2.5 870214 DBW - more additions (see readme file)
* v2.4 861214 DBW - lots of fixes/additions (see readme file)
* v2.3 861101 DBW - minor bug fixes
* v2.2 861012 DBW - more of the same
* v2.1 860915 DBW - new features (see README)
* 860901 ACS - Added Parity and Word Length and support code
* 860823 DBW - Integrated and rewrote lots of code
* v2.0 860809 DBW - Major rewrite
* v1.1 860720 DBW - Switches, 80 cols, colors, bug fixes
* v1.0 860712 DBW - First version released
*
***************************************************************/
#include "vt100.h"
struct Device *ConsoleDevice = NULL;
struct IOStdReq ConReq;
extern APTR OrigWindowPtr;
extern int capture; /* in vt100.c */
/* Used by script.c for script file chaining. */
int script_files_todo = 0;
char **script_files = NULL;
char line[256];
/* Command key equivalences per menu. Manipulated by script.c */
/* Equivalences for the File menu... */
struct filecmd {
char mo; /* Mode */
char se; /* Send */
char re; /* Receive */
char kg; /* Kermit Get */
char kb; /* Kermit Bye */
char ca; /* Capture or Capturing */
char nl;
} filecmd_chars = { ' ', 'S', 'R', 'G', 'B', ' ', '\0' };
/* Equivalences for Mode sub-menu... */
struct mode_cmd {
char as; /* ascii mode */
char xm; /* xmodem mode */
char xmc; /* xmodemcrc mode */
char ke; /* kermit mode */
char nl;
} modecmd_chars = { ' ', 'X', ' ', 'K', '\0' };
/* Equivalences for the Comm menu... */
struct commcmd {
char nl0; /* Baud Sub-Item */
char nl1; /* Parity Sub-Item */
char nl2; /* Xfer mode Sub-Item */
char sh; /* Shared item */
char nl;
} commcmd_chars = { ' ', ' ', ' ', ' ', '\0' };
/* Equivalences for the Baud Rate sub-menu... */
struct baudcmd {
char b03; /* 0300 */
char b12; /* 1200 */
char b24; /* 2400 */
char b48; /* 4800 */
char b96; /* 9600 */
char bnl;
} baudcmd_chars = { ' ', 'L', 'H', ' ', ' ', '\0' };
/* Equivalences for the Parity sub-menu... */
struct parcmd {
char no; /* NOne */
char ma; /* MArk */
char sp; /* SPace */
char ev; /* EVen */
char od; /* ODd */
char n0; /* --- */
char st; /* STrip */
char n1;
} parcmd_chars = { 'N', ' ', ' ', 'E', 'O', ' ', ' ', '\0' };
/* Equivalences for the Xfer Mode sub-menu... */
struct modcmd {
char im; /* IMage */
char tx; /* TeXt */
char cn; /* CoNvert */
char ac; /* AutoChop */
char nl;
} modcmd_chars = { 'I', 'T', ' ', ' ', '\0' };
/* Equivalences for the Script menu... */
struct scrcmd {
char em; /* Execute Macro */
char ab; /* Abort Macro */
char rc; /* AREXX Macro */
char nl;
} scrcmd_chars = { 'M', 'A', ' ', '\0' };
/* Equivalences for the Utility menu... */
struct utilcmd {
char sb; /* Send Break */
char hu; /* Hang Up */
char cd; /* Change Dir */
char cs; /* Clear Screen */
char ec; /* ECho */
char wr; /* WRap */
char nk; /* Num Key */
char ac; /* App Cur */
char bs; /* BS<->DEL */
char xb; /* Xfer beep */
char mu; /* Mouse up events */
char md; /* Mouse down events */
char nl;
} utilcmd_chars = { '.', ' ', 'D', ' ', ' ', 'W', 'K', 'C', ' ', ' ', ' ', ' ', '\0' };
static char *filetext[] = {
"Protocol",
"Send",
"Receive",
"Kermit Get",
"Kermit BYE",
"Capture"
};
static char *modetext[] = {
"Ascii",
"Xmodem",
"XmodemCRC",
"Kermit"
};
static char *commtext[] = {
"Baud Rate",
"Parity",
"Xfer Mode",
"Shared",
};
static char *baudtext[] = {
" 300",
"1200",
"2400",
"4800",
"9600"
};
static char *partext[] = {
"None",
"Mark",
"Space",
"Even",
"Odd",
"-------",
"Strip"
};
static char *modtext[] = {
"Image",
"Text",
"Convert",
"AutoChop"
};
static char *scrtext[] = {
"Execute Macro",
"Abort Execution",
"AREXX Macro"
};
static char *utiltext[] = {
"Send Break",
"Hang Up",
"Change Dir",
"Clear Scrn",
"Echo",
"Wrap",
"Num Key",
"App Cur",
"BS<->DEL",
"Xfer Beep ",
"Mouse Up",
"Mouse Dn",
};
struct HowToInit {
int LeftEdge; /* in characters, NOT pixels */
int Width; /* ditto */
ULONG Flags;
char **text;
char *cmdkeys;
};
static struct HowToInit menu_init[] = {
{ 0, 20, ITEMTEXT | ITEMENABLED | HIGHCOMP,
filetext, (char *)(&filecmd_chars) },
{10, 17, ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT | MENUTOGGLE,
modetext, (char *)(&modecmd_chars) },
{ 0, 11, ITEMTEXT | ITEMENABLED | HIGHCOMP,
commtext, (char *)(&commcmd_chars) },
{ 10, 12, ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT | MENUTOGGLE,
baudtext, (char *)(&baudcmd_chars) },
{ 10, 12, ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT | MENUTOGGLE,
partext, (char *)(&parcmd_chars) },
{ 10, 15, ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT | MENUTOGGLE,
modtext, (char *)(&modcmd_chars) },
{ 0, 20, ITEMTEXT | ITEMENABLED | HIGHCOMP,
scrtext, (char *)(&scrcmd_chars) },
{ 0, 16, ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT | MENUTOGGLE,
utiltext, (char *)(&utilcmd_chars) }
};
#define FILE_INIT_ENTRY (&(menu_init[0]))
#define MODE_INIT_ENTRY (&(menu_init[1]))
#define COMM_INIT_ENTRY (&(menu_init[2]))
#define RS_INIT_ENTRY (&(menu_init[3]))
#define PAR_INIT_ENTRY (&(menu_init[4]))
#define XF_INIT_ENTRY (&(menu_init[5]))
#define SCRIPT_INIT_ENTRY (&(menu_init[6]))
#define UTIL_INIT_ENTRY (&(menu_init[7]))
void do_menu_init();
#if AREXX
char *rexxerrmsgs[] = {
"",
"No AREXX library - AREXX unavailable.",
"Can't contact AREXX server - AREXX unavailable.",
"Can't create an AREXX msg - AREXX unavailable.",
"Can't get memory for hostname.",
"VT100 AREXX port already present - another VT100 up?",
"Can't get memory for AREXX port."
};
#endif /* AREXX */
char *InitDefaults(argc,argv)
int argc;
char **argv;
{
FILE *fd = NULL;
char *p = NULL, *ifile, temp[80];
int i, l, dont_init = 0, customfudge, maxrows, maxlines;
for(l = 0; l < EXTMAX; l++)
ExtXfer[l] = NULL;
doing_init = 1; /* make sure we only allow INIT script commands */
if (argc > 1) {
int start_of_script_files = 1;
if(strcmp(argv[1], "-i") == 0) { /* No init file */
dont_init = 1;
start_of_script_files = 2;
}
else if(strcmp(argv[1], "+i") == 0) { /* Use specified init file */
start_of_script_files = 3;
if((fd=fopen(argv[2],"r")) == NULL) {
ifile = AllocMem((LONG)(strlen(argv[2])+3), MEMF_PUBLIC|MEMF_CLEAR);
strcpy(ifile, "S:");
strcat(ifile, argv[2]);
fd = fopen(ifile, "r");
FreeMem(ifile, (LONG)(strlen(argv[2])+3));
ifile = NULL;
}
}
if(start_of_script_files > argc)
script_files_todo = 0;
else
script_files_todo = argc - start_of_script_files; /* # of cmdline script files left */
script_files = &(argv[start_of_script_files]); /* Ptr to first of 'em */
}
if((p_font == NULL) || (p_font[0] == '\0'))
strcpy(myfontname, "topaz");
else
strcpy(myfontname, p_font); /* Init font name */
strcat(myfontname, ".font");
if((p_device == NULL) || (p_device[0] == '\0'))
strcpy(mysername, SERIALNAME);
else
strcpy(mysername, p_device);
#if AREXX
/* Setup the AREXX interface now so user can use it during init. */
if( (RexxSysBase = (struct RxsLib *)OpenLibrary(RXSNAME, 0L))
== NULL)
puts("Can't open rexxsyslib.library - AREXX unavailable.");
else if( (i = makerexxport()) != 0)
cleanup(rexxerrmsgs[i], 256);
#endif /* AREXX */
if(!dont_init)
if((fd == NULL) && ((fd=fopen("vt100.init","r")) == NULL))
fd=fopen("s:vt100.init","r");
if(fd != NULL) {
while (fgets(line,256,fd) != 0) {
if(line[strlen(line)-1] == '\n')
line[strlen(line)-1] = '\000';
p = next_wrd(&line[0],&l);
if (*p) {
*p |= ' ';
if (p[1]) p[1] |= ' ';
if (*p == '#') continue;
if (strncmp(p, "exi", 3) == 0) break;
exe_cmd(p,l);
}
}
fclose(fd);
}
doing_init = 0;
IntuitionBase = (struct IntuitionBase *)
OpenLibrary("intuition.library", INTUITION_REV);
if( IntuitionBase == NULL )
cleanup("can't open intuition",1);
GfxBase = (struct GfxBase *)
OpenLibrary("graphics.library",GRAPHICS_REV);
if( GfxBase == NULL )
cleanup("can't open graphics library",2);
DiskfontBase = (struct Library *)OpenLibrary("diskfont.library", 0L);
if(DiskfontBase == NULL)
cleanup("can't open diskfont library", 2);
if ( (myfont = (struct TextFont *)OpenFont(&myattr)) == NULL
&& (myfont = (struct TextFont *)OpenDiskFont(&myattr)) == NULL) {
sprintf(temp, "Can't open font %s", myfontname);
cleanup(temp, 4);
}
Xsize = myfont->tf_XSize;
Ysize = myfont->tf_YSize;
BaseLine = myfont->tf_Baseline;
/* Now set up all the screen info as necessary */
maxrows = GfxBase->NormalDisplayRows;
/* If user wants to use the current interlace setting then set p_interlace
** according to what the ViewLord says it is. */
if(p_interlace == 2)
p_interlace = ((IntuitionBase->ViewLord.Modes & LACE) == LACE) ? 1 : 0;
else if((p_screen == 0) && ((IntuitionBase->ViewLord.Modes & LACE) == 0))
p_interlace = 0;
if(p_interlace)
maxrows *= 2;
customfudge = (p_screen == 1) ? 4 : 0;
/* See if user wants to use everything available (specified LINES 0).If
** so then set p_lines so we'll leave room for the window title.
** (Ysize + 1) is the size of the window title bar.
** (Ysize + 1 + customfudge) is used to allow us to account for the the 4
** scan-lines we'll allow in CUSTOM screen mode so that the user can pull
** the window down to expose the screen's depth arrangement gadgets. Note
** that it's OK to overwrite the last 2 lines or so of the window-title bar
** (that's why we take the remainder first).
**/
if( ((maxrows - (Ysize + 1 - customfudge)) % Ysize) > (Ysize - 2) )
maxlines = (maxrows - Ysize + customfudge) / Ysize;
else
maxlines = (maxrows - (Ysize + 1 + customfudge)) / Ysize;
if(p_lines == 0)
p_lines = maxlines;
else if (p_lines > maxlines)
p_lines = maxlines;
/* Set MINY. MINY will be adjusted so we'll overwrite part of the
** window title bar if necessary to get the last line to end at the bottom
** of the window.
** Remember that MINY is the location of the BASELINE of the character. */
{
int end = (Ysize + 2) + (p_lines * Ysize);
MINY = Ysize + 2;
if(end > maxrows)
MINY -= (end - maxrows);
MINY += BaseLine;
}
if(p_screen == 1 && p_interlace == 1)
NewScreen.ViewModes |= LACE;
MAXY = MINY + ((p_lines - 1) * Ysize);
top = MINY; bot = MAXY;
savx = MINX; savy = MINY;
NewWindow.Height = MAXY + customfudge + (Ysize - BaseLine);
NewWindow.MinHeight = NewWindow.Height;
NewWindow.MaxHeight = NewWindow.Height;
NewReqWindow.MaxHeight = NewWindow.Height;
NewWindow.TopEdge = 0L;
if (p_screen == 1) {
if (p_depth > 2)
p_depth = 2;
else if (p_depth < 1)
p_depth = 1;
NewScreen.Depth = (long)p_depth;
NewScreen.Height = NewWindow.Height + customfudge;
NewScreen.TopEdge = 0;
} else {
p_depth = 2L;
NewWindow.Screen = NULL;
NewReqWindow.Screen = NULL;
NewWindow.Type = WBENCHSCREEN;
NewReqWindow.Type = WBENCHSCREEN;
}
/* see if we exit with a startup script */
if (strncmp(p, "exi", 3) == 0) {
p = next_wrd(p+l+1,&l);
if (*p) return(p);
}
if (script_files_todo > 0) {
script_files_todo--;
return(*(script_files++));
}
return(NULL);
}
void InitDevs()
{
USHORT colors[4];
int i;
BYTE *b,*c;
struct Process *mproc;
if (p_screen == 1) {
if ((myscreen = (struct Screen *)OpenScreen(&NewScreen)) == NULL)
cleanup("can't open screen",3);
NewWindow.Screen = myscreen;
NewReqWindow.Screen = myscreen;
}
if ((mywindow = (struct Window *)OpenWindow(&NewWindow)) == NULL)
cleanup("can't open window",4);
if(OpenDevice("console.device", -1L, &ConReq, 0L))
cleanup("can't open console", 4);
ConsoleDevice = ConReq.io_Device;
if(p_screen == 1) { /* Cause system reqs to come to this screen */
mproc = (struct Process *)FindTask(0L);
OrigWindowPtr = mproc->pr_WindowPtr;
mproc->pr_WindowPtr = (APTR)mywindow;
}
myviewport = (struct ViewPort *)ViewPortAddress(mywindow);
myrastport = (struct RastPort *)mywindow->RPort;
SetFont(myrastport,myfont);
if (p_depth > 1) myrequest.BackFill = 2;
if (p_screen != 0 && p_wbcolors == 0) {
colors[0] = p_background;
colors[1] = p_foreground;
colors[2] = p_bold;
colors[3] = p_cursor;
if (p_depth == 1)
LoadRGB4(myviewport, colors, 2L);
else
LoadRGB4(myviewport, colors, 4L);
}
Read_Request = (struct IOExtSer *)
AllocMem((long)sizeof(*Read_Request),MEMF_PUBLIC|MEMF_CLEAR);
Read_Request->io_SerFlags = (p_shared ? SERF_SHARED : 0);
Read_Request->IOSer.io_Message.mn_ReplyPort = CreatePort(0L,0L);
if(OpenDevice(mysername, (LONG)p_unit, (struct IORequest *)Read_Request, NULL))
cleanup("Can't open Read device",5);
rs_in = malloc(p_buffer+1);
Read_Request->io_SerFlags = 0L;
Read_Request->io_Baud = p_baud;
Read_Request->io_ReadLen = 8L;
Read_Request->io_WriteLen = 8L;
Read_Request->io_CtlChar = 0x11130000L;
Read_Request->io_RBufLen = p_buffer;
Read_Request->io_BrkTime = p_break;
Read_Request->IOSer.io_Command = SDCMD_SETPARAMS;
DoIO((struct IORequest *)Read_Request);
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);
b = (BYTE *)Read_Request;
c = (BYTE *)Write_Request;
for (i=0;i<sizeof(struct IOExtSer);i++)
*c++ = *b++;
Write_Request->IOSer.io_Message.mn_ReplyPort = CreatePort(0L,0L);
Write_Request->IOSer.io_Command = CMD_WRITE;
Write_Request->IOSer.io_Length = 1;
Write_Request->IOSer.io_Data = (APTR) &rs_out[0];
Timer_Port = CreatePort("Timer Port",0L);
Script_Timer_Port = CreatePort("Timer Port",0L);
if (OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *)&Timer, NULL) ||
OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *)&Script_Timer, NULL))
cleanup("can't open timer device",7);
Timer.tr_node.io_Message.mn_ReplyPort = Timer_Port;
Timer.tr_node.io_Command = TR_ADDREQUEST;
Timer.tr_node.io_Flags = 0;
Timer.tr_node.io_Error = 0;
Script_Timer.tr_node.io_Message.mn_ReplyPort = Script_Timer_Port;
Script_Timer.tr_node.io_Command = TR_ADDREQUEST;
Script_Timer.tr_node.io_Flags = 0;
Script_Timer.tr_node.io_Error = 0;
BeepWave = (UBYTE *)AllocMem(BEEPSIZE,(long)(MEMF_CHIP|MEMF_CLEAR));
if (BeepWave != 0)
BeepWave[0] = 100;
Audio_Port = CreatePort("Audio Port",0L);
Audio_Request.ioa_Request.io_Message.mn_ReplyPort = Audio_Port;
Audio_Request.ioa_Request.io_Message.mn_Node.ln_Pri = 85;
Audio_Request.ioa_Data = Audio_AllocMap;
Audio_Request.ioa_Length = (ULONG) sizeof(Audio_AllocMap);
if (OpenDevice(AUDIONAME, NULL, (struct IORequest *)&Audio_Request, NULL))
cleanup("can't open audio device",8);
Audio_Request.ioa_Request.io_Command = CMD_WRITE;
Audio_Request.ioa_Request.io_Flags = ADIOF_PERVOL;
Audio_Request.ioa_Data = BeepWave;
Audio_Request.ioa_Length = BEEPSIZE;
Audio_Request.ioa_Period = COLORCLOCK / (BEEPSIZE * BEEPFREQ);
Audio_Request.ioa_Volume = p_volume;
Audio_Request.ioa_Cycles = 100;
}
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the File menu topic. */
/*****************************************************************/
void InitFileItems()
{
int n, nxfer;
struct HowToInit Externs; /* for the external xfer pgms */
char *p, *p1;
if(capture == TRUE)
filetext[FILEMAX-1] = "Capturing";
else
filetext[FILEMAX-1] = "Capture";
do_menu_init(FileItem, FileText, FILE_INIT_ENTRY, FILEMAX);
FileItem[0].SubItem = ModeItem;
do_menu_init(ModeItem, ModeText, MODE_INIT_ENTRY, MODEMAX);
p = (char *)&Externs; p1 = (char *)MODE_INIT_ENTRY;
for(n = 0; n < sizeof(struct HowToInit); n++)
*(p++) = *(p1++);
nxfer = MODEMAX;
for(n = 0; n < NumExts; n++) {
struct ExternalXfer *exp = ExtXfer[n];
nxfer = n + MODEMAX;
ModeItem[nxfer-1].NextItem = &ModeItem[nxfer];
Externs.text = &exp->dispname;
*Externs.cmdkeys = exp->cmdkey;
do_menu_init(&ModeItem[nxfer], &ModeText[nxfer], &Externs, 1);
ModeItem[nxfer].TopEdge = 10 * nxfer;
}
for(n = 0; n <= nxfer; n++ ) {
ModeItem[n].MutualExclude = (~(1 << n));
}
if(p_xproto > nxfer) {
p_xproto = MODEMAX - 1;
}
ModeItem[p_xproto].Flags |= CHECKED;
}
/******************************************************************
** Main Comm menu
** set up for Baud & Parity submenus
*******************************************************************/
void InitCommItems()
{
struct IntuiText *itext;
int n;
do_menu_init(CommItem, CommText, COMM_INIT_ENTRY, COMMAX);
CommItem[0].SubItem = RSItem;
CommItem[1].SubItem = ParItem;
CommItem[2].SubItem = XFItem;
CommItem[3].Flags |= CHECKIT | MENUTOGGLE;
CommItem[3].Width += CHECKWIDTH;
itext = (struct IntuiText *)CommItem[3].ItemFill;
itext->LeftEdge = CHECKWIDTH;
if(p_shared)
CommItem[3].Flags |= CHECKED;
else
CommItem[3].Flags &= (-1L ^ CHECKED);
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the BaudRate Submenu topic. */
/*****************************************************************/
do_menu_init(RSItem, RSText, RS_INIT_ENTRY, RSMAX);
for( n=0; n<RSMAX; n++ ) {
RSItem[n].MutualExclude = (~(1 << n));
}
/* select baud item chekced */
switch (p_baud) {
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; p_baud = 2400;
}
RSItem[n].Flags |= CHECKED;
/* initialize text for specific menu items */
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Parity Submenu topic. */
/*****************************************************************/
do_menu_init(ParItem, ParText, PAR_INIT_ENTRY, PARMAX);
for( n=0; n<PARMAX-2; n++ ) {
ParItem[n].MutualExclude = (~(1 << n));
}
/* select parity item chekced */
ParItem[p_parity].Flags |= CHECKED;
if(p_strip)
ParItem[PARMAX-1].Flags |= CHECKED;
else
ParItem[PARMAX-1].Flags &= (-1L ^ CHECKED);
ParItem[5].Flags |= HIGHNONE; /* Don't highlight "----" */
ParItem[5].Flags &= (-1L ^ (CHECKIT | MENUTOGGLE)); /* No checkmarks */
/*****************************************************************/
/* The following initializes the structure arrays */
/* initialize text for specific menu items */
/* needed to provide the Transfer Mode menu topic. */
/*****************************************************************/
do_menu_init(XFItem, XFText, XF_INIT_ENTRY, XFMAX);
/* initialize each menu item and IntuiText with loop */
for(n = 0; n < 2; n++)
XFItem[n].MutualExclude = 2 - n;
/* mode checked */
XFItem[p_mode].Flags |= CHECKED;
if (p_convert)
XFItem[2].Flags |= CHECKED;
if (p_autochop)
XFItem[3].Flags |= CHECKED;
} /* end of InitCommItems() */
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the Script menu topic. */
/*****************************************************************/
void InitScriptItems()
{
do_menu_init(ScriptItem, ScriptText, SCRIPT_INIT_ENTRY, SCRIPTMAX);
}
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the Util menu topic. */
/*****************************************************************/
void InitUtilItems()
{
struct IntuiText *itext;
int n;
do_menu_init(UtilItem, UtilText, UTIL_INIT_ENTRY, UTILMAX);
/* initialize each menu item and IntuiText with loop */
for(n = 0; n < 4; n++) {
UtilItem[n].Flags &= (-1L ^ (CHECKIT | MENUTOGGLE));
}
if (p_echo)
UtilItem[4].Flags |= CHECKED;
if (p_wrap)
UtilItem[5].Flags |= CHECKED;
if (p_keyapp == 0)
UtilItem[6].Flags |= CHECKED;
if (p_curapp)
UtilItem[7].Flags |= CHECKED;
if (p_bs_del)
UtilItem[8].Flags |= CHECKED;
if (p_xbeep)
UtilItem[9].Flags |= CHECKED;
if(p_mouse_up)
UtilItem[10].Flags |= CHECKED;
if(p_mouse_down)
UtilItem[11].Flags |= CHECKED;
swap_bs_del(); /* Setup keys[] properly... */
swap_bs_del(); /* ...for mode */
}
/****************************************************************/
/* The following function inits the Menu structure array with */
/* appropriate values for our simple menu. Review the manual */
/* if you need to know what each value means. */
/****************************************************************/
void InitMenu()
{
menu[0].NextMenu = &menu[1];
menu[0].LeftEdge = 5;
menu[0].TopEdge = 0;
menu[0].Width = 40;
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 = 55;
menu[1].TopEdge = 0;
menu[1].Width = 88;
menu[1].Height = 10;
menu[1].Flags = MENUENABLED;
menu[1].MenuName = "Comm Setup"; /* text for menu-bar display */
menu[1].FirstItem = &CommItem[0]; /* pointer to first item in list */
menu[2].NextMenu = &menu[3];
menu[2].LeftEdge = 153;
menu[2].TopEdge = 0;
menu[2].Width = 56;
menu[2].Height = 10;
menu[2].Flags = MENUENABLED;
menu[2].MenuName = "Script"; /* text for menu-bar display */
menu[2].FirstItem = &ScriptItem[0]; /* pointer to first item in list*/
menu[3].NextMenu = NULL;
menu[3].LeftEdge = 225;
menu[3].TopEdge = 0;
menu[3].Width = 64;
menu[3].Height = 10;
menu[3].Flags = MENUENABLED;
menu[3].MenuName = "Utility"; /* text for menu-bar display */
menu[3].FirstItem = &UtilItem[0]; /* pointer to first item in list*/
}
void do_menu_init(menuitem, menutext, initentry, max)
struct MenuItem menuitem[];
struct IntuiText menutext[];
struct HowToInit *initentry;
int max;
{
int n, nplus1;
char **temp;
/* initialize each menu item and IntuiText with loop */
for( n=0; n < max; n++ ) {
nplus1 = n + 1;
temp = initentry->text;
menutext[n].IText = (UBYTE *)temp[n];
menuitem[n].NextItem = &menuitem[nplus1];
menuitem[n].LeftEdge = initentry->LeftEdge * Ysize;
menuitem[n].TopEdge = 10 * n;
menuitem[n].Width = initentry->Width * Ysize;
if(initentry->Flags & CHECKIT)
menuitem[n].Width += CHECKWIDTH;
menuitem[n].Height = 10;
menuitem[n].Flags = initentry->Flags;
menuitem[n].MutualExclude = 0;
menuitem[n].ItemFill = (APTR)&menutext[n];
menuitem[n].SelectFill = NULL;
if((initentry->cmdkeys != NULL)
&& (initentry->cmdkeys[n])
&& (initentry->cmdkeys[n] != ' ')) {
menuitem[n].Command = initentry->cmdkeys[n];
menuitem[n].Flags |= COMMSEQ;
}
else menuitem[n].Command = 0;
menuitem[n].SubItem = NULL;
menuitem[n].NextSelect = 0;
menutext[n].FrontPen = 0;
menutext[n].BackPen = 1;
menutext[n].DrawMode = JAM2;/* render in fore and background */
if(menuitem[n].Flags & CHECKIT)
menutext[n].LeftEdge = CHECKWIDTH;
else
menutext[n].LeftEdge = 0;
menutext[n].TopEdge = 1;
menutext[n].ITextFont = NULL;
menutext[n].NextText = NULL;
}
menuitem[max-1].NextItem = NULL;
}
#if AREXX
makerexxport()
{
int i,
ret = 0;
long hostlen = strlen(HOSTNAMEROOT) + strlen(mysername) + 1 + 2 + 1;
/* "VT100-" name "-" "xx" \0 */
if(HostName) {
FreeMem(HostName, (ULONG)(strlen(HostName)+1));
HostName = NULL;
}
if( (HostName = AllocMem(hostlen, MEMF_PUBLIC | MEMF_CLEAR)) == NULL)
return NOHOSTMEM;
sprintf(HostName, "%s%s-%02d", HOSTNAMEROOT, mysername, p_unit);
Forbid();
if(FindPort(HostName) != NULL)
ret = HAVEVT100PORT;
else if( (FromRexxPort = (struct MsgPort *)AllocMem((LONG)sizeof(struct MsgPort),
MEMF_PUBLIC | MEMF_CLEAR)) == NULL)
ret = NOPORTMEM;
else {
InitPort(FromRexxPort, HostName);
AddPort(FromRexxPort);
}
Permit();
if(ret && RexxSysBase) {
CloseLibrary((struct Library *)RexxSysBase);
RexxSysBase = NULL;
}
return ret;
}
#endif /* AREXX */