/* $Revision Header * Header built automatically - do not edit! *************
 *
 *	(C) Copyright 1991 by Olaf 'Olsen' Barthel & MXM
 *
 *	Name .....: TermGlobal.h
 *	Created ..: Monday 21-Jan-91 20:12
 *	Revision .: 0
 *
 *	Date            Author          Comment
 *	=========       ========        ====================
 *	21-Jan-91       Olsen           Created this file!
 *
 * $Revision Header ********************************************************/

#include "xproto.h"
#include "shared.h"

	/* Menu item codes. */

enum	{	MEN_OPEN=1,MEN_SAVE,MEN_SAVEAS,MEN_PRINTSCREEN,MEN_ICONIFY,MEN_ABOUT,MEN_QUIT,
		MEN_SETCONSOLE,MEN_DOSCOMMAND,MEN_REXXCOMMAND,MEN_EDIT,MEN_PASTE,MEN_PACKET,
		MEN_CLEARBUFFER,MEN_DISPLAYBUFFER,MEN_CLOSEBUFFER,MEN_LOADBUFFER,MEN_SAVEBUFFER,MEN_CAPTUREDISK,MEN_CAPTUREPRINTER,
		MEN_UPLOADTEXT,MEN_DOWNLOADTEXT,MEN_SEND,MEN_RECEIVE,MEN_UPLOAD,MEN_DOWNLOAD,MEN_XFERPROTOCOL,MEN_SELECTXFER,
		MEN_PHONEBOOK,MEN_DIAL,MEN_REDIAL,MEN_PLAY,MEN_SENDBREAK,MEN_HANGUP,MEN_RELEASE,
		MEN_RESETSTYLES,MEN_CLEARSCREEN,MEN_RESETTERMINAL,MEN_SAVEILBM,MEN_SAVEASCII,
		MEN_SERIAL,MEN_MODEM,MEN_TRANSFER,MEN_FASTMACROS,MEN_MACROS,MEN_SCREEN,MEN_TERMINAL,MEN_STARTUP,MEN_EMULATION,MEN_PATH,MEN_HOTKEYS,MEN_SPEECH };

	/* Serial settings. */

enum	{	PARITY_NONE,PARITY_EVEN,PARITY_ODD,PARITY_MARK,PARITY_SPACE };
enum	{	HANDSHAKING_XONXOFF,HANDSHAKING_RTSCTS,HANDSHAKING_NONE };
enum	{	DUPLEX_FULL,DUPLEX_HALF };

	/* Terminal settings. */

enum	{	CR_IGNORE,CR_ASCR,CR_ASCRLF };
enum	{	LF_IGNORE,LF_ASLF,LF_ASLFCR };
enum	{	EMULATION_ANSIVT100,EMULATION_ATOMIC,EMULATION_TTY,EMULATION_EXTERNAL };
enum	{	COLOUR_AMIGA,COLOUR_EIGHT,COLOUR_SIXTEEN,COLOUR_MONO };

	/* Protocol types. */

enum	{	PROTOCOL_XMODEM,PROTOCOL_XMODEMCRC,PROTOCOL_YMODEM,PROTOCOL_ZMODEM };

	/* Font types. */

enum	{	FONT_TOPAZ,FONT_IBM };

	/* Status types. */

enum	{	STATUS_READY,STATUS_HOLDING,STATUS_DIALING,STATUS_UPLOAD,
		STATUS_DOWNLOAD,STATUS_BREAKING,STATUS_HANGUP };

	/* Font scales. */

enum	{	SCALE_NORMAL,SCALE_HALF };
enum	{	SCALE_ATTR_NORMAL,SCALE_ATTR_TOP2X,SCALE_ATTR_BOT2X,SCALE_ATTR_2X };

	/* Transfer types. */

enum	{	TRANSFER_BINARY,TRANSFER_TEXT,TRANSFER_ASCII };

	/* Upload panel actions. */

enum	{	UPLOAD_TEXT=1,UPLOAD_BINARY,UPLOAD_IGNORE,UPLOAD_ABORT };

	/* Miscellaneous emulation setup errors. */

enum	{	EM_LOADFAILED=1,EM_NOPORT,EM_NOPROC,EM_TIMEOUT,EM_VERSION,
		EM_DATA,EM_RESOURCES,EM_CONSOLE };

	/* These signal masks will make life a bit easier. */

#define SIG_WINDOW	(1 << Window -> UserPort -> mp_SigBit)
#define SIG_REXX	(1 << TermRexxPort -> mp_SigBit)
#define SIG_SERIAL	(1 << ReadPort -> mp_SigBit)
#define SIG_PACKET	(1 << PacketWindow -> UserPort -> mp_SigBit)
#define SIG_TIMER	(1 << TimeRequest -> tr_node . io_Message . mn_ReplyPort -> mp_SigBit)
#define SIG_AUDIO	(1 << AudioBlock -> ioa_Request . io_Message . mn_ReplyPort -> mp_SigBit)

	/* Most simple one line macro to return NULL if `Gadget' happens
	 * to be NULL as well.
	 */

#define	BailOut()	if(!Gadget) return(NULL)

	/* Size of the serial read buffer. Changing this value means having
	 * to recompile Serial.c, termMain.c and termRexx.c
	 */

#define SERBUFF_SIZE	16384

	/* Special character treatment. */

struct SpecialKey
{
	UBYTE	Key;
	VOID	(*Routine)();
};

	/* Cursor backup data. */

struct CursorData
{
	BYTE	Charset;
	BYTE	Attributes;
	BYTE	UseRegion;
	BYTE	RegionSet;
	WORD	Top,Bottom;
	WORD	CursorX,CursorY;
};

	/* Global data link. */

struct TermPort
{
	struct MsgPort		 ExecNode;

	struct Window		*TopWindow;

	struct SignalSemaphore	 OpenSemaphore;

	LONG			 ID,OpenCount,HoldIt;
	LONG			 Reserved[5];
};

	/* A dial list entry. */

struct PhoneNode
{
	struct Node		 VanillaNode;

	ULONG			 Number;
	struct PhoneEntry	*Entry;
};

	/* A Fast! macro list entry. */

struct MacroNode
{
	struct MacroNode	*mn_Succ;	/* Modeled after the default Node. */
	struct MacroNode	*mn_Pred;

	WORD			 mn_Pad;	/* Included only for Node compatibility. */

	UBYTE			*mn_Macro;	/* = ln_Name, title */
	UBYTE			*mn_Code;	/* The execution code. */
};

	/* Speech preferences. */

struct SpeechConfig
{
	WORD	Rate;
	WORD	Pitch;
	LONG	Frequency;
	BYTE	Sex;
	BYTE	Volume;
	BYTE	Enabled;
	BYTE	Pad;
};

	/* Macro Preferences. */

struct MacroKeys
{
	UBYTE	Keys[4][10][256];
};

	/* term configuration. */

struct Configuration
{
	/* Serial Preferences. */

	ULONG	BaudRate;
	BYTE	BitsPerChar;
	BYTE	Parity;
	BYTE	StopBits;
	BYTE	Handshaking;
	BYTE	Duplex;
	BYTE	HighSpeed;
	ULONG	BreakLength;
	UBYTE	SerialDevice[40];
	LONG	UnitNumber;

	/* Modem Preferences. */

	UBYTE	ModemInit[80];
	UBYTE 	ModemExit[80];
	UBYTE 	ModemHangup[80];
	UBYTE	DialPrefix[80];
	LONG	RedialDelay;
	LONG	DialRetries;
	LONG	DialTimeout;
	BYTE	ConnectAutoCapture;
	BYTE	ConnectAutoBaud;
	BYTE	LogActions;
	UBYTE	NoCarrier[16];
	UBYTE	Connect[16];
	UBYTE	Voice[16];
	UBYTE	Ring[16];
	UBYTE	Busy[16];

	/* Transfer Preferences. */

	UBYTE	Protocol[40];

	/* Startup macro. */

	UBYTE	StartupMacro[256];

	/* Macro Preferences. */

	UBYTE	MacroFile[256];

	/* Screen Preferences. */

	ULONG	DisplayMode;
	UWORD	Colours[16];
	BYTE	MakeScreenPublic;
	BYTE	ShanghaiWindows;

	/* Terminal Preferences. */

	BYTE	CaptureFilter;
	BYTE	DestructiveBackspace;
	BYTE	AudibleBell;
	BYTE	VisibleBell;
	BYTE	EightyColumns;
	BYTE	DisableBlinking;
	BYTE	SendCR;
	BYTE	SendLF;
	BYTE	ColourMode;
	BYTE	Emulation;
	BYTE	Font;

	/* Emulation control. */

	BYTE	CursorApp;
	BYTE	FontScale;
	BYTE	JumpScroll;
	BYTE	AutoWrap;
	BYTE	CursorWrap;
	BYTE	NewLine;
	BYTE	InsertChar;
	BYTE	NumApp;

	/* Path Preferences. */

	UBYTE	DefaultStorage[256];

	UBYTE	TextUploadPath[256];
	UBYTE	TextDownloadPath[256];

	UBYTE	ASCIIUploadPath[256];
	UBYTE	ASCIIDownloadPath[256];

	UBYTE	BinaryUploadPath[256];
	UBYTE	BinaryDownloadPath[256];

	UBYTE	CapturePath[256];
	UBYTE	LogFile[256];
	UBYTE	Editor[256];
	UBYTE	BeepSound[256];

	/* Extension in version 1.9b */

	BYTE	SwapBSDelete;
	BYTE	StripBit8;

	/* Some more extensions... */

	BYTE	RasterEnabled;

	UBYTE	EmulationName[256];
};

	/* term hotkey configuration. */

struct Hotkeys
{
	UBYTE	termScreenToFront[256];
	UBYTE	BufferScreenToFront[256];
	UBYTE	SkipDialEntry[256];
	BYTE	CommodityPriority;
	BYTE	HotkeysEnabled;

	ULONG	Reserved[25];
};

	/* A phonebook entry. */

struct PhoneEntry
{
	UBYTE			Name[30];
	UBYTE			Number[40];
	UBYTE			Password[40];

	LONG			PayPerUnit[2];
	LONG			SecPerUnit[2];
	LONG			TimeOfDay[2];

	struct Configuration	Config;
};

	/* Number of buffers to be used for buffered I/O. */

#define BUFFER_NUMBER 2

	/* Auxiliary structure for buffered file I/O. */

struct Buffer
{
	struct Message		 Message;			/* Vanilla message header. */

	BYTE			 Read;				/* Last access has read data. */
	BYTE			 Written;			/* Last access has written data. */

	LONG			 Action;			/* Action to perform. */
	LONG			 ActionData[2];			/* Seek and the like. */
	LONG			 Result;			/* Return value. */

	BPTR			 FileHandle;			/* Dos filehandle. */

	UBYTE			*Data;				/* Data buffer. */
	LONG			 BufLength;			/* Length of data buffer. */

	LONG			 BufPosition;			/* Read/write pointer into buffer. */

	LONG			 ReadBufFull;			/* How many bytes are still to be read from the buffer? */
	LONG			 WriteBufFull;			/* How many bytes are still to be written to the buffer?*/

	LONG			 RealPosition;			/* Real position in file. */
	LONG			 Cached;			/* How many bytes in pre-load cache. */

	UBYTE			*DataBuffer[BUFFER_NUMBER];	/* The data buffers. */
	LONG			 DataLength[BUFFER_NUMBER];	/* The lengths of the data buffers. */
	WORD			 DataCount;			/* Which buffer to use. */
	BYTE			 WriteAccess;			/* TRUE if a write file handle. */
	BYTE			 LastActionFailed;		/* TRUE if last action failed -> abort actions. */

	struct Process		*Child;
	struct Process		*Caller;			/* Synchronization. */

	BYTE			 Fresh;				/* TRUE if no read/write access has taken place yet. */
};

	/* Global data flow <-> term interface. */

struct FlowInfo
{
	BYTE	Changed;

	BYTE	NoCarrier;
	BYTE	ZModemUpload;

	BYTE	Connect;
	BYTE	Voice;
	BYTE	Ring;
	BYTE	Busy;
};

	/* A scan sequence, somewhat similar to the FlowInfo
	 * structure.
	 */

struct ScanNode
{
	struct MinNode	 Node;

	UBYTE		*Sequence;	/* Character sequence to be matched. */
	LONG		 Count;		/* Number of characters matched. */
};

	/* xpr serial bits. */

#define ST_PARTYON	(1 << 0)
#define ST_PARTYODD	(1 << 1)
#define ST_7WIRE	(1 << 2)
#define ST_QBREAK	(1 << 3)
#define ST_RADBOOGIE	(1 << 4)
#define ST_SHARED	(1 << 5)
#define ST_EOFMODE	(1 << 6)
#define ST_XDISABLED	(1 << 7)
#define ST_PARTYMARKON	(1 << 8)
#define ST_PARTYMARK	(1 << 9)
#define ST_2BITS	(1 << 10)
#define ST_READ7	(1 << 11)
#define ST_WRITE7	(1 << 12)

	/* Miscellaneous definitions. */

#define SPECIALKEYS	12

#define MILLION		1000000

#define	ATTR_UNDERLINE	1
#define	ATTR_HIGHLIGHT	2
#define ATTR_BLINK	4
#define	ATTR_INVERSE	8

	/* Status macro (is character printable?). */

#define IsPrintable(c)	(ValidTab[(c)])
#define IsControl(c)	(((c) > 127 && (c) < 160) ? TRUE : FALSE)

	/* Some macros which used to be in clib/macros.h. */

#define MAX(a,b)	((a) > (b) ? (a) : (b))
#define MIN(a,b)	((a) < (b) ? (a) : (b))
#define ABS(x)		(((x) < 0) ? (-(x)) : (x))

	/* Print a certain string. */

#define Print(s)	Text(RPort,(s),strlen(s))

	/* Set the stopwatch pointer. */

#define SetWait(Window)	SetPointer((Window),&Stopwatch[0],16,16,-6,0)

	/* Audio channels. */

#define LEFT0F  1
#define RIGHT0F  2
#define RIGHT1F  4
#define LEFT1F  8

	/* Program revision and the approriate info structure. */

struct TermInfo
{
	UWORD	Version;
	UWORD	Revision;
};

extern LONG TermVersion,TermRevision;
extern UBYTE TermName[],TermDate[];

	/* Buffer.c */

LONG __stdargs			BPrintf(struct Buffer *Buffer,UBYTE *Format,...);

BYTE __regargs			BufferClose(struct Buffer *Buffer);
struct Buffer * __regargs	BufferOpen(UBYTE *Name,UBYTE *AccessMode);
LONG __regargs			BufferRead(struct Buffer *Buffer,UBYTE *Destination,LONG Size);
LONG __regargs			BufferWrite(struct Buffer *Buffer,UBYTE *Source,LONG Size);
BYTE __regargs			BufferSeek(struct Buffer *Buffer,LONG Offset,LONG Origin);

	/* Beep.c */

BYTE				CreateBeep(VOID);
VOID				DeleteBeep(VOID);
VOID				Beep(VOID);
BYTE				OpenSound(UBYTE *Name);

	/* Console.c */

VOID __regargs			CaptureToFile(APTR Buffer,LONG Size);
VOID __regargs			Capture(APTR Buffer,LONG Size);

BYTE				HandleCursor(UBYTE Char);

VOID				DoBackspace(VOID);
VOID				RealBeep(VOID);
VOID				DoSomeBeep(VOID);

VOID				DoLF(VOID);
VOID				DoIgnore(VOID);
VOID				DoShiftIn(VOID);
VOID				DoShiftOut(VOID);
VOID				DoCR_LF(VOID);
VOID				DoFF(VOID);
VOID				DoLF_FF_VT(VOID);
VOID				DoCR(VOID);

VOID				DoTab(VOID);

VOID				SpillTheBeans(UBYTE *Buffer,LONG Size);

VOID				ConWrite(APTR Buffer,LONG Size);
VOID				ConProcess(UBYTE *String,LONG Size);
VOID __stdargs			ConWrites(UBYTE *String,...);
UBYTE				KeyConvert(struct IntuiMessage *Massage,UBYTE *Buffer);

	/* DialPanel.c */

VOID				DialPanel(VOID);

	/* FastMacros.c */

VOID				RefreshFastWindow(WORD Height);
VOID				CloseFastWindow(VOID);
BYTE				OpenFastWindow(VOID);
struct MacroNode *		NewFastMacro(UBYTE *Macro,UBYTE *Code);
VOID				RemFastMacro(struct MacroNode *Node);
struct MacroNode *		GetFastMacro(LONG Offset);
VOID				ClearFastMacroList(struct List *List);
LONG				GetFastMacroOffset(struct MacroNode *MacroNode);
VOID __regargs			MoveList(struct List *From,struct List *To);
BYTE				SaveFastMacros(UBYTE *Name);
BYTE				LoadFastMacros(UBYTE *Name);

	/* FastMacroPanel.c */

VOID				FastMacroPanel(VOID);

	/* Identify.c */

VOID				Identify(UBYTE *Name);

	/* Packet.c */

VOID				ClearPacketHistory(VOID);
VOID				PacketKey(struct Hook *Hook,struct SGWork *Work,ULONG *Msg);
BYTE				HandlePacket(VOID);
VOID				AddPacketHistory(UBYTE *Buffer);
VOID				DeletePacketWindow(VOID);
BYTE				CreatePacketWindow(VOID);

	/* ParseCode.c */

VOID				DoCancel(VOID);
VOID				CSIFake(VOID);
BYTE				ParseCode(UBYTE c);

	/* ParseRoutines.c */

VOID				ClearCursor(VOID);
VOID				DrawCursor(VOID);
VOID				SetCursor(VOID);
VOID				ClipBlitCursor(UBYTE DoClip,UBYTE DoMove); 
VOID				BackupRender(VOID);
VOID				ShiftChar(LONG Size);
VOID				ScrollRegion(WORD Direction);
VOID				DownLine(VOID);
VOID				ResetCursor(VOID);
UBYTE *				Ignore(VOID);
UBYTE *				CursorScrollDown(VOID);
UBYTE *				CursorScrollUp(VOID);
UBYTE *				NextLine(VOID);
UBYTE *				SaveCursor(VOID);
UBYTE *				FontStuff(UBYTE *);
UBYTE *				LoadCursor(VOID);
UBYTE *				ScaleFont(UBYTE *);
UBYTE *				SetTab(VOID);
UBYTE *				RequestTerminal(UBYTE *Buffer);
UBYTE *				Reset(VOID);
UBYTE *				RequestInformation(UBYTE *Buffer);
UBYTE *				SetSomething(UBYTE *Buffer);
UBYTE *				NumericAppMode(UBYTE *Buffer);
UBYTE *				MoveCursor(UBYTE *Buffer);
UBYTE *				EraseLine(UBYTE *Buffer);
UBYTE *				EraseScreen(UBYTE *Buffer);
UBYTE *				EraseCharacters(UBYTE *Buffer);
UBYTE *				InsertLine(UBYTE *Buffer);
UBYTE *				ClearLine(UBYTE *Buffer);
UBYTE *				SetTabs(UBYTE *Buffer);
UBYTE *				SetPosition(UBYTE *Buffer);
UBYTE *				SetAttributes(UBYTE *Buffer);
UBYTE *				SetRegion(UBYTE *Buffer);

	/* SaveILBM. */

LONG				SaveRPort(struct RastPort *RPort,struct ViewPort *VPort,LONG LeftEdge,LONG TopEdge,LONG Width,LONG Height,LONG ParentWidth,LONG ParentHeight,LONG Cookie,STRPTR Name);

	/* Scale.c */

VOID				DeleteScale(VOID);
BYTE				CreateScale(VOID);
VOID				PrintScaled(UBYTE *Buffer,LONG Size,UBYTE Scale);

	/* Serial.c */

VOID				XOn(VOID);
VOID				SerialCommand(UBYTE *String);
VOID				SerWrite(APTR Buffer,LONG Size);
VOID				SetFlags(struct IOExtSer *SomeRequest);
VOID				SetParameters(VOID);
VOID				FlushSerial(VOID);
VOID				ClearSerial(VOID);
VOID				DeleteSerial(VOID);
BYTE				CreateSerial(VOID);

	/* SpeechPanel.c */

VOID				SpeechPanel(VOID);

	/* StringHook.c */

ULONG __saveds __asm		HookEntry(register __a0 struct Hook *HookPtr,register __a2 APTR Object,register __a1 APTR Messsage);
VOID				InitHook(struct Hook *Hook,APTR HookCode);
VOID __saveds			ClipServer(VOID);
VOID				CommandKey(struct Hook *Hook,struct SGWork *Work,ULONG *Msg);

	/* termAux.c */

struct Node *			GetListNode(LONG Offset,struct List *List);
struct ConUnit *		GetConUnit(struct MsgPort *);
VOID				AddDownloadObject(UBYTE *Line);
VOID				ClearDownloadObjects(VOID);
struct ScanNode *		SequenceFilter(UBYTE Char);
VOID				AddSequenceObject(UBYTE *Sequence);
VOID				ClearSequenceObjects(VOID);
VOID __stdargs			LogAction(UBYTE *String,...);
VOID				FlushMsg(struct Window *Window);
BYTE				GetString(UBYTE *Prompt,UBYTE *Buffer);
VOID				WakeUp(struct Window *Window);
VOID				SendAmigaDOSCommand(UBYTE *Name);
VOID __saveds			RexxBackgroundServer(VOID);
VOID				SendARexxCommand(UBYTE *Name);
LONG				ahtoi(UBYTE *String);
VOID				BlockWindows(VOID);
VOID				ReleaseWindows(VOID);
BYTE				LineRead(BPTR File,UBYTE *Buffer,LONG MaxChars);
VOID				FlowInit(VOID);
VOID				FlowFilter(UBYTE Char);
BYTE				LoadMacros(UBYTE *Name,struct MacroKeys *Keys);
struct MenuItem *		FindThisItem(ULONG MenuID);
LONG				GetFileSize(UBYTE *Name);
struct FileRequester *		GetFile(UBYTE *Title,UBYTE *Directory,UBYTE *Name,UBYTE *Buffer,UBYTE *Pattern,BYTE SaveFlag,BYTE MultiSelect,BYTE DirsOnly,UBYTE *OKText);
WORD __stdargs			MyEasyRequest(struct Window *Window,UBYTE *Text,UBYTE *Gadgets,...);
VOID __saveds			StatusServer(VOID);
VOID				CloseWindowSafely(struct Window *Window);
VOID				WaitTime(LONG Secs,LONG Micros);
UBYTE *				GetEnvDOS(UBYTE *Name,UBYTE *Buffer);
BYTE				SetEnvDOS(UBYTE *Name,UBYTE *Value);
VOID				BumpWindow(struct Window *SomeWindow);
VOID				BumpDefault(VOID);
BYTE				WriteIFFData(UBYTE *Name,APTR Data,LONG Size,ULONG Type);
BYTE				ReadIFFData(UBYTE *Name,APTR Data,LONG Size,ULONG Type);
VOID				PushWindow(struct Window *Window);
VOID				PopWindow(VOID);

	/* termBuffer.c */

VOID __saveds			BufferServer(VOID);
VOID				AddLine(UBYTE *Line,LONG Size);
VOID				ClearBuffer(VOID);
VOID				StoreBuffer(APTR Buffer,LONG Size);

	/* termClip.c */

BYTE				SaveClip(APTR Buffer,LONG Size);
LONG				LoadClip(APTR Buffer,LONG Size);

	/* termInfo.c */

VOID				ShowInfo(BYTE Ticks);

	/* termInit.c */

VOID				ConfigSetup(VOID);
BYTE				DeleteDisplay(VOID);
UBYTE *				CreateDisplay(BYTE FirstSetup);
VOID				CloseAll(VOID);
UBYTE *				OpenAll(VOID);

	/* termHotkeys. */

VOID				ShutdownCx(VOID);
BYTE				SetupCx(VOID);

	/* termMain.c */

LONG __saveds			main(VOID);
VOID				HandleInput(VOID);
BYTE				HandleWindow(VOID);
BYTE				HandleSerial(VOID);
VOID				HandleMenu(ULONG Code);

	/* termPhone.c */

VOID				SetPrefToDefaults(struct Configuration *Config,UBYTE *PathBuffer);
struct List *			CreatePhoneList(VOID);
VOID				DeletePhoneList(struct List *PhoneList);
VOID				SortPhoneEntries(VOID);
VOID				RemPhoneEntry(LONG Num);
BYTE				NewPhoneEntry(VOID);
struct PhoneEntry **		CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries);
VOID				DeletePhonebook(struct PhoneEntry **,LONG Size,BYTE FreeEntries);
BYTE				SavePhonebook(UBYTE *Name);
BYTE				LoadPhonebook(UBYTE *Name);

	/* TerminalPanel.c */

VOID				TerminalPanel(struct Configuration *Config);
	/* SerialPanel.c */

BYTE				SerialPanel(struct Configuration *Config);

	/* ScreenPanel.c */

BYTE				ScreenPanel(struct Configuration *Config);

	/* PhonePanel.c */

BYTE				PhonePanel(VOID);

	/* ModemPanel.c */

BYTE				ModemPanel(struct Configuration *Config);

	/* MacroPanel.c */

VOID				MacroPanel(struct MacroKeys *MacroKeys);

	/* termRaster.c */

VOID				RasterMarkArea(WORD Column,WORD Line,WORD Length);
VOID				RasterClip(BYTE SingleChar,BYTE Xerox);
VOID				DeleteRaster(VOID);
BYTE				CreateRaster(VOID);
VOID				RasterEraseScreen(BYTE Mode);
VOID				RasterEraseLine(BYTE Mode);
VOID				RasterEraseCharacters(WORD Chars);
VOID				RasterClearLine(WORD Lines);
VOID				RasterInsertLine(WORD Lines);
VOID				RasterScrollRegion(WORD Direction,WORD RasterTop,WORD RasterBottom,WORD RasterLines);
VOID				RasterShiftChar(WORD Size);
VOID				RasterPutString(UBYTE *String,WORD Length);

	/* termRexx.c */

BYTE				SendRexxCommand(struct RexxHost *HostPort,STRPTR CommandString,STRPTR FileExtension,STRPTR HostName);
VOID				FreeRexxCommand(struct RexxMsg *RexxMessage);
VOID				ReplyRexxCommand(struct RexxMsg *RexxMessage,LONG Primary,LONG Secondary,STRPTR Result);
STRPTR				GetToken(STRPTR String,LONG *StartChar,STRPTR AuxBuff,LONG MaxLength);

UBYTE *				QueryBaud(VOID);
UBYTE *				QueryDataBits(VOID);
UBYTE *				QueryParity(VOID);
UBYTE *				QueryStopBits(VOID);
UBYTE *				QueryHandshaking(VOID);
UBYTE *				QueryDuplex(VOID);
UBYTE *				QueryHighspeed(VOID);
UBYTE *				QueryBreakLength(VOID);
UBYTE *				QuerySerialDevice(VOID);
UBYTE *				QueryUnitNumber(VOID);
UBYTE *				QueryModemInit(VOID);
UBYTE *				QueryModemExit(VOID);
UBYTE *				QueryDialPrefix(VOID);
UBYTE *				QueryRedialDelay(VOID);
UBYTE *				QueryDialRetries(VOID);
UBYTE *				QueryDialTimeout(VOID);
UBYTE *				QueryConnectAutoBaud(VOID);
UBYTE *				QueryNoCarrier(VOID);
UBYTE *				QueryConnect(VOID);
UBYTE *				QueryError(VOID);
UBYTE *				QueryVoice(VOID);
UBYTE *				QueryRing(VOID);
UBYTE *				QueryBusy(VOID);
UBYTE *				QueryOkay(VOID);
UBYTE *				QueryProtocol(VOID);
UBYTE *				QueryProtocolOptions(VOID);
UBYTE *				QueryMacroFile(VOID);
UBYTE *				QueryDisplay(VOID);
UBYTE *				QueryPublicScreen(VOID);
UBYTE *				QueryShanghai(VOID);
UBYTE *				QueryCaptureFilter(VOID);
UBYTE *				QueryDSBackSpace(VOID);
UBYTE *				QueryAudBell(VOID);
UBYTE *				QueryVisBell(VOID);
UBYTE *				QueryEightyColumns(VOID);
UBYTE *				QuerySendCR(VOID);
UBYTE *				QuerySendLF(VOID);
UBYTE *				QueryColourMode(VOID);
UBYTE *				QueryEmulation(VOID);
UBYTE *				QueryFont(VOID);
UBYTE *				QueryStatus(VOID);
UBYTE *				QuerySerial(VOID);
UBYTE *				QueryStartup(VOID);
UBYTE *				QueryRequesters(VOID);
UBYTE *				QueryTimeout(VOID);
UBYTE *				QueryLine(VOID);
UBYTE *				QueryLines(VOID);
UBYTE *				QueryColumns(VOID);
UBYTE *				QueryCursor(VOID);
UBYTE *				QueryModemHangup(VOID);
UBYTE *				QueryAutoCapture(VOID);
UBYTE *				QueryLogActions(VOID);
UBYTE *				QueryBlinking(VOID);
UBYTE *				QueryCursorMode(VOID);
UBYTE *				QueryFontScale(VOID);
UBYTE *				QueryJumpScroll(VOID);
UBYTE *				QueryCharacterWrap(VOID);
UBYTE *				QueryCursorWrap(VOID);
UBYTE *				QueryNewLine(VOID);
UBYTE *				QueryInsert(VOID);
UBYTE *				QueryNumeric(VOID);
UBYTE *				QueryDefaultStore(VOID);
UBYTE *				QueryTUploadPath(VOID);
UBYTE *				QueryTDownloadPath(VOID);
UBYTE *				QueryAUploadPath(VOID);
UBYTE *				QueryADownloadPath(VOID);
UBYTE *				QueryBUploadPath(VOID);
UBYTE *				QueryBDownloadPath(VOID);
UBYTE *				QueryCapturePath(VOID);
UBYTE *				QueryLogFile(VOID);
UBYTE *				QueryEditor(VOID);
UBYTE *				QueryBeepSound(VOID);
UBYTE *				QueryCaptureState(VOID);
UBYTE *				QueryDownloads(VOID);
UBYTE *				QueryScreenAddress(VOID);
UBYTE *				QuerySpeechFile(VOID);
UBYTE *				QuerySpeechRate(VOID);
UBYTE *				QuerySpeechPitch(VOID);
UBYTE *				QuerySpeechFrequency(VOID);
UBYTE *				QuerySpeechVolume(VOID);
UBYTE *				QuerySpeechSex(VOID);
UBYTE *				QuerySpeech(VOID);

VOID				RexxSetBaud(UBYTE *String);
VOID				RexxSetDataBits(UBYTE *String);
VOID				RexxSetParity(UBYTE *String);
VOID				RexxSetStopBits(UBYTE *String);
VOID				RexxSetHandshaking(UBYTE *String);
VOID				RexxSetDuplex(UBYTE *String);
VOID				RexxSetHighSpeed(UBYTE *String);
VOID				RexxSetBreakLength(UBYTE *String);
VOID				RexxSetSerialDevice(UBYTE *String);
VOID				RexxSetUnitNumber(UBYTE *String);
VOID				RexxSetModemInit(UBYTE *String);
VOID				RexxSetModemExit(UBYTE *String);
VOID				RexxSetDialPrefix(UBYTE *String);
VOID				RexxSetRedialDelay(UBYTE *String);
VOID				RexxSetDialRetries(UBYTE *String);
VOID				RexxSetDialTimeout(UBYTE *String);
VOID				RexxSetConnectAutoBaud(UBYTE *String);
VOID				RexxSetNoCarrier(UBYTE *String);
VOID				RexxSetConnect(UBYTE *String);
VOID				RexxSetError(UBYTE *String);
VOID				RexxSetVoice(UBYTE *String);
VOID				RexxSetRing(UBYTE *String);
VOID				RexxSetBusy(UBYTE *String);
VOID				RexxSetOkay(UBYTE *String);
VOID				RexxSetScreenMode(UBYTE *String);
VOID				RexxSetFilter(UBYTE *String);
VOID				RexxSetBackspace(UBYTE *String);
VOID				RexxSetCR(UBYTE *String);
VOID				RexxSetLF(UBYTE *String);
VOID				RexxSet80Columns(UBYTE *String);
VOID				RexxSetColourMode(UBYTE *String);
VOID				RexxSetEmulation(UBYTE *String);
VOID				RexxSetStartup(UBYTE *String);
VOID				RexxSetFont(UBYTE *String);
VOID				RexxSetProtocol(UBYTE *String);
VOID				RexxSetProtocolOptions(UBYTE *String);
VOID				RexxSetMacro(UBYTE *String);
VOID				RexxSetColour(UBYTE *String);
VOID				RexxSetScreen(UBYTE *String);
VOID				RexxSetBell(UBYTE *String);
VOID				RexxSetMacroFile(UBYTE *String);
VOID				RexxSetRequesters(UBYTE *String);
VOID				RexxSetTimeout(UBYTE *String);
VOID				RexxSetSerial(UBYTE *String);
VOID				RexxSetModemHangup(UBYTE *String);
VOID				RexxSetAutoCapture(UBYTE *String);
VOID				RexxSetLogActions(UBYTE *String);
VOID				RexxSetBlinking(UBYTE *String);
VOID				RexxSetCursorMode(UBYTE *String);
VOID				RexxSetFontScale(UBYTE *String);
VOID				RexxSetJumpScroll(UBYTE *String);
VOID				RexxSetCharacterWrap(UBYTE *String);
VOID				RexxSetCursorWrap(UBYTE *String);
VOID				RexxSetNewLine(UBYTE *String);
VOID				RexxSetInsert(UBYTE *String);
VOID				RexxSetNumeric(UBYTE *String);
VOID				RexxSetDefaultStore(UBYTE *String);
VOID				RexxSetTUploadPath(UBYTE *String);
VOID				RexxSetTDownloadPath(UBYTE *String);
VOID				RexxSetAUploadPath(UBYTE *String);
VOID				RexxSetADownloadPath(UBYTE *String);
VOID				RexxSetBUploadPath(UBYTE *String);
VOID				RexxSetBDownloadPath(UBYTE *String);
VOID				RexxSetCapturePath(UBYTE *String);
VOID				RexxSetLogFile(UBYTE *String);
VOID				RexxSetEditor(UBYTE *String);
VOID				RexxSetSpeechRate(UBYTE *String);
VOID				RexxSetSpeechPitch(UBYTE *String);
VOID				RexxSetSpeechFrequency(UBYTE *String);
VOID				RexxSetSpeechVolume(UBYTE *String);
VOID				RexxSetSpeechSex(UBYTE *String);
VOID				RexxSetSpeech(UBYTE *String);

UBYTE *				RexxBreak(VOID);
UBYTE *				RexxTUpload(UBYTE *String);
UBYTE *				RexxTDownload(UBYTE *String);
UBYTE *				RexxBDownload(UBYTE *String);
UBYTE *				RexxBUpload(UBYTE *String);
UBYTE *				RexxWrite(UBYTE *String);
UBYTE *				RexxResetStyles(VOID);
UBYTE *				RexxClearScreen(VOID);
UBYTE *				RexxSaveILBM(UBYTE *String);
UBYTE *				RexxHangUp(VOID);
UBYTE *				RexxGetString(UBYTE *String);
UBYTE *				RexxCommand(UBYTE *String);
UBYTE *				RexxMessage(UBYTE *String);
UBYTE *				RexxPutClip(UBYTE *String);
UBYTE *				RexxGetClip(VOID);
UBYTE *				RexxDelay(UBYTE *String);
UBYTE *				RexxDial(UBYTE *String);
UBYTE *				RexxInput(UBYTE *String);
UBYTE *				RexxPrinter(UBYTE *String);
UBYTE *				RexxMacros(UBYTE *String);
UBYTE *				RexxSpeech(UBYTE *String);
UBYTE *				RexxConfig(UBYTE *String);
UBYTE *				RexxPhone(UBYTE *String);
UBYTE *				RexxCapture(UBYTE *String);
UBYTE *				RexxBuffer(UBYTE *String);
UBYTE *				RexxFirstDownload(VOID);
UBYTE *				RexxNextDownload(VOID);
UBYTE *				RexxLastDownload(VOID);
UBYTE *				RexxWaitString(UBYTE *String);
UBYTE *				RexxToneDial(UBYTE *String);
UBYTE *				RexxSimpleRequest(UBYTE *String);
UBYTE *				RexxTwoGadRequest(UBYTE *String);
UBYTE *				RexxFileRequest(UBYTE *String);
UBYTE *				RexxSpeak(UBYTE *String);

VOID				QuietExit(VOID);
VOID				Rexx2Front(VOID);
VOID				Term2Front(VOID);
VOID				Display2Front(VOID);
VOID				CloseDisplay(VOID);

BYTE				RexxASyncCommand(struct RexxMsg *RexxMsg,UBYTE *Arg1,UBYTE *Arg2);
VOID				RexxSyncCommand(struct RexxMsg *RexxMsg,UBYTE *Arg1,UBYTE *Arg2);

VOID __saveds			RexxServer(VOID);
VOID				HandleRexx(VOID);

	/* termSpeech. */

VOID				DeleteSpeech(VOID);
BYTE				CreateSpeech(VOID);
VOID				Say(UBYTE *String,...);
VOID				SpeechSetup(VOID);

	/* termSub.c */

BYTE				OpenSubWindow(VOID);
VOID				CloseSubWindow(VOID);
VOID				AddSubEntry(LONG Entry);
VOID				RemSub(struct PhoneNode *SubNode);
BYTE				RemSubEntry(VOID);
VOID				FreeSubList(VOID);
BYTE				HandleSubWindow(struct Window *PanelWindow);

	/* termTransfer.c */

VOID				StartXprReceive(BYTE Type);
BYTE				StartXprSend(BYTE Type);
BYTE				ASCIISetup(VOID);
VOID				ASCIIShutdown(VOID);

	/* termXEM.c */

VOID				DeleteEmulator(BYTE UnloadIt);
BYTE				CreateEmulator(UBYTE *Name,BYTE ForceNew);

	/* termXpr.c */

LONG __saveds __asm		xpr_fopen(register __a0 UBYTE *FileName,register __a1 UBYTE *AccessMode);
LONG __saveds __asm		xpr_fclose(register __a0 struct Buffer *File);
LONG __saveds __asm		xpr_fread(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 struct Buffer *File);
LONG __saveds __asm		xpr_fwrite(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 struct Buffer *File);
ULONG __saveds __asm		xpr_sread(register __a0 UBYTE *Buffer,register __d0 ULONG Size,register __d1 LONG Timeout);
LONG __saveds __asm		xpr_swrite(register __a0 UBYTE *Buffer,register __d0 LONG Size);
LONG __saveds			xpr_sflush(VOID);
LONG __saveds __asm		xpr_update(register __a0 struct XPR_UPDATE *UpdateInfo);
LONG __saveds			xpr_chkabort(VOID);
LONG __saveds __asm		xpr_gets(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer);
LONG __saveds __asm		xpr_setserial(register __d0 LONG Status);
LONG __saveds __asm		xpr_ffirst(register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern);
LONG __saveds __asm		xpr_fnext(register __d0 LONG OldState,register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern);
LONG __saveds __asm		xpr_finfo(register __a0 UBYTE *FileName,register __d0 LONG InfoType);
LONG __saveds __asm		xpr_fseek(register __a0 struct Buffer *File,register __d0 LONG Offset,register __d1 LONG Origin);
ULONG __saveds __asm		xpr_options(register __d0 LONG NumOpts,register __a0 struct xpr_option **Opts);
LONG __saveds __asm		xpr_unlink(register __a0 UBYTE *FileName);
LONG __saveds			xpr_squery(VOID);
LONG __saveds __asm		xpr_getptr(register __d0 LONG InfoType);
LONG __saveds __asm		xpr_stealopts(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer);

struct Gadget *			CreateAllGetsGadgets(BYTE LoadGadget,UBYTE *String,UBYTE *Prompt,LONG *WindowWidth,struct Gadget **GadgetArray,struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge,struct Screen *Screen);

BYTE				ProtocolSetup(VOID);
VOID				SaveProtocolOpts(VOID);
BYTE				SelectProtocol(UBYTE *Name,struct Window *ParentWindow);

	/* ToneDial.c */

VOID				DeleteTone(VOID);
BYTE				ToneDial(UBYTE *Number);

	/* TransferPanel.c */

VOID __stdargs			TransferInfo(WORD X,WORD Y,BYTE *String,...);
VOID __stdargs			ShowString(struct Gadget *Gadget,UBYTE *String,...);
VOID				GhostStats(struct Gadget *Gadget);
VOID				ShowStats(struct Gadget *Gadget,LONG Value,LONG Max);
BYTE				TransferPanel(UBYTE *Title);
VOID				DeleteTransferPanel(VOID);

	/* UploadPanel.c */

BYTE				UploadPanel(VOID);

	/* Format.asm/Res.asm */

VOID __stdargs			Printf(UBYTE *,...);
VOID __stdargs			SPrintf(APTR,UBYTE *,...);
VOID __stdargs			VSPrintf(APTR,UBYTE *,va_list);
LONG __stdargs			FPrintf(BPTR,UBYTE *,...);

struct MsgPort * __stdargs	Res(UBYTE *,LONG,APTR,LONG,LONG);

	/* termData.c */

extern struct ExecBase		*SysBase;
extern struct DosLibrary	*DOSBase;

extern struct IntuitionBase	*IntuitionBase;
extern struct GfxBase		*GfxBase;
extern struct Library		*GadToolsBase;
extern struct Library		*DiskfontBase;
extern struct Library		*UtilityBase;
extern struct Device		*TimerBase;
extern struct Library		*AslBase;
extern struct RxsLib		*RexxSysBase;
extern struct Library		*IFFParseBase;
extern struct Library		*CxBase;
extern struct Library		*LayersBase;
extern struct Library		*IconBase;
extern struct Library		*WorkbenchBase;
extern struct Library		*KeymapBase;

extern struct timerequest	*TimeRequest;

extern struct IOStdReq		*ConsoleRequest;
extern struct Device		*ConsoleDevice;

extern struct Screen		*Screen;
extern struct Window		*Window;
extern struct Window		*StatusWindow;
extern APTR			 OldWindowPtr;

extern struct ViewPort		*VPort;
extern struct RastPort		*RPort;
extern struct TextFont		*Topaz,*IBM,*GFX,*CurrentFont;
extern APTR			 VisualInfo;

extern UWORD			 ANSIPens[NUMDRIPENS + 1];
extern UWORD			 EGAPens[NUMDRIPENS + 1];
extern UWORD			 AtomicColours[16];
extern UWORD			 EGAColours[16];
extern UWORD			 ANSIColours[16];
extern UWORD			 DefaultColours[16];
extern UWORD			 BlinkColours[16];
extern UWORD			 StandardColours[16];

extern struct Process		*ThisProcess;
extern struct Process		*RexxProcess;
extern struct MsgPort		*TermRexxPort;
extern struct Task		*StatusTask;
extern struct Process		*BufferProcess;
extern struct WBStartup		*WBenchMsg;
extern BPTR			 RemoteCurrentDir;

extern struct InputEvent	*FakeInputEvent;

extern struct IOExtSer		*ReadRequest;
extern struct IOExtSer		*WriteRequest;
extern struct MsgPort		*ReadPort;
extern APTR			 ReadBuffer;

extern struct Hotkeys		 Hotkeys;
extern struct NewBroker		 NewTermBroker;

extern struct TextAttr		 DefaultFont;
extern struct TextAttr		 IBMFont;
extern struct TextAttr		 GFXFont;

extern UBYTE			 AnyChannel[4];

extern UBYTE __chip		 SineWave[8];

extern struct IOAudio		*AudioBlock;

extern UWORD __chip		 Stopwatch[(2 + 16) * 2];

extern BYTE			 ValidTab[256];
extern UBYTE			 IBMConversion[256];

extern struct SpecialKey	 SpecialKeys[SPECIALKEYS];
extern UBYTE			 SpecialMap[256];

extern UBYTE			 SharedBuffer[512];

extern struct NewMenu		 TermMenu[];
extern struct Menu		*Menu;

extern struct TermPort		*TermPort;

extern struct Configuration	 Config;
extern struct Configuration	 PrivateConfig;
extern struct SpeechConfig	 SpeechConfig;
extern BYTE			 Status;
extern BYTE			 Online;
extern UWORD			 PublicModes;

extern UBYTE			 LastConfig[256];
extern UBYTE			 DefaultPubScreen[MAXPUBSCREENNAME];

extern ULONG			 ModeID[16];

extern struct Buffer		*FileCapture;
extern BPTR			 PrinterCapture;
extern UBYTE			 CaptureName[256];

extern UBYTE			**BufferLines;
extern LONG			 Lines;
extern struct SignalSemaphore	*BufferSemaphore;
extern LONG			 MaxLines;
extern LONG			 BufferSpace;
extern BYTE			 BufferClosed;

extern struct PhoneEntry	**Phonebook;
extern LONG			 PhoneSize;

extern LONG			 NumPhoneEntries;

extern UBYTE			 LastPhone[256];
extern UBYTE			 LastKeys[256];
extern UBYTE			 LastMacros[256];
extern UBYTE			 LastSpeech[256];

extern struct MacroKeys		*MacroKeys;

extern UWORD			 LastLine,LastColumn;
extern BYTE			 Charset,Attributes,FgPen,BgPen;
extern WORD			 CursorX,CursorY,Top,Bottom;
extern BYTE			 UseRegion,RegionSet,InSequence,Quiet;
extern BYTE			 TabStops[1024];

extern struct CursorData	 CursorBackup;

extern BYTE			 ResetDisplay,Escape;

extern UBYTE			*AttentionBuffers[7],AttentionCount[7],FlowCount;
extern BYTE			 BaudPending,FullCheck;
extern UBYTE			 BaudBuffer[20],BaudCount;

extern struct FlowInfo		 FlowInfo;

extern LONG			 FileCount,FileCountMax;
extern struct WBArg		*FileArg;
extern BYTE			 MultipleFiles,FileMatch,BinaryTransfer;
extern struct AnchorPath	*FileAnchor;
extern LONG			 TransferBits;

extern struct Window		*TransferWindow;
extern struct Menu		*TransferMenu;
extern struct Gadget		*TransferGadgetArray[5];

extern UBYTE			*DownloadPath;
extern BYTE			 Uploading;

extern struct Library		*XProtocolBase;
extern struct XPR_IO		*XprIO;

extern UBYTE			 ProtocolOptsBuffer[256];
extern BYTE			 NewLibrary,NewOptions,DidTransfer;
extern UBYTE			 LastXprLibrary[60];
extern BYTE			 UsesZModem;

extern LONG			 CurrentPay;
extern LONG			 PayPerUnit[2];
extern LONG			 SecPerUnit[2];
extern LONG			 TimeOfDay[2];
extern WORD			 PreferredTime;
extern UBYTE			 Password[40];

extern UBYTE			 WindowName[256];

extern BYTE			 WeAreBlocking;

extern struct List		*SubList;
extern LONG			 SubItemNum;
extern struct Window		*SubWindow;
extern LONG			 SubListNum;

extern BYTE			 SendStartup;

extern BYTE			 ReleaseSerial;
extern BYTE			 ResetSerial;
extern BYTE			 BatchMode;

extern UBYTE			 LastDownload[256];
extern UBYTE			 LastUpload[256];

extern struct Hook		 CommandHook;
extern BYTE			 DontActivate;
extern UBYTE			 CommandWorkBuffer[256];
extern struct StringExtend	 CommandExtend;
extern struct Window		*CommandWindow;
extern struct Gadget		*CommandGadget;
extern struct Gadget		*ActiveGadget;

extern struct Process		*ClipProcess;
extern struct MsgPort		*ClipPort;

extern struct Window		*PacketWindow;
extern struct Gadget		*PacketGadgetArray[1];
extern struct Menu		*PacketMenu;
extern struct Gadget		*PacketGadgetList;
extern struct List		 PacketHistoryList;

extern struct NewMenu		 GetsMenu[];

extern BYTE			 Initializing,LoadColours;

extern UBYTE			*Raster,*RasterAttr;
extern WORD			 RasterWidth,RasterHeight;

extern struct SignalSemaphore	*DownloadSemaphore;
extern struct List		 DownloadList;
extern LONG			 DownloadLineCount;
extern struct Node		*DownloadNode;

extern struct List		 SequenceList;
extern LONG			 SequenceCount;

extern ULONG			 VersionProps[2];

extern BYTE			 ExitQuietly;

extern struct Window		*RexxWindow;

extern struct Window		*TopWindow;
extern struct Window		*WindowStack[5];
extern WORD			 WindowStackPtr;

extern LONG			 TermID;
extern UBYTE			 TermIDString[];

extern struct List		 FastMacroList;
extern LONG			 FastMacroCount;
extern UBYTE			 LastFastMacros[256];
extern struct Window		*FastWindow;
extern struct Gadget		*FastGadget;

extern struct List		 DoubleBufferList;
extern struct SignalSemaphore	 DoubleBufferSemaphore;

extern struct confuncs		*Console;
extern ULONG			 ExtSigs;
extern UBYTE			*OptionTitle;
extern BYTE			 NewEmulatorPlease;
extern BYTE			 EmulationSetupError;
extern UBYTE			*EmulationErrorStrings[8];