home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 550b.lha / Term_v1.8a / Source.LZH / termGlobal.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-26  |  29.3 KB  |  1,081 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: TermGlobal.h
  6.  *    Created ..: Monday 21-Jan-91 20:12
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    21-Jan-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. #include "xproto.h"
  16.  
  17.     /* Menu item codes. */
  18.  
  19. enum    {    MEN_OPEN=1,MEN_SAVE,MEN_SAVEAS,MEN_PRINTSCREEN,MEN_ABOUT,MEN_QUIT,
  20.         MEN_SETCONSOLE,MEN_DOSCOMMAND,MEN_REXXCOMMAND,MEN_EDIT,MEN_PASTE,MEN_PACKET,
  21.         MEN_CLEARBUFFER,MEN_DISPLAYBUFFER,MEN_CLOSEBUFFER,MEN_LOADBUFFER,MEN_SAVEBUFFER,MEN_CAPTUREDISK,MEN_CAPTUREPRINTER,
  22.         MEN_UPLOADTEXT,MEN_DOWNLOADTEXT,MEN_SEND,MEN_RECEIVE,MEN_UPLOAD,MEN_DOWNLOAD,MEN_XFERPROTOCOL,MEN_SELECTXFER,
  23.         MEN_PHONEBOOK,MEN_DIAL,MEN_REDIAL,MEN_PLAY,MEN_SENDBREAK,MEN_HANGUP,MEN_RELEASE,
  24.         MEN_RESETSTYLES,MEN_CLEARSCREEN,MEN_SAVEILBM,MEN_SAVEASCII,
  25.         MEN_SERIAL,MEN_MODEM,MEN_TRANSFER,MEN_MACROS,MEN_SCREEN,MEN_TERMINAL,MEN_STARTUP,MEN_EMULATION,MEN_PATH,MEN_HOTKEYS,MEN_SPEECH };
  26.  
  27.     /* Serial settings. */
  28.  
  29. enum    {    PARITY_NONE,PARITY_EVEN,PARITY_ODD,PARITY_MARK,PARITY_SPACE };
  30. enum    {    HANDSHAKING_XONXOFF,HANDSHAKING_RTSCTS,HANDSHAKING_NONE };
  31. enum    {    DUPLEX_FULL,DUPLEX_HALF };
  32.  
  33.     /* Terminal settings. */
  34.  
  35. enum    {    CR_IGNORE,CR_ASCR,CR_ASCRLF };
  36. enum    {    LF_IGNORE,LF_ASLF,LF_ASLFCR };
  37. enum    {    EMULATION_ANSIVT100,EMULATION_ATOMIC,EMULATION_TTY };
  38. enum    {    COLOUR_AMIGA,COLOUR_EIGHT,COLOUR_SIXTEEN,COLOUR_MONO };
  39.  
  40.     /* Protocol types. */
  41.  
  42. enum    {    PROTOCOL_XMODEM,PROTOCOL_XMODEMCRC,PROTOCOL_YMODEM,PROTOCOL_ZMODEM };
  43.  
  44.     /* Font types. */
  45.  
  46. enum    {    FONT_TOPAZ,FONT_IBM };
  47.  
  48.     /* Status types. */
  49.  
  50. enum    {    STATUS_READY,STATUS_HOLDING,STATUS_DIALING,STATUS_UPLOAD,
  51.         STATUS_DOWNLOAD,STATUS_BREAKING,STATUS_HANGUP };
  52.  
  53.     /* Font scales. */
  54.  
  55. enum    {    SCALE_NORMAL,SCALE_TOP2X,SCALE_BOT2X,SCALE_2X,SCALE_HALF };
  56.  
  57.     /* Transfer types. */
  58.  
  59. enum    {    TRANSFER_BINARY,TRANSFER_TEXT,TRANSFER_ASCII };
  60.                     
  61.     /* These signal masks will make life a bit easier. */
  62.  
  63. #define SIG_WINDOW    (1 << Window -> UserPort -> mp_SigBit)
  64. #define SIG_REXX    (1 << TermRexxPort -> mp_SigBit)
  65. #define SIG_SERIAL    (1 << ReadPort -> mp_SigBit)
  66. #define SIG_PACKET    (1 << PacketWindow -> UserPort -> mp_SigBit)
  67. #define SIG_TIMER    (1 << TimeRequest -> tr_node . io_Message . mn_ReplyPort -> mp_SigBit)
  68. #define SIG_AUDIO    (1 << AudioBlock -> ioa_Request . io_Message . mn_ReplyPort -> mp_SigBit)
  69.  
  70.     /* Special character treatment. */
  71.  
  72. struct SpecialKey
  73. {
  74.     UBYTE    Key;
  75.     VOID    (*Routine)();
  76. };
  77.  
  78.     /* Cursor backup data. */
  79.  
  80. struct CursorData
  81. {
  82.     BYTE    Charset;
  83.     BYTE    Attributes;
  84.     BYTE    UseRegion;
  85.     SHORT    Top,Bottom;
  86.     SHORT    CursorX,CursorY;
  87. };
  88.  
  89.     /* Global data link. */
  90.  
  91. struct TermPort
  92. {
  93.     struct MsgPort         ExecNode;
  94.  
  95.     struct Window        *TopWindow;
  96.  
  97.     struct SignalSemaphore     OpenSemaphore;
  98.  
  99.     LONG             ID,OpenCount,HoldIt;
  100.     LONG             Reserved[5];
  101. };
  102.  
  103.     /* A dial list entry. */
  104.  
  105. struct PhoneNode
  106. {
  107.     struct Node         VanillaNode;
  108.  
  109.     ULONG             Number;
  110.     struct PhoneEntry    *Entry;
  111. };
  112.  
  113.     /* Speech preferences. */
  114.  
  115. struct SpeechConfig
  116. {
  117.     SHORT    Rate;
  118.     SHORT    Pitch;
  119.     LONG    Frequency;
  120.     BYTE    Sex;
  121.     BYTE    Volume;
  122.     BYTE    Enabled;
  123.     BYTE    Pad;
  124. };
  125.  
  126.     /* Macro Preferences. */
  127.  
  128. struct MacroKeys
  129. {
  130.     UBYTE    Keys[4][10][256];
  131. };
  132.  
  133.     /* term configuration. */
  134.  
  135. struct Configuration
  136. {
  137.     /* Serial Preferences. */
  138.  
  139.     ULONG    BaudRate;
  140.     BYTE    BitsPerChar;
  141.     BYTE    Parity;
  142.     BYTE    StopBits;
  143.     BYTE    Handshaking;
  144.     BYTE    Duplex;
  145.     BYTE    HighSpeed;
  146.     ULONG    BreakLength;
  147.     UBYTE    SerialDevice[40];
  148.     LONG    UnitNumber;
  149.  
  150.     /* Modem Preferences. */
  151.  
  152.     UBYTE    ModemInit[80];
  153.     UBYTE     ModemExit[80];
  154.     UBYTE     ModemHangup[80];
  155.     UBYTE    DialPrefix[80];
  156.     LONG    RedialDelay;
  157.     LONG    DialRetries;
  158.     LONG    DialTimeout;
  159.     BYTE    ConnectAutoCapture;
  160.     BYTE    ConnectAutoBaud;
  161.     BYTE    LogActions;
  162.     UBYTE    NoCarrier[16];
  163.     UBYTE    Connect[16];
  164.     UBYTE    Voice[16];
  165.     UBYTE    Ring[16];
  166.     UBYTE    Busy[16];
  167.  
  168.     /* Transfer Preferences. */
  169.  
  170.     UBYTE    Protocol[40];
  171.  
  172.     /* Startup macro. */
  173.  
  174.     UBYTE    StartupMacro[256];
  175.  
  176.     /* Macro Preferences. */
  177.  
  178.     UBYTE    MacroFile[256];
  179.  
  180.     /* Screen Preferences. */
  181.  
  182.     ULONG    DisplayMode;
  183.     UWORD    Colours[16];
  184.     BYTE    MakeScreenPublic;
  185.     BYTE    ShanghaiWindows;
  186.  
  187.     /* Terminal Preferences. */
  188.  
  189.     BYTE    CaptureFilter;
  190.     BYTE    DestructiveBackspace;
  191.     BYTE    AudibleBell;
  192.     BYTE    VisibleBell;
  193.     BYTE    EightyColumns;
  194.     BYTE    DisableBlinking;
  195.     BYTE    SendCR;
  196.     BYTE    SendLF;
  197.     BYTE    ColourMode;
  198.     BYTE    Emulation;
  199.     BYTE    Font;
  200.  
  201.     /* Emulation control. */
  202.  
  203.     BYTE    CursorApp;
  204.     BYTE    FontScale;
  205.     BYTE    JumpScroll;
  206.     BYTE    AutoWrap;
  207.     BYTE    CursorWrap;
  208.     BYTE    NewLine;
  209.     BYTE    InsertChar;
  210.     BYTE    NumApp;
  211.  
  212.     /* Path Preferences. */
  213.  
  214.     UBYTE    DefaultStorage[256];
  215.  
  216.     UBYTE    TextUploadPath[256];
  217.     UBYTE    TextDownloadPath[256];
  218.  
  219.     UBYTE    ASCIIUploadPath[256];
  220.     UBYTE    ASCIIDownloadPath[256];
  221.  
  222.     UBYTE    BinaryUploadPath[256];
  223.     UBYTE    BinaryDownloadPath[256];
  224.  
  225.     UBYTE    CapturePath[256];
  226.     UBYTE    LogFile[256];
  227.     UBYTE    Editor[256];
  228.     UBYTE    BeepSound[256];
  229. };
  230.  
  231.     /* term hotkey configuration. */
  232.  
  233. struct Hotkeys
  234. {
  235.     UBYTE    termScreenToFront[256];
  236.     UBYTE    BufferScreenToFront[256];
  237.     UBYTE    SkipDialEntry[256];
  238.     BYTE    CommodityPriority;
  239.     BYTE    HotkeysEnabled;
  240.  
  241.     ULONG    Reserved[25];
  242. };
  243.  
  244.     /* A phonebook entry. */
  245.  
  246. struct PhoneEntry
  247. {
  248.     UBYTE            Name[30];
  249.     UBYTE            Number[40];
  250.     UBYTE            Password[40];
  251.  
  252.     LONG            PayPerUnit[2];
  253.     LONG            SecPerUnit[2];
  254.     LONG            TimeOfDay[2];
  255.  
  256.     struct Configuration    Config;
  257. };
  258.  
  259.     /* Global data flow <-> term interface. */
  260.  
  261. struct FlowInfo
  262. {
  263.     BYTE    Changed;
  264.  
  265.     BYTE    NoCarrier;
  266.     BYTE    ZModemUpload;
  267.  
  268.     BYTE    Connect;
  269.     BYTE    Voice;
  270.     BYTE    Ring;
  271.     BYTE    Busy;
  272. };
  273.  
  274.     /* A scan sequence, somewhat similar to the FlowInfo
  275.      * structure.
  276.      */
  277.  
  278. struct ScanNode
  279. {
  280.     struct MinNode     Node;
  281.  
  282.     UBYTE        *Sequence;    /* Character sequence to be matched. */
  283.     LONG         Count;        /* Number of characters matched. */
  284. };
  285.  
  286.     /* xpr serial bits. */
  287.  
  288. #define ST_PARTYON    (1 << 0)
  289. #define ST_PARTYODD    (1 << 1)
  290. #define ST_7WIRE    (1 << 2)
  291. #define ST_QBREAK    (1 << 3)
  292. #define ST_RADBOOGIE    (1 << 4)
  293. #define ST_SHARED    (1 << 5)
  294. #define ST_EOFMODE    (1 << 6)
  295. #define ST_XDISABLED    (1 << 7)
  296. #define ST_PARTYMARKON    (1 << 8)
  297. #define ST_PARTYMARK    (1 << 9)
  298. #define ST_2BITS    (1 << 10)
  299. #define ST_READ7    (1 << 11)
  300. #define ST_WRITE7    (1 << 12)
  301.  
  302.     /* Miscellaneous definitions. */
  303.  
  304. #define SPECIALKEYS    12
  305.  
  306. #define MILLION        1000000
  307.  
  308. #define    ATTR_UNDERLINE    1
  309. #define    ATTR_HIGHLIGHT    2
  310. #define ATTR_BLINK    4
  311. #define    ATTR_INVERSE    8
  312.  
  313.     /* Status macro (is character printable?). */
  314.  
  315. #define IsPrintable(c)    (ValidTab[(c)])
  316. #define IsControl(c)    (((c) > 127 && (c) < 160) ? TRUE : FALSE)
  317.  
  318.     /* Some macros which used to be in clib/macros.h. */
  319.  
  320. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  321. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  322. #define ABS(x)        (((x) < 0) ? (-(x)) : (x))
  323.  
  324.     /* Print a certain string. */
  325.  
  326. #define Print(s)    Text(RPort,(s),strlen(s))
  327.  
  328.     /* Convert the case of a character. */
  329.  
  330. #define ToUpper(c)    ((((c) >= 224 && (c) <= 254) || ((c) >= 'a' && (c) <= 'z')) ? (c) - 32 : (c))
  331. #define ToLower(c)    ((((c) >= 192 && (c) <= 222) || ((c) >= 'A' && (c) <= 'Z')) ? (c) + 32 : (c))
  332.  
  333.     /* Set the stopwatch pointer. */
  334.  
  335. #define SetWait(Window)    SetPointer((Window),&Stopwatch[0],16,16,-6,0)
  336.  
  337.     /* String gadget hooks. */
  338.  
  339. #define SGEXT(Gadget,Extend) {(((struct StringInfo *)(Gadget) -> SpecialInfo) -> Extension) = (Extend); Gadget -> Activation |= GACT_STRINGEXTEND;}
  340.  
  341.     /* Audio channels. */
  342.  
  343. #define LEFT0F  1
  344. #define RIGHT0F  2
  345. #define RIGHT1F  4
  346. #define LEFT1F  8
  347.  
  348.     /* Program revision and the approriate info structure. */
  349.  
  350. struct TermInfo
  351. {
  352.     UWORD    Version;
  353.     UWORD    Revision;
  354. };
  355.  
  356. extern LONG TermVersion,TermRevision;
  357. extern UBYTE TermName[],TermDate[];
  358.  
  359.     /* Beep.c */
  360.  
  361. BYTE                CreateBeep(VOID);
  362. VOID                DeleteBeep(VOID);
  363. VOID                Beep(VOID);
  364. BYTE                OpenSound(UBYTE *Name);
  365.  
  366.     /* Console.c */
  367.  
  368. BYTE                HandleCursor(UBYTE Char);
  369.  
  370. VOID                DoBackspace(VOID);
  371. VOID                DoSomeBeep(VOID);
  372.  
  373. VOID                DoLF(VOID);
  374. VOID                DoIgnore(VOID);
  375. VOID                DoCR_LF(VOID);
  376. VOID                DoFF(VOID);
  377. VOID                DoLF_FF_VT(VOID);
  378. VOID                DoCR(VOID);
  379.  
  380. VOID                DoTab(VOID);
  381.  
  382. VOID                SpillTheBeans(UBYTE *Buffer,LONG Size);
  383.  
  384. VOID                ConWrite(APTR Buffer,LONG Size);
  385. VOID                ConProcess(UBYTE *String,LONG Size);
  386. VOID __stdargs            ConWrites(UBYTE *String,...);
  387. UBYTE                KeyConvert(struct IntuiMessage *Massage,UBYTE *Buffer);
  388.  
  389.     /* DialPanel.c */
  390.  
  391. VOID                DialPanel(VOID);
  392.  
  393.     /* Identify.c */
  394.  
  395.  
  396. VOID                Identify(UBYTE *Name);
  397.  
  398.     /* Packet.c */
  399.  
  400. VOID                ClearPacketHistory(VOID);
  401. VOID                PacketKey(struct Hook *Hook,struct SGWork *Work,ULONG *Msg);
  402. BYTE                HandlePacket(VOID);
  403. VOID                AddPacketHistory(UBYTE *Buffer);
  404. VOID                DeletePacketWindow(VOID);
  405. BYTE                CreatePacketWindow(VOID);
  406.  
  407.     /* ParseCode.c */
  408.  
  409. VOID                DoCancel(VOID);
  410. VOID                CSIFake(VOID);
  411. BYTE                ParseCode(UBYTE c);
  412.  
  413.     /* ParseRoutines.c */
  414.  
  415. VOID                ClearCursor(VOID);
  416. VOID                DrawCursor(VOID);
  417. VOID                SetCursor(VOID);
  418. VOID                BackupRender(VOID);
  419. VOID                ShiftChar(VOID);
  420. VOID                ScrollRegion(BYTE Direction);
  421. UBYTE *                Ignore(VOID);
  422. UBYTE *                CursorScrollDown(VOID);
  423. UBYTE *                CursorScrollUp(VOID);
  424. UBYTE *                NextLine(VOID);
  425. UBYTE *                SaveCursor(VOID);
  426. UBYTE *                FontStuff(UBYTE *);
  427. UBYTE *                LoadCursor(VOID);
  428. UBYTE *                ScaleFont(UBYTE *);
  429. UBYTE *                SetTab(VOID);
  430. UBYTE *                RequestTerminal(UBYTE *Buffer);
  431. UBYTE *                Reset(VOID);
  432. UBYTE *                RequestInformation(UBYTE *Buffer);
  433. UBYTE *                SetSomething(UBYTE *Buffer);
  434. UBYTE *                NumericAppMode(UBYTE *Buffer);
  435. UBYTE *                MoveCursor(UBYTE *Buffer);
  436. UBYTE *                EraseLine(UBYTE *Buffer);
  437. UBYTE *                EraseScreen(UBYTE *Buffer);
  438. UBYTE *                EraseCharacters(UBYTE *Buffer);
  439. UBYTE *                InsertLine(UBYTE *Buffer);
  440. UBYTE *                ClearLine(UBYTE *Buffer);
  441. UBYTE *                SetTabs(UBYTE *Buffer);
  442. UBYTE *                SetPosition(UBYTE *Buffer);
  443. UBYTE *                SetAttributes(UBYTE *Buffer);
  444. UBYTE *                SetRegion(UBYTE *Buffer);
  445.  
  446.     /* SaveILBM. */
  447.  
  448. LONG                SaveRPort(struct RastPort *RPort,struct ViewPort *VPort,LONG LeftEdge,LONG TopEdge,LONG Width,LONG Height,LONG ParentWidth,LONG ParentHeight,LONG Cookie,STRPTR Name);
  449.  
  450.     /* Scale.c */
  451.  
  452. VOID                DeleteScale(VOID);
  453. BYTE                CreateScale(VOID);
  454. VOID                PrintScaled(UBYTE Char);
  455.  
  456.     /* Serial.c */
  457.  
  458. VOID                XOn(VOID);
  459. VOID                SerialCommand(UBYTE *String);
  460. VOID                SerWrite(APTR Buffer,LONG Size);
  461. VOID                SetFlags(struct IOExtSer *SomeRequest);
  462. VOID                SetParameters(VOID);
  463. VOID                FlushSerial(VOID);
  464. VOID                DeleteSerial(VOID);
  465. BYTE                CreateSerial(VOID);
  466.  
  467.     /* SpeechPanel.c */
  468.  
  469. VOID                SpeechPanel(VOID);
  470.  
  471.     /* StringHook.c */
  472.  
  473. ULONG __saveds __asm        HookEntry(register __a0 struct Hook *HookPtr,register __a2 APTR Object,register __a1 APTR Messsage);
  474. VOID                InitHook(struct Hook *Hook,APTR HookCode);
  475. VOID                CommandKey(struct Hook *Hook,struct SGWork *Work,ULONG *Msg);
  476. VOID                DubGadList(struct Gadget *Gadget);
  477.  
  478.     /* termAux.c */
  479.  
  480. struct ConUnit *        GetConUnit(struct MsgPort *);
  481. VOID                AddDownloadObject(UBYTE *Line);
  482. VOID                ClearDownloadObjects(VOID);
  483. struct ScanNode *        SequenceFilter(UBYTE Char);
  484. VOID                AddSequenceObject(UBYTE *Sequence);
  485. VOID                ClearSequenceObjects(VOID);
  486. VOID __stdargs            LogAction(UBYTE *String,...);
  487. VOID                FlushMsg(struct Window *Window);
  488. UBYTE                Local2Upper(UBYTE c);
  489. BYTE                GetString(UBYTE *Prompt,UBYTE *Buffer);
  490. VOID                WakeUp(struct Window *Window);
  491. VOID                SendAmigaDOSCommand(UBYTE *Name);
  492. VOID __saveds            RexxBackgroundServer(VOID);
  493. VOID                SendARexxCommand(UBYTE *Name);
  494. LONG                ahtoi(UBYTE *String);
  495. VOID                BlockWindows(VOID);
  496. VOID                ReleaseWindows(VOID);
  497. BYTE                LineRead(BPTR File,UBYTE *Buffer,LONG MaxChars);
  498. VOID                FlowInit(VOID);
  499. VOID                FlowFilter(UBYTE Char);
  500. BYTE                LoadMacros(UBYTE *Name,struct MacroKeys *Keys);
  501. struct MenuItem *        FindThisItem(ULONG MenuID);
  502. LONG                GetFileSize(UBYTE *Name);
  503. LONG                StrCmp(UBYTE *a,UBYTE *b);
  504. struct FileRequester *        GetFile(UBYTE *Title,UBYTE *Directory,UBYTE *Name,UBYTE *Buffer,UBYTE *Pattern,BYTE SaveFlag,BYTE MultiSelect);
  505. SHORT __stdargs            MyEasyRequest(struct Window *Window,UBYTE *Text,UBYTE *Gadgets,...);
  506. VOID __saveds            StatusServer(VOID);
  507. VOID                CloseWindowSafely(struct Window *Window);
  508. VOID                WaitTime(LONG Secs,LONG Micros);
  509. UBYTE *                GetEnvDOS(UBYTE *Name,UBYTE *Buffer);
  510. BYTE                SetEnvDOS(UBYTE *Name,UBYTE *Value);
  511. VOID                BumpWindow(struct Window *SomeWindow);
  512. VOID                BumpDefault(VOID);
  513. BYTE                WriteIFFData(UBYTE *Name,APTR Data,LONG Size,ULONG Type);
  514. BYTE                ReadIFFData(UBYTE *Name,APTR Data,LONG Size,ULONG Type);
  515. VOID                PushWindow(struct Window *Window);
  516. VOID                PopWindow(VOID);
  517.  
  518.     /* termBuffer.c */
  519.  
  520. VOID                AddLine(UBYTE *Line,LONG Size);
  521. VOID                ClearBuffer(VOID);
  522. VOID                StoreBuffer(APTR Buffer,LONG Size);
  523. VOID                Capture(APTR Buffer,LONG Size);
  524.  
  525. VOID __saveds            BufferServer(VOID);
  526.  
  527.     /* termClip.c */
  528.  
  529. BYTE                SaveClip(APTR Buffer,LONG Size);
  530. LONG                LoadClip(APTR Buffer,LONG Size);
  531.  
  532.     /* termInfo.c */
  533.  
  534. VOID                ShowInfo(BYTE Ticks);
  535.  
  536.     /* termInit.c */
  537.  
  538. VOID                ConfigSetup(VOID);
  539. BYTE                DeleteDisplay(VOID);
  540. UBYTE *                CreateDisplay(BYTE FirstSetup);
  541. VOID                CloseAll(VOID);
  542. UBYTE *                OpenAll(VOID);
  543.  
  544.     /* termHotkeys. */
  545.  
  546. VOID                ShutdownCx(VOID);
  547. BYTE                SetupCx(VOID);
  548.  
  549.     /* termMain.c */
  550.  
  551. LONG __saveds            main(VOID);
  552. VOID                HandleInput(VOID);
  553. BYTE                HandleWindow(VOID);
  554. BYTE                HandleSerial(VOID);
  555. VOID                HandleMenu(ULONG Code);
  556.  
  557.     /* termPhone.c */
  558.  
  559. VOID                SetPrefToDefaults(struct Configuration *Config,UBYTE *PathBuffer);
  560. struct List *            CreatePhoneList(VOID);
  561. VOID                DeletePhoneList(struct List *PhoneList);
  562. VOID                SortPhoneEntries(VOID);
  563. VOID                RemPhoneEntry(LONG Num);
  564. BYTE                NewPhoneEntry(VOID);
  565. struct PhoneEntry **        CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries);
  566. VOID                DeletePhonebook(struct PhoneEntry **,LONG Size,BYTE FreeEntries);
  567. BYTE                SavePhonebook(UBYTE *Name);
  568. BYTE                LoadPhonebook(UBYTE *Name);
  569.  
  570.     /* TerminalPanel.c */
  571.  
  572. BYTE                TerminalPanel(struct Configuration *Config);
  573. BYTE                SerialPanel(struct Configuration *Config);
  574. BYTE                ScreenPanel(struct Configuration *Config);
  575. struct List *            PhonePanel(LONG *NumCalls);
  576. struct List *            NumberPanel(LONG *NumCalls);
  577. BYTE                ModemPanel(struct Configuration *Config);
  578. VOID                MacroPanel(struct MacroKeys *MacroKeys);
  579.  
  580.     /* termRaster.c */
  581.  
  582. VOID                RasterMarkArea(SHORT Column,SHORT Line,SHORT Length);
  583. VOID                RasterClip(BYTE SingleChar,BYTE Xerox);
  584. VOID                DeleteRaster(VOID);
  585. BYTE                CreateRaster(VOID);
  586. VOID                RasterEraseScreen(BYTE Mode);
  587. VOID                RasterEraseLine(BYTE Mode);
  588. VOID                RasterEraseCharacters(SHORT Chars);
  589. VOID                RasterClearLine(SHORT Lines);
  590. VOID                RasterInsertLine(SHORT Lines);
  591. VOID                RasterScrollRegion(BYTE Direction);
  592. VOID                RasterShiftChar(VOID);
  593. VOID                RasterPutString(UBYTE *String,SHORT Length);
  594.  
  595.     /* termRexx.c */
  596.  
  597. BYTE                SendRexxCommand(struct RexxHost *HostPort,STRPTR CommandString,STRPTR FileExtension,STRPTR HostName);
  598. VOID                FreeRexxCommand(struct RexxMsg *RexxMessage);
  599. VOID                ReplyRexxCommand(struct RexxMsg *RexxMessage,LONG Primary,LONG Secondary,STRPTR Result);
  600. STRPTR                GetToken(STRPTR String,LONG *StartChar,STRPTR AuxBuff,LONG MaxLength);
  601.  
  602. UBYTE *                QueryBaud(VOID);
  603. UBYTE *                QueryDataBits(VOID);
  604. UBYTE *                QueryParity(VOID);
  605. UBYTE *                QueryStopBits(VOID);
  606. UBYTE *                QueryHandshaking(VOID);
  607. UBYTE *                QueryDuplex(VOID);
  608. UBYTE *                QueryHighspeed(VOID);
  609. UBYTE *                QueryBreakLength(VOID);
  610. UBYTE *                QuerySerialDevice(VOID);
  611. UBYTE *                QueryUnitNumber(VOID);
  612. UBYTE *                QueryModemInit(VOID);
  613. UBYTE *                QueryModemExit(VOID);
  614. UBYTE *                QueryDialPrefix(VOID);
  615. UBYTE *                QueryRedialDelay(VOID);
  616. UBYTE *                QueryDialRetries(VOID);
  617. UBYTE *                QueryDialTimeout(VOID);
  618. UBYTE *                QueryConnectAutoBaud(VOID);
  619. UBYTE *                QueryNoCarrier(VOID);
  620. UBYTE *                QueryConnect(VOID);
  621. UBYTE *                QueryError(VOID);
  622. UBYTE *                QueryVoice(VOID);
  623. UBYTE *                QueryRing(VOID);
  624. UBYTE *                QueryBusy(VOID);
  625. UBYTE *                QueryOkay(VOID);
  626. UBYTE *                QueryProtocol(VOID);
  627. UBYTE *                QueryProtocolOptions(VOID);
  628. UBYTE *                QueryMacroFile(VOID);
  629. UBYTE *                QueryDisplay(VOID);
  630. UBYTE *                QueryPublicScreen(VOID);
  631. UBYTE *                QueryShanghai(VOID);
  632. UBYTE *                QueryCaptureFilter(VOID);
  633. UBYTE *                QueryDSBackSpace(VOID);
  634. UBYTE *                QueryAudBell(VOID);
  635. UBYTE *                QueryVisBell(VOID);
  636. UBYTE *                QueryEightyColumns(VOID);
  637. UBYTE *                QuerySendCR(VOID);
  638. UBYTE *                QuerySendLF(VOID);
  639. UBYTE *                QueryColourMode(VOID);
  640. UBYTE *                QueryEmulation(VOID);
  641. UBYTE *                QueryFont(VOID);
  642. UBYTE *                QueryStatus(VOID);
  643. UBYTE *                QuerySerial(VOID);
  644. UBYTE *                QueryStartup(VOID);
  645. UBYTE *                QueryRequesters(VOID);
  646. UBYTE *                QueryTimeout(VOID);
  647. UBYTE *                QueryLine(VOID);
  648. UBYTE *                QueryLines(VOID);
  649. UBYTE *                QueryColumns(VOID);
  650. UBYTE *                QueryCursor(VOID);
  651. UBYTE *                QueryModemHangup(VOID);
  652. UBYTE *                QueryAutoCapture(VOID);
  653. UBYTE *                QueryLogActions(VOID);
  654. UBYTE *                QueryBlinking(VOID);
  655. UBYTE *                QueryCursorMode(VOID);
  656. UBYTE *                QueryFontScale(VOID);
  657. UBYTE *                QueryJumpScroll(VOID);
  658. UBYTE *                QueryCharacterWrap(VOID);
  659. UBYTE *                QueryCursorWrap(VOID);
  660. UBYTE *                QueryNewLine(VOID);
  661. UBYTE *                QueryInsert(VOID);
  662. UBYTE *                QueryNumeric(VOID);
  663. UBYTE *                QueryDefaultStore(VOID);
  664. UBYTE *                QueryTUploadPath(VOID);
  665. UBYTE *                QueryTDownloadPath(VOID);
  666. UBYTE *                QueryAUploadPath(VOID);
  667. UBYTE *                QueryADownloadPath(VOID);
  668. UBYTE *                QueryBUploadPath(VOID);
  669. UBYTE *                QueryBDownloadPath(VOID);
  670. UBYTE *                QueryCapturePath(VOID);
  671. UBYTE *                QueryLogFile(VOID);
  672. UBYTE *                QueryEditor(VOID);
  673. UBYTE *                QueryBeepSound(VOID);
  674. UBYTE *                QueryCaptureState(VOID);
  675. UBYTE *                QueryDownloads(VOID);
  676.  
  677. VOID                RexxSetBaud(UBYTE *String);
  678. VOID                RexxSetDataBits(UBYTE *String);
  679. VOID                RexxSetParity(UBYTE *String);
  680. VOID                RexxSetStopBits(UBYTE *String);
  681. VOID                RexxSetHandshaking(UBYTE *String);
  682. VOID                RexxSetDuplex(UBYTE *String);
  683. VOID                RexxSetHighSpeed(UBYTE *String);
  684. VOID                RexxSetBreakLength(UBYTE *String);
  685. VOID                RexxSetSerialDevice(UBYTE *String);
  686. VOID                RexxSetUnitNumber(UBYTE *String);
  687. VOID                RexxSetModemInit(UBYTE *String);
  688. VOID                RexxSetModemExit(UBYTE *String);
  689. VOID                RexxSetDialPrefix(UBYTE *String);
  690. VOID                RexxSetRedialDelay(UBYTE *String);
  691. VOID                RexxSetDialRetries(UBYTE *String);
  692. VOID                RexxSetDialTimeout(UBYTE *String);
  693. VOID                RexxSetConnectAutoBaud(UBYTE *String);
  694. VOID                RexxSetNoCarrier(UBYTE *String);
  695. VOID                RexxSetConnect(UBYTE *String);
  696. VOID                RexxSetError(UBYTE *String);
  697. VOID                RexxSetVoice(UBYTE *String);
  698. VOID                RexxSetRing(UBYTE *String);
  699. VOID                RexxSetBusy(UBYTE *String);
  700. VOID                RexxSetOkay(UBYTE *String);
  701. VOID                RexxSetScreenMode(UBYTE *String);
  702. VOID                RexxSetFilter(UBYTE *String);
  703. VOID                RexxSetBackspace(UBYTE *String);
  704. VOID                RexxSetCR(UBYTE *String);
  705. VOID                RexxSetLF(UBYTE *String);
  706. VOID                RexxSet80Columns(UBYTE *String);
  707. VOID                RexxSetColourMode(UBYTE *String);
  708. VOID                RexxSetEmulation(UBYTE *String);
  709. VOID                RexxSetStartup(UBYTE *String);
  710. VOID                RexxSetFont(UBYTE *String);
  711. VOID                RexxSetProtocol(UBYTE *String);
  712. VOID                RexxSetProtocolOptions(UBYTE *String);
  713. VOID                RexxSetMacro(UBYTE *String);
  714. VOID                RexxSetColour(UBYTE *String);
  715. VOID                RexxSetScreen(UBYTE *String);
  716. VOID                RexxSetBell(UBYTE *String);
  717. VOID                RexxSetMacroFile(UBYTE *String);
  718. VOID                RexxSetRequesters(UBYTE *String);
  719. VOID                RexxSetTimeout(UBYTE *String);
  720. VOID                RexxSetSerial(UBYTE *String);
  721. VOID                RexxSetModemHangup(UBYTE *String);
  722. VOID                RexxSetAutoCapture(UBYTE *String);
  723. VOID                RexxSetLogActions(UBYTE *String);
  724. VOID                RexxSetBlinking(UBYTE *String);
  725. VOID                RexxSetCursorMode(UBYTE *String);
  726. VOID                RexxSetFontScale(UBYTE *String);
  727. VOID                RexxSetJumpScroll(UBYTE *String);
  728. VOID                RexxSetCharacterWrap(UBYTE *String);
  729. VOID                RexxSetCursorWrap(UBYTE *String);
  730. VOID                RexxSetNewLine(UBYTE *String);
  731. VOID                RexxSetInsert(UBYTE *String);
  732. VOID                RexxSetNumeric(UBYTE *String);
  733. VOID                RexxSetDefaultStore(UBYTE *String);
  734. VOID                RexxSetTUploadPath(UBYTE *String);
  735. VOID                RexxSetTDownloadPath(UBYTE *String);
  736. VOID                RexxSetAUploadPath(UBYTE *String);
  737. VOID                RexxSetADownloadPath(UBYTE *String);
  738. VOID                RexxSetBUploadPath(UBYTE *String);
  739. VOID                RexxSetBDownloadPath(UBYTE *String);
  740. VOID                RexxSetCapturePath(UBYTE *String);
  741. VOID                RexxSetLogFile(UBYTE *String);
  742. VOID                RexxSetEditor(UBYTE *String);
  743.  
  744. UBYTE *                RexxBreak(VOID);
  745. UBYTE *                RexxTUpload(UBYTE *String);
  746. UBYTE *                RexxTDownload(UBYTE *String);
  747. UBYTE *                RexxBDownload(UBYTE *String);
  748. UBYTE *                RexxBUpload(UBYTE *String);
  749. UBYTE *                RexxWrite(UBYTE *String);
  750. UBYTE *                RexxResetStyles(VOID);
  751. UBYTE *                RexxClearScreen(VOID);
  752. UBYTE *                RexxSaveILBM(UBYTE *String);
  753. UBYTE *                RexxHangUp(VOID);
  754. UBYTE *                RexxGetString(UBYTE *String);
  755. UBYTE *                RexxCommand(UBYTE *String);
  756. UBYTE *                RexxMessage(UBYTE *String);
  757. UBYTE *                RexxPutClip(UBYTE *String);
  758. UBYTE *                RexxGetClip(VOID);
  759. UBYTE *                RexxDelay(UBYTE *String);
  760. UBYTE *                RexxDial(UBYTE *String);
  761. UBYTE *                RexxInput(UBYTE *String);
  762. UBYTE *                RexxPrinter(UBYTE *String);
  763. UBYTE *                RexxMacros(UBYTE *String);
  764. UBYTE *                RexxConfig(UBYTE *String);
  765. UBYTE *                RexxPhone(UBYTE *String);
  766. UBYTE *                RexxCapture(UBYTE *String);
  767. UBYTE *                RexxBuffer(UBYTE *String);
  768. UBYTE *                RexxFirstDownload(VOID);
  769. UBYTE *                RexxNextDownload(VOID);
  770. UBYTE *                RexxLastDownload(VOID);
  771. UBYTE *                RexxWaitString(UBYTE *String);
  772. UBYTE *                RexxToneDial(UBYTE *String);
  773.  
  774. VOID                QuietExit(VOID);
  775. VOID                Rexx2Front(VOID);
  776. VOID                Term2Front(VOID);
  777. VOID                Display2Front(VOID);
  778. VOID                CloseDisplay(VOID);
  779.  
  780. BYTE                RexxASyncCommand(struct RexxMsg *RexxMsg,UBYTE *Arg1,UBYTE *Arg2);
  781. VOID                RexxSyncCommand(struct RexxMsg *RexxMsg,UBYTE *Arg1,UBYTE *Arg2);
  782.  
  783. VOID __saveds            RexxServer(VOID);
  784. VOID                HandleRexx(VOID);
  785.  
  786.     /* termSpeech. */
  787.  
  788. VOID                DeleteSpeech(VOID);
  789. BYTE                CreateSpeech(VOID);
  790. VOID                Say(UBYTE *String,...);
  791. VOID                SpeechSetup(VOID);
  792.  
  793.     /* termSub.c */
  794.  
  795. BYTE                OpenSubWindow(VOID);
  796. VOID                CloseSubWindow(VOID);
  797. VOID                AddSubEntry(LONG Entry);
  798. BYTE                RemSubEntry(VOID);
  799. VOID                FreeSubList(VOID);
  800. BYTE                HandleSubWindow(struct Window *PanelWindow);
  801.  
  802.     /* termTransfer.c */
  803.  
  804. VOID                StartXprReceive(BYTE Type);
  805. VOID                StartXprSend(BYTE Type);
  806. BYTE                ASCIISetup(VOID);
  807. VOID                ASCIIShutdown(VOID);
  808.  
  809.     /* termXpr.c */
  810.  
  811. LONG __saveds __asm        xpr_fopen(register __a0 UBYTE *FileName,register __a1 UBYTE *AccessMode);
  812. LONG __saveds __asm        xpr_fclose(register __a0 BPTR File);
  813. LONG __saveds __asm        xpr_fread(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 BPTR File);
  814. LONG __saveds __asm        xpr_fwrite(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 LONG Count,register __a1 BPTR File);
  815. ULONG __saveds __asm        xpr_sread(register __a0 UBYTE *Buffer,register __d0 LONG Size,register __d1 LONG Timeout);
  816. LONG __saveds __asm        xpr_swrite(register __a0 UBYTE *Buffer,register __d0 LONG Size);
  817. LONG __saveds            xpr_sflush(VOID);
  818. LONG __saveds __asm        xpr_update(register __a0 struct XPR_UPDATE *UpdateInfo);
  819. LONG __saveds            xpr_chkabort(VOID);
  820. LONG __saveds __asm        xpr_gets(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer);
  821. LONG __saveds __asm        xpr_setserial(register __d0 LONG Status);
  822. LONG __saveds __asm        xpr_ffirst(register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern);
  823. LONG __saveds __asm        xpr_fnext(register __d0 LONG OldState,register __a0 UBYTE *Buffer,register __a1 UBYTE *Pattern);
  824. LONG __saveds __asm        xpr_finfo(register __a0 UBYTE *FileName,register __d0 LONG InfoType);
  825. LONG __saveds __asm        xpr_fseek(register __a0 BPTR File,register __d0 LONG Offset,register __d1 LONG Origin);
  826. ULONG __saveds __asm        xpr_options(register __d0 LONG NumOpts,register __a0 struct xpr_option **Opts);
  827. LONG __saveds __asm        xpr_unlink(register __a0 UBYTE *FileName);
  828. LONG __saveds            xpr_squery(VOID);
  829. LONG __saveds __asm        xpr_getptr(register __d0 LONG InfoType);
  830. LONG __saveds __asm        xpr_stealopts(register __a0 UBYTE *Prompt,register __a1 UBYTE *Buffer);
  831.  
  832. struct Gadget *            CreateAllGetsGadgets(BYTE LoadGadget,UBYTE *String,UBYTE *Prompt,LONG *WindowWidth,struct Gadget **GadgetArray,struct Gadget **GadgetList,APTR VisualInfo,UWORD TopEdge);
  833.  
  834. BYTE                ProtocolSetup(VOID);
  835. VOID                SaveProtocolOpts(VOID);
  836.  
  837.     /* ToneDial.c */
  838.  
  839. VOID                DeleteTone(VOID);
  840. BYTE                ToneDial(UBYTE *Number);
  841.  
  842.     /* TransferPanel.c */
  843.  
  844. VOID                TransferInfo(SHORT X,SHORT Y,BYTE *String,...);
  845. BYTE                TransferPanel(UBYTE *Title);
  846. VOID                DeleteTransferPanel(VOID);
  847.  
  848.     /* UploadPanel.c */
  849.  
  850. BYTE                UploadPanel(VOID);
  851.  
  852.     /* Format.asm/Res.asm */
  853.  
  854. VOID __stdargs            Printf(UBYTE *,...);
  855. VOID __stdargs            SPrintf(APTR,UBYTE *,...);
  856. VOID __stdargs            VSPrintf(APTR,UBYTE *,va_list);
  857. LONG __stdargs            FPrintf(BPTR,UBYTE *,...);
  858.  
  859. struct MsgPort * __stdargs    Res(UBYTE *,LONG,APTR,LONG,LONG);
  860.  
  861.     /* termData.c */
  862.  
  863. extern struct ExecBase        *SysBase;
  864. extern struct DosLibrary    *DOSBase;
  865.  
  866. extern struct IntuitionBase    *IntuitionBase;
  867. extern struct GfxBase        *GfxBase;
  868. extern struct Library        *GadToolsBase;
  869. extern struct Library        *DiskfontBase;
  870. extern struct Device        *TimerBase;
  871. extern struct Library        *AslBase;
  872. extern struct RxsLib        *RexxSysBase;
  873. extern struct Library        *IFFParseBase;
  874. extern struct Library        *CxBase;
  875. extern struct Library        *LayersBase;
  876.  
  877. extern struct timerequest    *TimeRequest;
  878.  
  879. extern struct IOStdReq        *ConsoleRequest;
  880. extern struct Device        *ConsoleDevice;
  881.  
  882. extern struct Screen        *Screen;
  883. extern struct Window        *Window;
  884. extern struct Window        *StatusWindow;
  885. extern APTR             OldWindowPtr;
  886.  
  887. extern struct ViewPort        *VPort;
  888. extern struct RastPort        *RPort;
  889. extern struct TextFont        *Topaz;
  890. extern struct TextFont        *IBM;
  891. extern struct TextFont        *GFX;
  892. extern APTR             VisualInfo;
  893.  
  894. extern UWORD             ANSIPens[numDrIPens + 1];
  895. extern UWORD             EGAPens[numDrIPens + 1];
  896. extern UWORD             AtomicColours[16];
  897. extern UWORD             EGAColours[16];
  898. extern UWORD             ANSIColours[16];
  899. extern UWORD             DefaultColours[16];
  900. extern UWORD             BlinkColours[16];
  901. extern UWORD             StandardColours[16];
  902.  
  903. extern struct Process        *ThisProcess;
  904. extern struct Process        *RexxProcess;
  905. extern struct MsgPort        *TermRexxPort;
  906. extern struct Task        *StatusTask;
  907. extern struct Process        *BufferProcess;
  908. extern struct WBStartup        *WBenchMsg;
  909. extern BPTR             RemoteCurrentDir;
  910.  
  911. extern struct InputEvent    *FakeInputEvent;
  912.  
  913. extern struct IOExtSer        *ReadRequest;
  914. extern struct IOExtSer        *WriteRequest;
  915. extern struct MsgPort        *ReadPort;
  916. extern APTR             ReadBuffer;
  917.  
  918. extern struct Hotkeys         Hotkeys;
  919. extern struct NewBroker         NewTermBroker;
  920.  
  921. extern struct TextAttr         DefaultFont;
  922. extern struct TextAttr         IBMFont;
  923. extern struct TextAttr         GFXFont;
  924.  
  925. extern UBYTE             AnyChannel[4];
  926.  
  927. extern UBYTE __chip         SineWave[8];
  928.  
  929. extern struct IOAudio        *AudioBlock;
  930.  
  931. extern USHORT __chip         Stopwatch[(2 + 16) * 2];
  932.  
  933. extern BYTE             ValidTab[256];
  934. extern UBYTE             IBMConversion[256];
  935.  
  936. extern struct SpecialKey     SpecialKeys[SPECIALKEYS];
  937. extern UBYTE             SpecialMap[256];
  938.  
  939. extern UBYTE             SharedBuffer[512];
  940.  
  941. extern struct NewMenu         TermMenu[];
  942. extern struct Menu        *Menu;
  943.  
  944. extern struct TermPort        *TermPort;
  945.  
  946. extern struct Configuration     Config;
  947. extern struct Configuration     PrivateConfig;
  948. extern struct SpeechConfig     SpeechConfig;
  949. extern BYTE             Status;
  950. extern BYTE             Online;
  951. extern UWORD             PublicModes;
  952.  
  953. extern UBYTE             LastConfig[256];
  954. extern UBYTE             DefaultPubScreen[MAXPUBSCREENNAME];
  955.  
  956. extern ULONG             ModeID[16];
  957.  
  958. extern BPTR             FileCapture;
  959. extern BPTR             PrinterCapture;
  960. extern UBYTE             CaptureName[256];
  961.  
  962. extern UBYTE            **BufferLines;
  963. extern LONG             Lines;
  964. extern struct SignalSemaphore    *BufferSemaphore;
  965. extern LONG             MaxLines;
  966. extern LONG             BufferSpace;
  967.  
  968. extern struct PhoneEntry    **Phonebook;
  969. extern LONG             PhoneSize;
  970.  
  971. extern LONG             NumPhoneEntries;
  972.  
  973. extern UBYTE             LastPhone[256];
  974. extern UBYTE             LastKeys[256];
  975. extern UBYTE             LastMacros[256];
  976. extern UBYTE             LastSpeech[256];
  977.  
  978. extern struct MacroKeys        *MacroKeys;
  979.  
  980. extern struct List         EmptyList;
  981.  
  982. extern UWORD             LastLine,LastColumn;
  983. extern BYTE             Charset,Attributes,FgPen,BgPen;
  984. extern SHORT             CursorX,CursorY,Top,Bottom;
  985. extern BYTE             UseRegion,InSequence,Quiet;
  986. extern BYTE             TabStops[1024];
  987.  
  988. extern struct CursorData     CursorBackup;
  989.  
  990. extern BYTE             ResetDisplay,Escape;
  991.  
  992. extern UBYTE            *AttentionBuffers[7],AttentionCount[7],FlowCount;
  993. extern BYTE             BaudPending,FullCheck;
  994. extern UBYTE             BaudBuffer[20],BaudCount;
  995.  
  996. extern struct FlowInfo         FlowInfo;
  997.  
  998. extern LONG             FileCount,FileCountMax;
  999. extern struct WBArg        *FileArg;
  1000. extern BYTE             MultipleFiles,FileMatch,BinaryTransfer;
  1001. extern struct AnchorPath    *FileAnchor;
  1002. extern LONG             TransferBits;
  1003.  
  1004. extern struct Window        *TransferWindow;
  1005. extern struct Menu        *TransferMenu;
  1006.  
  1007. extern struct Library        *XProtocolBase;
  1008. extern struct XPR_IO        *XprIO;
  1009.  
  1010. extern UBYTE             ProtocolOptsBuffer[256];
  1011. extern BYTE             NewLibrary,NewOptions,DidTransfer;
  1012. extern UBYTE             LastXprLibrary[60];
  1013. extern BYTE             UsesZModem;
  1014.  
  1015. extern LONG             CurrentPay;
  1016. extern LONG             PayPerUnit[2];
  1017. extern LONG             SecPerUnit[2];
  1018. extern LONG             TimeOfDay[2];
  1019. extern SHORT             PreferredTime;
  1020. extern UBYTE             Password[40];
  1021.  
  1022. extern UBYTE             WindowName[256];
  1023.  
  1024. extern BYTE             WeAreBlocking;
  1025.  
  1026. extern struct List        *SubList;
  1027. extern LONG             SubItemNum;
  1028. extern struct Window        *SubWindow;
  1029. extern LONG             SubListNum;
  1030.  
  1031. extern BYTE             SendStartup;
  1032.  
  1033. extern BYTE             ReleaseSerial;
  1034. extern BYTE             ResetSerial;
  1035. extern BYTE             BatchMode;
  1036.  
  1037. extern UBYTE             LastDownload[256];
  1038. extern UBYTE             LastUpload[256];
  1039.  
  1040. extern struct Hook         CommandHook;
  1041. extern BYTE             DontActivate;
  1042. extern UBYTE             CommandWorkBuffer[256];
  1043. extern struct StringExtend     CommandExtend;
  1044. extern struct Window        *CommandWindow;
  1045. extern struct Gadget        *CommandGadget;
  1046. extern struct Gadget        *ActiveGadget;
  1047.  
  1048. extern struct Window        *PacketWindow;
  1049. extern struct Gadget        *PacketGadgetArray[1];
  1050. extern struct Menu        *PacketMenu;
  1051. extern struct Gadget        *PacketGadgetList;
  1052. extern struct List         PacketHistoryList;
  1053.  
  1054. extern struct NewMenu         GetsMenu[];
  1055.  
  1056. extern BYTE             Initializing,LoadColours;
  1057.  
  1058. extern UBYTE            *Raster;
  1059. extern SHORT             RasterWidth,RasterHeight;
  1060.  
  1061. extern struct SignalSemaphore    *DownloadSemaphore;
  1062. extern struct List         DownloadList;
  1063. extern LONG             DownloadLineCount;
  1064. extern struct Node        *DownloadNode;
  1065.  
  1066. extern struct List         SequenceList;
  1067. extern LONG             SequenceCount;
  1068.  
  1069. extern ULONG             VersionProps[2];
  1070.  
  1071. extern BYTE             ExitQuietly;
  1072.  
  1073. extern struct Window        *RexxWindow;
  1074.  
  1075. extern struct Window        *TopWindow;
  1076. extern struct Window        *WindowStack[5];
  1077. extern SHORT             WindowStackPtr;
  1078.  
  1079. extern LONG             TermID;
  1080. extern UBYTE             TermIDString[20];
  1081.