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