home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / PIBTERM / PIBT41S4.ARC / SETPARMA.MOD < prev    next >
Encoding:
Text File  |  1988-02-23  |  51.3 KB  |  1,508 lines
  1. (*----------------------------------------------------------------------*)
  2. (*        Get_Default_Params --- Set Communications Parameters          *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Get_Default_Params( First_Time : BOOLEAN );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Get_Default_Params                                   *)
  10. (*                                                                      *)
  11. (*     Purpose:    Set communications parameters                        *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Get_Default_Params( First_Time : BOOLEAN );                   *)
  16. (*                                                                      *)
  17. (*           First_Time:  TRUE for initial setup, else FALSE.           *)
  18. (*                                                                      *)
  19. (*     Calls:    Async_Init                                             *)
  20. (*               Async_Open                                             *)
  21. (*               Menu_Get_Choice                                        *)
  22. (*               Menu_Display_Choices                                   *)
  23. (*                                                                      *)
  24. (*      Remarks:                                                        *)
  25. (*                                                                      *)
  26. (*         This routine is called if PIBTERM.CNF doesn't exist,         *)
  27. (*         or to update communications parameters.                      *)
  28. (*                                                                      *)
  29. (*----------------------------------------------------------------------*)
  30.  
  31. CONST
  32.    Quit_Item       = 13;
  33.  
  34. VAR
  35.    Config_File     : Text_File;
  36.  
  37. VAR
  38.    Settings_Menu   : Menu_Type;
  39.    Settings_Choice : INTEGER;
  40.    I               : INTEGER;
  41.    J               : INTEGER;
  42.  
  43. (* STRUCTURED *) CONST
  44.    Colon_Str     : STRING[ 2] = ': ';
  45.    Enter_Str     : STRING[ 6] = 'Enter ';
  46.    Currently_Str : STRING[11] = 'Currently: ';
  47.    Arrow_Str     : STRING[ 5] = ' --> ';
  48.  
  49. TYPE
  50.    PNums_Vector  = ARRAY[1..25] OF INTEGER;
  51.  
  52. VAR
  53.                                    (* Parameter types                    *)
  54.  
  55.    Param_Types : ARRAY[1..25] OF Param_Type;
  56.  
  57.                                    (* Pointers to parameter addresses    *)
  58.  
  59.    Param_IPtrs : ARRAY[1..25] OF Param_IPtr_Type;
  60.    Param_XPtrs : ARRAY[1..25] OF Param_XPtr_Type ABSOLUTE Param_IPtrs;
  61.    Param_SPtrs : ARRAY[1..25] OF Param_SPtr_Type ABSOLUTE Param_IPtrs;
  62.    Param_CPtrs : ARRAY[1..25] OF Param_CPtr_Type ABSOLUTE Param_IPtrs;
  63.    Param_LPtrs : ARRAY[1..25] OF Param_LPtr_Type ABSOLUTE Param_IPtrs;
  64.    Param_BPtrs : ARRAY[1..25] OF Param_BPtr_Type ABSOLUTE Param_IPtrs;
  65.    Param_TPtrs : ARRAY[1..25] OF Param_TPtr_Type ABSOLUTE Param_IPtrs;
  66.    Param_FPtrs : ARRAY[1..25] OF Param_FPtr_Type ABSOLUTE Param_IPtrs;
  67.    Param_DPtrs : ARRAY[1..25] OF Param_DPtr_Type ABSOLUTE Param_IPtrs;
  68.    Param_OPtrs : ARRAY[1..25] OF Param_OPtr_Type ABSOLUTE Param_IPtrs;
  69.    Param_WPtrs : ARRAY[1..25] OF Param_WPtr_Type ABSOLUTE Param_IPtrs;
  70.  
  71.                                    (* Pointers to parameter descriptions *)
  72.  
  73.    Param_Desc  : ARRAY[1..25] OF StringPtr;
  74.  
  75.                                    (* Parameter numbers *)
  76.  
  77.    Param_Nums  : PNums_Vector;
  78.  
  79.    Param_Count : INTEGER           (* Parameter count                    *);
  80.    Param_ValCol: INTEGER           (* Column at which value is displayed *);
  81.    Null_Guy    : INTEGER           (* For null parameter definitions     *);
  82.  
  83. (* STRUCTURED *) CONST
  84.    Int_Param  : Param_Type = Integer_Param;
  85.    PInt_Param : Param_Type = PosInt_Param;
  86.    Wor_Param  : Param_Type = Word_Param;
  87.    Str_Param  : Param_Type = String_Param;
  88.    Chr_Param  : Param_Type = Char_Param;
  89.    Lin_Param  : Param_Type = LongInt_Param;
  90.    Bol_Param  : Param_Type = Boolean_Param;
  91.    Byt_Param  : Param_Type = Byte_Param;
  92.    Pat_Param  : Param_Type = Path_Param;
  93.    Tra_Param  : Param_Type = Transfer_Param;
  94.    Dat_Param  : Param_Type = Date_Param;
  95.    Scr_Param  : Param_Type = ScrOrder_Param;
  96.    Col_Param  : Param_Type = Color_Param;
  97.    BCol_Param : Param_Type = BColor_Param;
  98.    Vid_Param  : Param_Type = VidMode_Param;
  99.    Ter_Param  : Param_Type = Terminal_Param;
  100.    Hex_Param  : Param_Type = Hexi_Param;
  101.    Nul_Param  : Param_Type = Null_Param;
  102.  
  103. (* STRUCTURED *) CONST
  104.    Date_Formats : ARRAY[1..3] OF STRING[8] =
  105.                   ( 'MM/DD/YY', 'YY/MM/DD', 'DD/MM/YY' );
  106.  
  107.    Date_Modes   : ARRAY[1..3] OF Date_Format_Type =
  108.                   (  MDY_Style,  YMD_Style,  DMY_Style );
  109.  
  110. (* STRUCTURED *) CONST
  111.    Lib_Search      : ARRAY[1..4] OF STRING[22] =
  112.                      ( 'Directory then library', 'Library then directory',
  113.                        'Directory only', 'Library only' );
  114.  
  115.    Lib_Search_Mode : ARRAY[1..4] OF Script_Search_Order_Type =
  116.                      ( Dir_Then_Lib, Lib_Then_Dir, Dir_Only, Lib_Only );
  117.  
  118. (* STRUCTURED *) CONST
  119.    Colors : ARRAY[0..15] OF STRING[12] =
  120.             ( 'Black       ', 'Blue        ', 'Green       ',
  121.               'Cyan        ', 'Red         ', 'Magenta     ',
  122.               'Brown       ', 'LightGray   ', 'DarkGray    ',
  123.               'LightBlue   ', 'LightGreen  ', 'LightCyan   ',
  124.               'LightRed    ', 'LightMagenta', 'Yellow      ',
  125.               'White       ' );
  126.  
  127. PROCEDURE Get_General_Setup( Menu_String : AnyStr;
  128.                              Menu_Title  : AnyStr;
  129.                              Post_Proc   : CHAR    );
  130.    FORWARD;
  131.  
  132. FUNCTION Get_Item_Choice : INTEGER;
  133.    FORWARD;
  134.  
  135. PROCEDURE Define_Param_For_Display( PName : Char_2 );
  136.    FORWARD;
  137.  
  138. PROCEDURE File_Post_Processor( Menu_Item : INTEGER );
  139.    FORWARD;
  140.  
  141. PROCEDURE Input_Post_Processor( Menu_Item : INTEGER );
  142.    FORWARD;
  143.  
  144. PROCEDURE Kermit_Post_Processor( Menu_Item : INTEGER );
  145.    FORWARD;
  146.  
  147. PROCEDURE Modem_Post_Processor( Menu_Item : INTEGER );
  148.    FORWARD;
  149.  
  150. (*----------------------------------------------------------------------*)
  151. (*                 Get_A_Color --- Get a color variable                 *)
  152. (*----------------------------------------------------------------------*)
  153.  
  154. PROCEDURE Get_A_Color(      Color_Title   : AnyStr;
  155.                             Default_Color : INTEGER;
  156.                             Short_Menu    : BOOLEAN;
  157.                         VAR The_Color     : INTEGER );
  158.  
  159. VAR
  160.    Color_Menu  : Menu_Type;
  161.    I           : INTEGER;
  162.    J           : INTEGER;
  163.    Block_Chars : STRING[5];
  164.    Menu_Size   : INTEGER;
  165.  
  166. BEGIN (* Get_A_Color *)
  167.                                    (* Set up color menu *)
  168.    IF Short_Menu THEN
  169.       Menu_Size := 8
  170.    ELSE
  171.       Menu_Size := 16;
  172.  
  173.    INC( Default_Color );
  174.    IF ( Default_Color > Menu_Size ) THEN
  175.       Default_Color := 1;
  176.  
  177.    Make_A_Menu( Color_Menu, Menu_Size, 6, 50, 29, 0,
  178.                 Default_Color,
  179.                 Color_Title,
  180.                 'Black;Blue;Green;Cyan;Red;Magenta;Brown;LightGray;' +
  181.                 'DarkGray;LightBlue;LightGreen;LightCyan;LightRed;'  +
  182.                 'LightMagenta;Yellow;White;',
  183.                 TRUE );
  184.  
  185.    Menu_Display_Choices( Color_Menu );
  186.  
  187.    Block_Chars := DUPL( CHR( 219 ) , 5 );
  188.  
  189.    FOR J := 0 TO PRED( Menu_Size ) DO
  190.       WriteSXY( Block_Chars, 72, ( J + 6 ), J );
  191.  
  192.    I := Menu_Get_Choice( Color_Menu, TRUE );
  193.  
  194.                                    (* If selected color legitimate, *)
  195.                                    (* return it.                    *)
  196.    IF ( I > 0 ) THEN
  197.       The_Color := PRED( I );
  198.  
  199. END   (* Get_A_Color *);
  200.  
  201. (*----------------------------------------------------------------------*)
  202. (*                Get_Video_Mode --- Get video mode                     *)
  203. (*----------------------------------------------------------------------*)
  204.  
  205. PROCEDURE Get_Video_Mode;
  206.  
  207. VAR
  208.    Video_Menu   : Menu_Type;
  209.    I            : INTEGER;
  210.    J            : INTEGER;
  211.    Default      : INTEGER;
  212.  
  213. BEGIN (* Get_Video_Mode *)
  214.                                    (* Get video mode *)
  215.    CASE Text_Mode OF
  216.       Mono : Default := 1;
  217.       BW80 : Default := 2;
  218.       ELSE   Default := 3;
  219.    END (* CASE *);
  220.                                    (* Display menu and get choice *)
  221.  
  222.    Make_And_Display_Menu( Video_Menu, 3, 10, 54, 0, 0, Default,
  223.                           'Choose Text Mode: ',
  224.                           'Monochrome;Black and White;Color;',
  225.                           FALSE, TRUE, I );
  226.  
  227.    CASE I OF
  228.       1:   New_Text_Mode := Mono;
  229.       2:   New_Text_Mode := BW80;
  230.       3:   New_Text_Mode := C80;
  231.       ELSE New_Text_Mode := Text_Mode;
  232.    END (* CASE *);
  233.                                    (* Monochrome -- all colors *)
  234.                                    (* become black and white   *)
  235.    IF ( ( New_Text_Mode = BW80 ) OR
  236.         ( New_Text_Mode = Mono ) ) THEN
  237.       BEGIN
  238.  
  239.          New_ForeGround_Color   := White;
  240.          New_BackGround_Color   := Black;
  241.          New_Menu_Text_Color    := White;
  242.          New_Menu_Text_Color_2  := White;
  243.          New_Menu_Frame_Color   := White;
  244.          New_Border_Color       := Black;
  245.  
  246.          VT100_ForeGround_Color := LightGray;
  247.          VT100_BackGround_Color := Black;
  248.          VT100_Border_Color     := Black;
  249.          VT100_Underline_Color  := Blue;
  250.          VT100_Bold_Color       := White;
  251.  
  252.       END;
  253.  
  254. END   (* Get_Video_Mode *);
  255.  
  256. (*----------------------------------------------------------------------*)
  257. (*        Get_Terminal_Type --- Get Type of Terminal to Emulate         *)
  258. (*----------------------------------------------------------------------*)
  259.  
  260. PROCEDURE Get_Terminal_Type;
  261.  
  262. VAR
  263.    Emul_Menu   : Menu_Type;
  264.    I           : INTEGER;
  265.    J           : INTEGER;
  266.    Default     : INTEGER;
  267.    Gossip_Str  : STRING[20];
  268.  
  269. BEGIN (* Get_Terminal_Type *)
  270.                                    (* Get current terminal type *)
  271.  
  272.    Default := SUCC( ORD( Terminal_To_Emulate ) );
  273.  
  274.    IF Gossip_Mode_On THEN
  275.       Gossip_Str := 'Turn OFF Gossip mode'
  276.    ELSE
  277.       Gossip_Str := 'Turn ON Gossip mode';
  278.  
  279.                                    (* Construct menu *)
  280.  
  281.    Make_And_Display_Menu( Emul_Menu, NumberTerminalTypes + 1, 8, 54, 0, 0,
  282.                           Default,
  283.                           'Terminal to Emulate: ',
  284.                           'Dumb;VT52;ANSI;VT100;' + Gossip_Str + ';Host Mode;' +
  285.                           'Tektronix 4010;ADM3a;ADM5;TV925;User1;User2;User3;' +
  286.                           'User4;User5;',
  287.                           TRUE, TRUE, I );
  288.  
  289.    IF ( I > 0 ) THEN
  290.       BEGIN
  291.  
  292.          IF ( I = 5 ) THEN
  293.             IF ( NOT Gossip_Mode_On ) THEN
  294.                BEGIN
  295.                   Saved_Gossip_Term   := Terminal_To_Emulate;
  296.                   Terminal_To_Emulate := Gossip;
  297.                   Gossip_Mode_On      := TRUE;
  298.                END
  299.             ELSE
  300.                BEGIN
  301.                   Terminal_To_Emulate := Saved_Gossip_Term;
  302.                   Gossip_Mode_On      := FALSE;
  303.                END
  304.          ELSE
  305.             Terminal_To_Emulate := Terminal_Type_List[ PRED( I ) ];
  306.  
  307.       END;
  308.  
  309. END   (* Get_Terminal_Type *);
  310.  
  311. (*----------------------------------------------------------------------*)
  312. (*     Get_Kermit_Checksum_Type --- Get Type of Checksum for Kermit     *)
  313. (*----------------------------------------------------------------------*)
  314.  
  315. PROCEDURE Get_Kermit_Checksum_Type;
  316.  
  317. VAR
  318.    Kermit_Chk_Menu : Menu_Type;
  319.    I               : INTEGER;
  320.  
  321. BEGIN (* Get_Kermit_Checksum_Type *)
  322.  
  323.    Make_And_Display_Menu( Kermit_Chk_Menu, 3, 10, 54, 0, 0,
  324.                           ( ORD( Kermit_Chk_Type ) - ORD( '0' ) ),
  325.                           'Block check type: ',
  326.                           '1 character checksum;2 character checksum;' +
  327.                           '3 character CRC',
  328.                           FALSE, TRUE, I );
  329.  
  330.    IF ( I > 0 ) THEN
  331.       Kermit_Chk_Type := CHR( I + ORD('0') );
  332.  
  333. END   (* Get_Kermit_Checksum_Type *);
  334.  
  335. (*----------------------------------------------------------------------*)
  336. (*          Get_Date_Type --- Get Type of Date Format for Display       *)
  337. (*----------------------------------------------------------------------*)
  338.  
  339. PROCEDURE Get_Date_Type;
  340.  
  341. VAR
  342.    L2        : INTEGER;
  343.    L         : INTEGER;
  344.    Date_Menu : Menu_Type;
  345.  
  346. BEGIN (* Get_Date_Type *)
  347.  
  348.    L2 := SUCC( ORD( Date_Format ) );
  349.  
  350.    Make_And_Display_Menu( Date_Menu, 4, 10, 54, 0, 0, L2,
  351.                           'Date Format: ',
  352.                           Date_Formats[1] + ';' +
  353.                           Date_Formats[2] + ';' +
  354.                           Date_Formats[3] + ';QUIT',
  355.                           TRUE, TRUE, L );
  356.  
  357.    IF ( L > 0 ) AND ( L < 4 ) THEN
  358.       BEGIN
  359.          Date_Format        := Date_Modes[ L ];
  360.          Date_Format_String := Date_Formats[ L ];
  361.       END;
  362.  
  363. END   (* Get_Date_Type *);
  364.  
  365. (*----------------------------------------------------------------------*)
  366. (*          Get_Script_Order --- Get order to search for scripts        *)
  367. (*----------------------------------------------------------------------*)
  368.  
  369. PROCEDURE Get_Script_Order;
  370.  
  371. VAR
  372.    L2         : INTEGER;
  373.    L          : INTEGER;
  374.    Order_Menu : Menu_Type;
  375.  
  376. BEGIN (* Get_Script_Order *)
  377.  
  378.    L2 := SUCC( ORD( Script_Search_Order ) );
  379.  
  380.    Make_And_Display_Menu( Order_Menu, 5, 10, 54, 0, 0,
  381.                           L2,
  382.                           'Script search order: ',
  383.                           Lib_Search[1] + ';' +
  384.                           Lib_Search[2] + ';' +
  385.                           Lib_Search[3] + ';' +
  386.                           Lib_Search[4] + ';QUIT;',
  387.                           FALSE, TRUE, L );
  388.  
  389.    IF ( L > 0 ) AND ( L < 5 ) THEN
  390.       BEGIN
  391.          Script_Search_Order := Lib_Search_Mode[ L ];
  392.          Script_Order_String := Lib_Search     [ L ];
  393.       END;
  394.  
  395. END   (* Get_Script_Order *);
  396.  
  397. (*----------------------------------------------------------------------*)
  398. (*         Get_VT100_Setup   ---  Get VT100 setup                       *)
  399. (*----------------------------------------------------------------------*)
  400.  
  401. PROCEDURE Get_VT100_Setup;
  402.  
  403. BEGIN (* Get_VT100_Setup *)
  404.  
  405.    (* VF = VT100_Foreground_Color   *)
  406.    (* VB = VT100_Background_Color   *)
  407.    (* VS = VT100_Border_Color       *)
  408.    (* VE = VT100_Bold_Color         *)
  409.    (* VU = VT100_Underline_Color    *)
  410.    (* VA = VT100_Answerback_Message *)
  411.    (* VC = Auto_Change_Arrows       *)
  412.    (* VK = KeyPad_Appl_On_File      *)
  413.    (* VN = KeyPad_Appl_Off_File     *)
  414.  
  415.    Get_General_Setup( 'VF VB VS VE VU VA VC VK VN ',
  416.                       'VT100 settings', ' ' );
  417.  
  418. END   (* Get_VT100_Setup *);
  419.  
  420. (*----------------------------------------------------------------------*)
  421. (*                 Get_A_Key --- Get a function key and name            *)
  422. (*----------------------------------------------------------------------*)
  423.  
  424. PROCEDURE Get_A_Key( VAR Key_No     : INTEGER;
  425.                      VAR Key_Name   : AnyStr   );
  426.  
  427. VAR
  428.    Ch        : CHAR;
  429.    OK_KeyHit : BOOLEAN;
  430.    Defs_Done : BOOLEAN;
  431.    AKey_No   : INTEGER;
  432.    Key_Type  : INTEGER;
  433.    AKey_Name : STRING[20];
  434.    S_Val     : STRING[10];
  435.    SKey_Name : STRING[4];
  436.    I         : INTEGER;
  437.  
  438. BEGIN (* Get_Command_Key *)
  439.  
  440.    OK_KeyHit := FALSE;
  441.    Defs_Done := FALSE;
  442.  
  443.    REPEAT
  444.  
  445.       GoToXY( 2 , Param_Count + 3 );
  446.  
  447.       IF ( Command_Key_Name = '' ) THEN
  448.          AKey_Name := 'None'
  449.       ELSE
  450.          AKey_Name := Command_Key_Name;
  451.  
  452.       WRITE(' Hit key for invoking command mode (currently ',
  453.             AKey_Name, ') >>');
  454.       ClrEol;
  455.                                    (* Pick up blank, ESC, or function key sequence *)
  456.       Read_Kbd( Ch );
  457.  
  458.       IF ( Ch = ' ' ) THEN
  459.          BEGIN
  460.             Key_No   := 0;
  461.             Key_Name := '';
  462.             EXIT;
  463.          END
  464.       ELSE IF ( Ch <> CHR( ESC ) ) THEN
  465.          OK_KeyHit := FALSE
  466.       ELSE
  467.          IF ( NOT PibTerm_KeyPressed ) THEN
  468.             BEGIN
  469.                Defs_Done := TRUE;
  470.                OK_KeyHit := TRUE;
  471.             END
  472.          ELSE
  473.             BEGIN
  474.                Read_Kbd( Ch );
  475.                AKey_No   := ORD( Ch );
  476.                OK_KeyHit := ( PibTerm_Command_Table[ AKey_No ] = KeySendSy );
  477.             END;
  478.                                    (* Not just plain escape -- must be *)
  479.                                    (* function key.                    *)
  480.       IF ( NOT OK_KeyHit ) THEN
  481.          BEGIN
  482.             WRITE(' *** Not a valid key');
  483.             ClrEol;
  484.             Window_Delay;
  485.          END
  486.       ELSE                         (* Get key name *)
  487.  
  488.          IF ( NOT Defs_Done ) THEN
  489.             BEGIN
  490.  
  491.                Key_No   := AKey_No;
  492.                Get_Long_Key_Name( Key_Definitions[Key_No].Name , Key_Name );
  493.  
  494.                WRITE( Key_Name );
  495.                ClrEol;
  496.  
  497.                Window_Delay;
  498.  
  499.             END;
  500.  
  501.    UNTIL ( OK_KeyHit OR Defs_Done );
  502.  
  503. END   (* Get_A_Key *);
  504.  
  505. (*----------------------------------------------------------------------*)
  506. (*         Get_Ascii_Parameters --- Get parameters for ascii transfers  *)
  507. (*----------------------------------------------------------------------*)
  508.  
  509. PROCEDURE Get_Ascii_Parameters;
  510.  
  511. BEGIN (* Get_Ascii_Parameters *)
  512.                                    (* Fake this parameter as boolean *)
  513.  
  514.    Ascii_CRLF := ( Ascii_CR_LF_String <> CHR( CR ) );
  515.  
  516.    (* AC = Ascii_Char_Delay  *)
  517.    (* AL = Ascii_Line_Delay  *)
  518.    (* AP = Ascii_Pacing_Char *)
  519.    (* AX = Ascii_Send_Asis   *)
  520.    (* AS = Ascii_Line_Size   *)
  521.    (* AE = Ascii_CRLF        *)
  522.    (* AF = Ascii_Send_Blank  *)
  523.    (* AZ = Ascii_Use_CtrlZ   *)
  524.    (* AD = Ascii_Show_Text   *)
  525.    (* AT = Ascii_Translate   *)
  526.  
  527.    Get_General_Setup( 'AC AL AP AX AS 10 AF AZ AD AT ',
  528.                       'Ascii transfer settings', ' ' );
  529.  
  530.    Ascii_Line_Size := MAX( MIN( Ascii_Line_Size , 255 ) , 1 );
  531.  
  532.    IF ( NOT Ascii_CRLF ) THEN
  533.       Ascii_CR_LF_String := CHR( CR )
  534.    ELSE
  535.       Ascii_CR_LF_String := CHR( CR ) + CHR( LF );
  536.  
  537. END   (* Get_Ascii_Parameters *);
  538.  
  539. (*----------------------------------------------------------------------*)
  540. (*      Get_Xmodem_Parameters --- Get parameters for xmodem transfers   *)
  541. (*----------------------------------------------------------------------*)
  542.  
  543. PROCEDURE Get_Xmodem_Parameters;
  544.  
  545. BEGIN (* Get_Xmodem_Parameters *)
  546.  
  547.    (*  XC = Xmodem_Char_Wait   *)
  548.    (*  XH = Xmodem_Block_Wait  *)
  549.    (*  XA = Xmodem_Ack_Wait    *)
  550.    (*  XT = Xmodem_Max_Errors  *)
  551.    (*  GD = GMT_Difference     *)
  552.    (*  DY = Downsize_Ymodem    *)
  553.    (*  Y0 = Use_Ymodem_Header  *)
  554.    (*  U0 = Use_Block_Zero     *)
  555.    (*  YX = Honor_Xoff_Ymodem  *)
  556.    (*  YF = Use_Full_Path_Name *)
  557.  
  558.    Get_General_Setup( 'XC XH XA XT GD DY Y0 U0 YX YF ',
  559.                       'Xmodem/Ymodem transfer settings', ' ' );
  560.  
  561. END   (* Get_Xmodem_Parameters *);
  562.  
  563. (*----------------------------------------------------------------------*)
  564. (*      Save_Params --- Save current parameter vector definitions       *)
  565. (*----------------------------------------------------------------------*)
  566.  
  567. PROCEDURE Save_Params( VAR Save_P_Count : INTEGER;
  568.                        VAR Save_PNums   : PNums_Vector );
  569.  
  570. VAR
  571.    I : INTEGER;
  572.  
  573. BEGIN (* Save_Params *)
  574.  
  575.    Save_P_Count  := Param_Count;
  576.  
  577.    IF ( Save_P_Count > 0 ) THEN
  578.       FOR I := 1 TO Save_P_Count DO
  579.          Save_PNums[ I ] := Param_Nums[ I ];
  580.  
  581. END   (* Save_Params *);
  582.  
  583. (*----------------------------------------------------------------------*)
  584. (*      Restore_Params --- Restore saved parameter vector definitions   *)
  585. (*----------------------------------------------------------------------*)
  586.  
  587. PROCEDURE Restore_Params( VAR Save_P_Count : INTEGER;
  588.                           VAR Save_PNums   : PNums_Vector );
  589.  
  590. VAR
  591.    I    : INTEGER;
  592.    PNum : INTEGER;
  593.  
  594. BEGIN (* Restore_Params *)
  595.  
  596.    IF ( Save_P_Count > 0 ) THEN
  597.       BEGIN
  598.          Param_Count  := 0;
  599.          Param_ValCol := 0;
  600.          FOR I := 1 TO Save_P_Count DO
  601.             BEGIN
  602.                PNum := Save_PNums[ I ];
  603.                Define_Param_For_Display( Parameters[PNum].PName );
  604.                Param_Nums[ I ] := PNum;
  605.             END;
  606.          Param_ValCol := Param_ValCol + 6;
  607.       END;
  608.  
  609. END   (* Restore_Params *);
  610.  
  611. (*----------------------------------------------------------------------*)
  612. (*      Get_External_Protocols --- Get parms for external protocols     *)
  613. (*----------------------------------------------------------------------*)
  614.  
  615. PROCEDURE Get_External_Protocols;
  616.  
  617. VAR
  618.    Local_Save : Saved_Screen_Ptr;
  619.    I          : INTEGER;
  620.    T          : Transfer_Type;
  621.    BatchF     : STRING[3];
  622.    SName      : String12;
  623.    RName      : String12;
  624.    Prot_Menu  : Menu_Type;
  625.    Prot_Item  : INTEGER;
  626.    IProt      : INTEGER;
  627.    First_Prot : INTEGER;
  628.    Default    : INTEGER;
  629.    Save_PCount: INTEGER;
  630.    Save_PNums : PNums_Vector;
  631.  
  632. (*----------------------------------------------------------------------*)
  633.  
  634. PROCEDURE Display_One_Protocol( I : INTEGER );
  635.  
  636. VAR
  637.    T          : Transfer_Type;
  638.    SName      : String12;
  639.    RName      : String12;
  640.    HostOK     : STRING[3];
  641.    ProtI      : INTEGER;
  642.    TName      : String12;
  643.    BatchL     : CHAR;
  644.    HostL      : CHAR;
  645.  
  646. BEGIN (* Display_One_Protocol *)
  647.  
  648.    GoToXY( 1 , ( I - First_Prot ) + 4 );
  649.  
  650.    T     := Transfers[SUCC(I)];
  651.    ProtI := SUCC( I - First_Prot );
  652.  
  653.    SName := Send_Script_Names[T];
  654.    RName := Receive_Script_Names[T];
  655.  
  656.    IF Single_File_Protocol[T] THEN
  657.       BEGIN
  658.          BatchF := 'NO ';
  659.          BatchL := 'S';
  660.       END
  661.    ELSE
  662.       BEGIN
  663.          BatchF := 'YES';
  664.          BatchL := 'B';
  665.       END;
  666.  
  667.    IF Trans_OK_In_Host[T] THEN
  668.       BEGIN
  669.          HostOK := 'YES';
  670.          HostL  := 'H';
  671.       END
  672.    ELSE
  673.       BEGIN
  674.          HostOK := 'NO ';
  675.          HostL  := 'T';
  676.       END;
  677.  
  678.    WRITE( ' ', CHR( ORD('a') + ( I - First_Prot ) ) );
  679.  
  680.    TextColor( Menu_Text_Color_2);
  681.  
  682.    WRITE( ')');
  683.  
  684.    TextColor( Menu_Text_Color );
  685.  
  686.    IF ( TRIM( Transfer_Name_List[SUCC(I)] ) <> '' ) THEN
  687.       BEGIN
  688.          TName := LTrim( Transfer_Name_List[SUCC(I)] );
  689.          External_Trans_Def[ProtI] := Trans_Type_Name[T]  +
  690.                                       ' '                 +
  691.                                       TName               +
  692.                                       ' '                 +
  693.                                       BatchL              +
  694.                                       ' '                 +
  695.                                       HostL               +
  696.                                       ' '                 +
  697.                                       RName               +
  698.                                       ' '                 +
  699.                                       SName;
  700.          WRITE( Transfer_Name_List[SUCC(I)]:13,
  701.                 '    ',
  702.                 Trans_Type_Name[T] ,
  703.                 '        ' );
  704.          IF ( Trans_Type_Name[T] <> '  ' ) THEN
  705.             WRITE( BatchF, '         ',
  706.                    HostOK, '     ',
  707.                    RName:12, '   ',
  708.                    SName:12 )
  709.        END
  710.    ELSE
  711.       BEGIN
  712.          WRITE( '** Unused **':13 );
  713.          External_Trans_Def[ProtI] := '';
  714.       END;
  715.  
  716.    ClrEol;
  717.  
  718. END   (* Display_One_Protocol *);
  719.  
  720. (*----------------------------------------------------------------------*)
  721.  
  722. PROCEDURE Revise_Protocol_String(     Desc    : AnyStr;
  723.                                   VAR NewSVal : String12 );
  724.  
  725. VAR
  726.    SVal : AnyStr;
  727.    I    : INTEGER;
  728.  
  729. BEGIN (* Revise_Protocol_String *)
  730.  
  731.    GoToXY( 2 , Param_Count + 3 );
  732.    ClrEol;
  733.  
  734.    TextColor( Menu_Text_Color_2 );
  735.  
  736.    WRITELN( Desc );
  737.    WRITE  ( Arrow_Str );
  738.  
  739.    TextColor( Menu_Text_Color );
  740.  
  741.    SVal := NewSVal;
  742.  
  743.    Read_Edited_String( SVal );
  744.  
  745.    IF ( SVal <> CHR( ESC ) ) THEN
  746.       NewSVal := SVal;
  747.  
  748.    FOR I := ( Param_Count + 3 ) TO ( Param_Count + 7 ) DO
  749.       BEGIN
  750.          GoToXY( 1 , I );
  751.          ClrEol;
  752.       END;
  753.  
  754. END   (* Revise_Protocol_String *);
  755.  
  756. (*----------------------------------------------------------------------*)
  757.  
  758. BEGIN (* Get_External_Protocols *)
  759.                                    (* Save current definitions *)
  760.  
  761.    Save_Params( Save_PCount , Save_PNums );
  762.  
  763.                                    (* Draw frame around screen *)
  764.  
  765.    Draw_Titled_Box( Local_Save, 1, 1, 80, 24,
  766.                     'External transfer protocol definitions' );
  767.  
  768.    TextColor( Menu_Text_Color_2 );
  769.  
  770.    WRITELN;
  771.    WRITELN('   Protocol Name  Abbrev.  Batch Mode  Host Mode  Receive Script  Send Script');
  772.    WRITELN;
  773.  
  774.    TextColor( Menu_Text_Color );
  775.  
  776.    Param_Count := 2;
  777.    First_Prot  := ORD( PUser1 );
  778.  
  779.    FOR I := First_Prot TO ORD( PUser10 ) DO
  780.       BEGIN
  781.          Display_One_Protocol( I );
  782.          INC( Param_Count );
  783.       END;
  784.  
  785.    WRITELN;
  786.                                    (* Get entries to change *)
  787.    IProt := Get_Item_Choice;
  788.  
  789.    WHILE( IProt > 0 ) DO
  790.       BEGIN
  791.  
  792.          IProt   := IProt + First_Prot;
  793.          Default := 1;
  794.  
  795.          REPEAT
  796.  
  797.             Make_And_Display_Menu( Prot_Menu, 7, 17, 30, 0, 0, Default,
  798.                                    'Revise Protocol: ',
  799.                                    'P)rotocol name;A)bbreviation;B)atch mode;' +
  800.                                    'H)ost mode allowed;R)eceive script;S)end script;Q)uit;',
  801.                                    FALSE, TRUE, Prot_Item );
  802.  
  803.             TextColor     ( Menu_Text_Color );
  804.             TextBackGround( Black );
  805.  
  806.             T := Transfers[IProt];
  807.  
  808.             CASE Prot_Item OF
  809.  
  810.                1: BEGIN
  811.                      SName := Transfer_Name_List[IProt];
  812.                      IF ( TRIM( SName ) <> '' ) THEN
  813.                         SName := LTRIM( SName );
  814.                      Revise_Protocol_String( 'Protocol name:' , SName );
  815.                      SName := LTRIM( TRIM( SName ) );
  816.                      CopyS2AR( SName, RName[1], 12 );
  817.                      RName[0] := CHR( 12 );
  818.                      Transfer_Name_List[IProt] := RName;
  819.                   END;
  820.  
  821.                2: BEGIN
  822.                      SName := Trans_Type_Name[T];
  823.                      Revise_Protocol_String( 'Abbreviation:' , SName );
  824.                      SName := UpperCase( SName + '  ' );
  825.                      Trans_Type_Name[T][1] := SName[1];
  826.                      Trans_Type_Name[T][2] := SName[2];
  827.                      IF ( Trans_Type_Name[T] <> '  ' ) THEN
  828.                         IF ( ( Trans_Type_Name[T][1] = ' ' ) OR
  829.                              ( Trans_Type_Name[T][2] = ' ' ) ) THEN
  830.                            BEGIN
  831.                               Trans_Type_Name[T] := '  ';
  832.                               Menu_Beep;
  833.                            END;
  834.                   END;
  835.  
  836.                3: BEGIN
  837.                      GoToXY( 3 , Param_Count + 2 );
  838.                      Single_File_Protocol[ T ] := NOT YesNo(' Batch mode protocol (Y/N)? ');
  839.                      GoToXY( 1 , Param_Count + 3 );
  840.                      ClrEol;
  841.                      GoToXY( 1 , Param_Count + 4 );
  842.                      ClrEol;
  843.                   END;
  844.  
  845.                4: BEGIN
  846.                      GoToXY( 3 , Param_Count + 2 );
  847.                      Trans_OK_In_Host[ T ] := YesNo(' Allow this protocol in host mode (Y/N)? ');
  848.                      GoToXY( 1 , Param_Count + 3 );
  849.                      ClrEol;
  850.                      GoToXY( 1 , Param_Count + 4 );
  851.                      ClrEol;
  852.                   END;
  853.  
  854.                5: BEGIN
  855.                      SName := Receive_Script_Names[T];
  856.                      IF ( TRIM( SName ) <> '' ) THEN
  857.                         SName := LTrim( SName );
  858.                      Revise_Protocol_String( 'Script name for receiving files:' , SName );
  859.                      SName := UpperCase( LTrim( Trim( SName ) ) );
  860.                      I := POS( '.BAT' , SName );
  861.                      IF ( I = 0 ) THEN
  862.                         IF ( LENGTH( SName ) > 8 ) THEN
  863.                            SName := COPY( SName, 1, 8 )
  864.                         ELSE
  865.                      ELSE
  866.                         SName := COPY( SName, 1, MIN( 8 , PRED( I ) ) ) + '.BAT';
  867.                      Receive_Script_Names[T] := SName;
  868.                   END;
  869.  
  870.                6: BEGIN
  871.                      SName := Send_Script_Names[T];
  872.                      IF ( TRIM( SName ) <> '' ) THEN
  873.                         SName := LTrim( SName );
  874.                      Revise_Protocol_String( 'Script name for sending files:' , SName );
  875.                      SName := UpperCase( LTrim( Trim( SName ) ) );
  876.                      I := POS( '.BAT' , SName );
  877.                      IF ( I = 0 ) THEN
  878.                         IF ( LENGTH( SName ) > 8 ) THEN
  879.                            SName := COPY( SName, 1, 8 )
  880.                         ELSE
  881.                      ELSE
  882.                         SName := COPY( SName, 1, MIN( 8 , PRED( I ) ) ) + '.BAT';
  883.                      Send_Script_Names[T] := SName;
  884.                   END;
  885.  
  886.                ELSE
  887.                   Prot_Item := -3;
  888.  
  889.             END (* CASE *);
  890.  
  891.             Default := SUCC( Prot_Item );
  892.             IF ( ( Default > 7 ) OR ( Default < 1 ) ) THEN
  893.                Default := 1;
  894.  
  895.             IF ( Prot_Item > 0 ) THEN
  896.                Display_One_Protocol( PRED( IProt ) );
  897.  
  898.          UNTIL ( Prot_Item <= 0 );
  899.  
  900.          IProt := Get_Item_Choice;
  901.  
  902.       END;
  903.                                    (* Restore previous screen *)
  904.    Restore_Screen( Local_Save );
  905.                                    (* Restore previous definitions *)
  906.  
  907.    Restore_Params( Save_PCount , Save_PNums );
  908.  
  909. END   (* Get_External_Protocols *);
  910.  
  911. (*----------------------------------------------------------------------*)
  912. (*        Define_Param_For_Display --- Define parameter for display     *)
  913. (*----------------------------------------------------------------------*)
  914.  
  915. PROCEDURE Define_Param_For_Display( PName : Char_2 );
  916.  
  917. (*----------------------------------------------------------------------*)
  918. (*                                                                      *)
  919. (*     Procedure:  Define_Param_For_Display                             *)
  920. (*                                                                      *)
  921. (*     Purpose:    Define parameter for display/update                  *)
  922. (*                                                                      *)
  923. (*     Calling Sequence:                                                *)
  924. (*                                                                      *)
  925. (*        Define_Param_For_Display( PName : Char_2 );                   *)
  926. (*                                                                      *)
  927. (*           PName --- Name of parameter to be defined                  *)
  928. (*                                                                      *)
  929. (*----------------------------------------------------------------------*)
  930.  
  931. VAR
  932.    P_Num : INTEGER;
  933.  
  934. BEGIN (* Define_Param_For_Display *)
  935.  
  936.                                    (* Increment parameter count *)
  937.    INC( Param_Count );
  938.                                    (* Insert information on this parameter *)
  939.  
  940.    P_Num := Look_Up_Parameter( PName );
  941.  
  942.    WITH Parameters[P_Num] DO
  943.       BEGIN
  944.          Param_Types[Param_Count] := PType;
  945.          Param_IPtrs[Param_Count] := PAddr;
  946.          Param_Desc [Param_Count] := PDesc;
  947.          Param_Nums [Param_Count] := P_Num;
  948.       END;
  949.                                    (* Remember longest description length *)
  950.  
  951.    Param_ValCol := MAX( Param_ValCol ,
  952.                         LENGTH( Param_Desc[Param_Count]^ ) );
  953.  
  954. END   (* Define_Param_For_Display *);
  955.  
  956. (*----------------------------------------------------------------------*)
  957. (*  Display_Parameter --- Display description and value of a parameter  *)
  958. (*----------------------------------------------------------------------*)
  959.  
  960. PROCEDURE Display_Parameter( IParam: INTEGER );
  961.  
  962. (*----------------------------------------------------------------------*)
  963. (*                                                                      *)
  964. (*     Procedure:  Display_Parameter                                    *)
  965. (*                                                                      *)
  966. (*     Purpose:    Display description/value of a parameter             *)
  967. (*                                                                      *)
  968. (*     Calling Sequence:                                                *)
  969. (*                                                                      *)
  970. (*        Display_Parameter( IParam : INTEGER );                        *)
  971. (*                                                                      *)
  972. (*           IParam --- which parameter to display                      *)
  973. (*                      (corresponds to offset previously set by        *)
  974. (*                      calling Define_Parameter_For_Display)           *)
  975. (*                                                                      *)
  976. (*----------------------------------------------------------------------*)
  977.  
  978. VAR
  979.    SVal      : STRING[10];
  980.    Disp_Line : INTEGER;
  981.    MaxDLen   : INTEGER;
  982.    SDisply   : AnyStr;
  983.  
  984. BEGIN (* Display_Parameter *)
  985.                                    (* Clear line of current stuff *)
  986.    Disp_Line := SUCC( IParam );
  987.  
  988.    TextColor     ( Menu_Text_Color_2 );
  989.    TextBackGround( Black );
  990.  
  991.    GoToXY( 2 , Disp_Line );
  992.    ClrEol;
  993.                                    (* Display description *)
  994.  
  995.    WRITE( CHR( ORD('a') + PRED( IParam ) ) );
  996.  
  997.    TextColor( Menu_Text_Color  );
  998.  
  999.    WRITE( ') ');
  1000.  
  1001.    TextColor( Menu_Text_Color_2 );
  1002.  
  1003.    WRITE( Param_Desc[IParam]^ );
  1004.                                    (* If null parameter, quit      *)
  1005.  
  1006.    IF ( ( Param_Types[IParam] = Menu_Param ) OR
  1007.         ( Param_Types[IParam] = Null_Param ) ) THEN EXIT;
  1008.  
  1009.                                    (* Move to value display column *)
  1010.  
  1011.    GoToXY( Param_ValCol , Disp_Line );
  1012.  
  1013.                                    (* Figure maximum display length *)
  1014.                                    (* for parameters.               *)
  1015.  
  1016.    MaxDLen := MAX( 1 , PRED( Lower_Right_Column -
  1017.                        ( PRED( Param_ValCol ) + Upper_Left_Column ) ) );
  1018.  
  1019.    WRITE ( ': ');
  1020.    TextColor( Menu_Text_Color );
  1021.  
  1022.                                    (* Display parameter value      *)
  1023.    CASE Param_Types[IParam] OF
  1024.  
  1025.       PosInt_Param,
  1026.       Integer_Param : WRITE( Param_IPtrs[IParam]^ );
  1027.  
  1028.       Word_Param    : WRITE( Param_WPtrs[IParam]^ );
  1029.  
  1030.       Byte_Param    : WRITE( Param_BPtrs[IParam]^ );
  1031.  
  1032.       LongInt_Param : WRITE( Param_XPtrs[IParam]^ );
  1033.  
  1034.       String_Param,
  1035.       Path_Param,
  1036.       FileN_Param,
  1037.       Key_Param     : BEGIN
  1038.                          SDisPly := Write_Ctrls( Param_SPtrs[IParam]^ );
  1039.                          IF ( LENGTH( SDisPly ) > MaxDLen ) THEN
  1040.                             BEGIN
  1041.  
  1042.                                TextColor( Menu_Text_Color_2 );
  1043.                                GoToXY( Param_ValCol , Disp_Line );
  1044.                                WRITE ( '+ ');
  1045.                                TextColor( Menu_Text_Color );
  1046.  
  1047.                                SDisPly := COPY( SDisPly, 1, MaxDLen );
  1048.  
  1049.                             END;
  1050.                          WRITE( SDisPly );
  1051.                       END;
  1052.  
  1053.       SpecChar_Param: BEGIN
  1054.                          SVal := Param_CPtrs[IParam]^;
  1055.                          WRITE( Write_Ctrls( SVal ), ' (Ascii ',ORD( SVal[1] ),
  1056.                                 ')');
  1057.                       END;
  1058.  
  1059.       KCheck_Param,
  1060.       Char_Param    : WRITE( Param_CPtrs[IParam]^, ' (Ascii ',
  1061.                          ORD( Param_CPtrs[IParam]^ ),')');
  1062.  
  1063.       Boolean_Param : IF Param_LPtrs[IParam]^ THEN
  1064.                         WRITE( 'Yes' )
  1065.                       ELSE
  1066.                         WRITE( 'No' );
  1067.  
  1068.       Transfer_Param: WRITE( LTrim( Transfer_Name_List[ ORD( Param_FPtrs[IParam]^ ) + 1 ] ) );
  1069.  
  1070.       Terminal_Param: WRITE( Terminal_Name_List[ ORD( Param_TPtrs[IParam]^ ) ] );
  1071.  
  1072.       Date_Param    : WRITE( Date_Formats[ ORD( Param_DPtrs[IParam]^ ) + 1 ] );
  1073.  
  1074.       ScrOrder_Param: WRITE( Lib_Search[ ORD( Param_OPtrs[IParam]^ ) + 1 ] );
  1075.  
  1076.       BColor_Param,
  1077.       Color_Param   : WRITE( Colors[ Param_IPtrs[IParam]^ ] );
  1078.  
  1079.       VidMode_Param : CASE Param_IPtrs[IParam]^ OF
  1080.                          BW80: WRITE( 'Black and white' );
  1081.                          Mono: WRITE( 'Monochrome' );
  1082.                          ELSE
  1083.                                WRITE( 'Color' );
  1084.                       END (* CASE *);
  1085.  
  1086.       Hexi_Param    : WRITE( Dec_To_Hex( Param_IPtrs[IParam]^ ) );
  1087.  
  1088.       ELSE;
  1089.  
  1090.    END (* CASE *);
  1091.  
  1092.    TextColor( Menu_Text_Color );
  1093.  
  1094. END   (* Display_Parameter *);
  1095.  
  1096. (*----------------------------------------------------------------------*)
  1097. (*            Update_Parameter --- Update value of a parameter          *)
  1098. (*----------------------------------------------------------------------*)
  1099.  
  1100. PROCEDURE Update_Parameter( IParam: INTEGER );
  1101.  
  1102. (*----------------------------------------------------------------------*)
  1103. (*                                                                      *)
  1104. (*     Procedure:  Update_Parameter                                     *)
  1105. (*                                                                      *)
  1106. (*     Purpose:    Update value of a parameter                          *)
  1107. (*                                                                      *)
  1108. (*     Calling Sequence:                                                *)
  1109. (*                                                                      *)
  1110. (*        Update_Parameter( IParam : INTEGER );                         *)
  1111. (*                                                                      *)
  1112. (*           IParam --- which parameter to update                       *)
  1113. (*                      (corresponds to offset previously set by        *)
  1114. (*                      calling Define_Parameter_For_Display)           *)
  1115. (*                                                                      *)
  1116. (*----------------------------------------------------------------------*)
  1117.  
  1118. VAR
  1119.    I     : LongInt;
  1120.    II    : INTEGER;
  1121.    PType : Param_Type;
  1122.    PStr  : AnyStr;
  1123.    PDesc : AnyStr;
  1124.    Y     : INTEGER;
  1125.  
  1126. BEGIN (* Update_Parameter *)
  1127.  
  1128.    PType := Param_Types[IParam];
  1129.    Y     := WhereY;
  1130.  
  1131.    CASE PType OF
  1132.  
  1133.       Boolean_Param : Param_LPtrs[IParam]^ := NOT Param_LPtrs[IParam]^;
  1134.  
  1135.       Color_Param   : Get_A_Color( Param_Desc[IParam]^, Param_IPtrs[IParam]^, FALSE,
  1136.                                    Param_IPtrs[IParam]^ );
  1137.  
  1138.       BColor_Param  : Get_A_Color( Param_Desc[IParam]^, Param_IPtrs[IParam]^, TRUE,
  1139.                                    Param_IPtrs[IParam]^ );
  1140.  
  1141.       VidMode_Param : Get_Video_Mode;
  1142.  
  1143.       Terminal_Param: Get_Terminal_Type;
  1144.  
  1145.       KCheck_Param  : Get_Kermit_Checksum_Type;
  1146.  
  1147.       VT100_Param   : Get_VT100_Setup;
  1148.  
  1149.       Date_Param    : Get_Date_Type;
  1150.  
  1151.       ScrOrder_Param: Get_Script_Order;
  1152.  
  1153.       Key_Param     : Get_A_Key( Command_Key , Command_Key_Name );
  1154.  
  1155.       Ascii_Param   : Get_Ascii_Parameters;
  1156.  
  1157.       Xmodem_Param  : Get_Xmodem_Parameters;
  1158.  
  1159.       ExtTrans_Param: Get_External_Protocols;
  1160.  
  1161.       Transfer_Param: Display_Transfer_Types( 'Transfer protocol: ',
  1162.                                                Default_Transfer_Type,
  1163.                                                FALSE,
  1164.                                                2, 54, 0, 0, 24,
  1165.                                                TRUE,
  1166.                                                Default_Transfer_Type );
  1167.       ELSE
  1168.          BEGIN
  1169.  
  1170.             GoToXY( 2 , MIN( Param_Count + 3 , 21 ) );
  1171.             ClrEol;
  1172.  
  1173.             PDesc    := Param_Desc[IParam]^;
  1174.  
  1175.             IF ( ( PDesc[1] IN ['A'..'Z'] ) AND
  1176.                  ( COPY( PDesc, 1, 5 ) <> 'VT100' ) AND
  1177.                  ( COPY( PDesc, 1, 4 ) <> 'CTTY'  )     ) THEN
  1178.                PDesc[1] := CHR( ORD( PDesc[1] ) + ORD('a') - ORD('A') );
  1179.  
  1180.             TextColor( Menu_Text_Color_2 );
  1181.  
  1182.             WRITE( Enter_Str, PDesc, Colon_Str );
  1183.  
  1184.             TextColor( Menu_Text_Color );
  1185.  
  1186.             CASE PType OF
  1187.  
  1188.                PosInt_Param :  BEGIN
  1189.                                   I := Param_IPtrs[IParam]^;
  1190.                                   IF Read_Number( I, TRUE, I ) THEN
  1191.                                      BEGIN
  1192.                                         IF ( I <= 0 ) THEN
  1193.                                            II := 0
  1194.                                         ELSE IF ( I > 32767 ) THEN
  1195.                                            II := 32767
  1196.                                         ELSE
  1197.                                            II := I;
  1198.                                         Param_IPtrs[IParam]^ := II;
  1199.                                      END;
  1200.                                END;
  1201.  
  1202.                Byte_Param   :  BEGIN
  1203.                                   I := Param_BPtrs[IParam]^;
  1204.                                   IF Read_Number( I, TRUE, I ) THEN
  1205.                                      Param_BPtrs[IParam]^ := I;
  1206.                                END;
  1207.  
  1208.                LongInt_Param:  IF Read_Number( Param_XPtrs[IParam]^,
  1209.                                                TRUE, I ) THEN
  1210.                                   Param_XPtrs[IParam]^ := I;
  1211.  
  1212.                String_Param :  BEGIN
  1213.                                   PStr := Write_Ctrls( Param_SPtrs[IParam]^ );
  1214.                                   WRITELN;
  1215.                                   WRITE( Arrow_Str );
  1216.                                   ClrEol;
  1217.                                   Read_Edited_String( PStr );
  1218.                                   IF ( PStr <> CHR( ESC ) ) THEN
  1219.                                      Param_SPtrs[IParam]^ := Read_Ctrls( PStr );
  1220.                                END;
  1221.  
  1222.                SpecChar_Param: BEGIN
  1223.                                   PStr := Write_Ctrls( Param_CPtrs[IParam]^ );
  1224.                                   WRITELN;
  1225.                                   WRITE( Arrow_Str );
  1226.                                   ClrEol;
  1227.                                   Read_Edited_String( PStr );
  1228.                                   IF ( PStr <> CHR( ESC ) ) THEN
  1229.                                      BEGIN
  1230.                                         PStr := Read_Ctrls( PStr );
  1231.                                         IF( LENGTH( PStr ) > 0 ) THEN
  1232.                                            Param_CPtrs[IParam]^ := PStr[1];
  1233.                                      END;
  1234.                                END;
  1235.  
  1236.                Char_Param    : BEGIN
  1237.                                   PStr := Param_CPtrs[IParam]^;
  1238.                                   WRITELN;
  1239.                                   WRITE( Arrow_Str );
  1240.                                   ClrEol;
  1241.                                   Read_Edited_String( PStr );
  1242.                                   IF ( PStr <> CHR( ESC ) ) THEN
  1243.                                      IF( LENGTH( PStr ) > 0 ) THEN
  1244.                                         Param_CPtrs[IParam]^ := PStr[1];
  1245.                                END;
  1246.  
  1247.                Path_Param   :  BEGIN
  1248.                                   PStr := Param_SPtrs[IParam]^;
  1249.                                   WRITELN;
  1250.                                   WRITE( Arrow_Str );
  1251.                                   ClrEol;
  1252.                                   Read_Edited_String( PStr );
  1253.                                   PStr := TRIM( PStr );
  1254.                                   IF ( PStr <> CHR( ESC ) ) THEN
  1255.                                      BEGIN
  1256.                                         IF ( LENGTH( PStr ) > 0 ) THEN
  1257.                                            IF PStr[ LENGTH( PStr ) ] <> '\' THEN
  1258.                                               PStr := PStr + '\';
  1259.                                         Param_SPtrs[IParam]^ := PStr;
  1260.                                      END;
  1261.                                END;
  1262.  
  1263.                Hexi_Param   :  BEGIN
  1264.                                   II   := Param_IPtrs[IParam]^;
  1265.                                   PStr := Dec_To_Hex( II );
  1266.                                   WRITELN;
  1267.                                   WRITE( Arrow_Str );
  1268.                                   ClrEol;
  1269.                                   Read_Edited_String( PStr );
  1270.                                   IF ( PStr <> CHR( ESC ) ) THEN
  1271.                                      Param_IPtrs[IParam]^ := Hex_To_Dec( PStr , II );
  1272.                                END;
  1273.  
  1274.                Integer_Param:  BEGIN
  1275.                                   I := Param_IPtrs[IParam]^;
  1276.                                   IF Read_Number( I, TRUE, I ) THEN
  1277.                                      BEGIN
  1278.                                         IF ( I <= -32768 ) THEN
  1279.                                            II := -32768
  1280.                                         ELSE IF ( I > 32767 ) THEN
  1281.                                            II := 32767
  1282.                                         ELSE
  1283.                                            II := I;
  1284.                                         Param_IPtrs[IParam]^ := II;
  1285.                                      END;
  1286.                                END;
  1287.  
  1288.                ELSE;
  1289.  
  1290.             END (* CASE *);
  1291.  
  1292.          END (* BEGIN *);
  1293.  
  1294.    END (* CASE *);
  1295.  
  1296.    TextBackGround( BLACK );
  1297.  
  1298.    GoToXY( 1 , 21 );
  1299.    ClrEol;
  1300.  
  1301. END   (* Update_Parameter *);
  1302.  
  1303. (*----------------------------------------------------------------------*)
  1304. (*            Do_Display --- Display all currently defined parameters   *)
  1305. (*----------------------------------------------------------------------*)
  1306.  
  1307. PROCEDURE Do_Display;
  1308.  
  1309. VAR
  1310.    I: INTEGER;
  1311.  
  1312. BEGIN (* Do_Display *)
  1313.  
  1314.    FOR I := 1 TO Param_Count DO
  1315.       Display_Parameter( I );
  1316.  
  1317. END   (* Do_Display *);
  1318.  
  1319. (*----------------------------------------------------------------------*)
  1320. (*            Get_Item_Choice  ---   Get parameter item choice          *)
  1321. (*----------------------------------------------------------------------*)
  1322.  
  1323. FUNCTION Get_Item_Choice : INTEGER;
  1324.  
  1325. VAR
  1326.    OK_Choice : BOOLEAN;
  1327.    Hi_Let_Ord: INTEGER;
  1328.    Ch        : CHAR;
  1329.    I         : INTEGER;
  1330.    Cur_Choice: INTEGER;
  1331.    Cur_Let   : CHAR;
  1332.    OK_Move   : BOOLEAN;
  1333.  
  1334. BEGIN (* Get_Item_Choice *)
  1335.                                    (* Clear input area lines       *)
  1336.  
  1337.    FOR I := ( Param_Count + 3 ) TO ( Param_Count + 7 ) DO
  1338.       BEGIN
  1339.          GoToXY( 2 , I );
  1340.          ClrEol;
  1341.       END;
  1342.                                    (* Assume ESC as default choice *)
  1343.    Get_Item_Choice := 0;
  1344.    OK_Choice       := FALSE;
  1345.    Hi_Let_Ord      := ORD( 'A' ) + Param_Count - 1;
  1346.    Cur_Choice      := Param_Count;
  1347.    Cur_Let         := ' ';
  1348.                                    (* Get choice *)
  1349.    REPEAT
  1350.  
  1351.       GoToXY( 2 , Param_Count + 3 );
  1352.  
  1353.       TextColor( Menu_Text_Color_2 );
  1354.       WRITE( 'Enter letter of item to revise or hit ESC to quit: ');
  1355.       ClrEol;
  1356.  
  1357.       TextColor( Menu_Text_Color );
  1358.       WRITE( Cur_Let );
  1359.  
  1360.       Read_Kbd_Old( Ch );
  1361.  
  1362.       Ch := UpCase( Ch );
  1363.  
  1364.       OK_Choice := ( Ch = CHR( ESC ) ) OR
  1365.                    ( Ch = CHR( CR  ) ) OR
  1366.                    ( ( ORD( Ch ) >= ORD( 'A' ) ) AND
  1367.                      ( ORD( Ch ) <= Hi_Let_Ord ) );
  1368.  
  1369.       IF ( NOT OK_Choice ) THEN
  1370.          Menu_Beep
  1371.       ELSE
  1372.                                    (* Check for arrows *)
  1373.  
  1374.          IF ( ( Ch = CHR( ESC ) ) ) THEN
  1375.             IF ( NOT PibTerm_KeyPressed ) THEN
  1376.                Cur_Let := ' '
  1377.             ELSE
  1378.                BEGIN
  1379.  
  1380.                   Read_Kbd_Old( Ch );
  1381.  
  1382.                   OK_Move := TRUE;
  1383.  
  1384.                   CASE ORD( Ch ) OF
  1385.  
  1386.                      U_Arrow,
  1387.                      5        : BEGIN
  1388.                                    DEC( Cur_Choice );
  1389.                                    IF ( Cur_Choice < 1 ) THEN
  1390.                                       Cur_Choice := Param_Count;
  1391.                                 END;
  1392.  
  1393.                      D_Arrow,
  1394.                      24       : BEGIN
  1395.                                    INC( Cur_Choice );
  1396.                                    IF ( Cur_Choice > Param_Count ) THEN
  1397.                                       Cur_Choice := 1;
  1398.                                 END;
  1399.  
  1400.                      ELSE       BEGIN
  1401.                                    Menu_Beep;
  1402.                                    OK_Move := FALSE;
  1403.                                 END;
  1404.  
  1405.                   END (* CASE *);
  1406.  
  1407.                   IF OK_Move THEN
  1408.                      BEGIN
  1409.                         Ch        := CHR( PRED( Cur_Choice ) + ORD('a') );
  1410.                         Cur_Let   := Ch;
  1411.                         OK_Choice := FALSE;
  1412.                      END;
  1413.  
  1414.                END;
  1415.  
  1416.    UNTIL ( OK_Choice );
  1417.                                    (* Get index of choice *)
  1418.    IF ( Ch <> CHR( ESC ) ) THEN
  1419.       IF ( Cur_Let = ' ' ) THEN
  1420.          BEGIN
  1421.             IF ( Ch <> CHR( CR ) ) THEN
  1422.                Get_Item_Choice := SUCC( ORD( Ch ) - ORD( 'A' ) );
  1423.          END
  1424.       ELSE
  1425.          Get_Item_Choice := Cur_Choice;
  1426.  
  1427. END   (* Get_Item_Choice *);
  1428.  
  1429. (*----------------------------------------------------------------------*)
  1430. (*         Get_General_Setup --- Get "non-special" setup                *)
  1431. (*----------------------------------------------------------------------*)
  1432.  
  1433. PROCEDURE Get_General_Setup( Menu_String : AnyStr;
  1434.                              Menu_Title  : AnyStr;
  1435.                              Post_Proc   : CHAR    );
  1436.  
  1437. VAR
  1438.    Local_Save   : Saved_Screen_Ptr;
  1439.    Item_Name    : Char_2;
  1440.    Menu_Item    : INTEGER;
  1441.  
  1442.    Save_P_Count : INTEGER;
  1443.    PNum         : INTEGER;
  1444.    Save_PNums   : PNums_Vector;
  1445.  
  1446. BEGIN (* Get_General_Setup *)
  1447.                                    (* Save previous parameters info *)
  1448.  
  1449.    Save_Params( Save_P_Count , Save_PNums );
  1450.  
  1451.                                    (* Draw frame around screen *)
  1452.  
  1453.    Draw_Titled_Box( Local_Save, 1, 1, 80, 24, Menu_Title );
  1454.  
  1455.                                    (* Set up parameter addresses  *)
  1456.    Param_Count  := 0;
  1457.    Param_ValCol := 0;
  1458.  
  1459.    WHILE ( LENGTH ( Menu_String ) > 0 ) DO
  1460.       BEGIN
  1461.          Item_Name[1] := Menu_String[1];
  1462.          Item_Name[2] := Menu_String[2];
  1463.          Define_Param_For_Display( Item_Name );
  1464.          DELETE( Menu_String, 1, 3 );
  1465.       END;
  1466.  
  1467.    Param_ValCol := Param_ValCol + 6;
  1468.  
  1469.                                    (* Display parameter values *)
  1470.    Do_Display;
  1471.                                    (* Get 1st item to modify, if any.   *)
  1472.                                    (* ESC takes us out.                 *)
  1473.  
  1474.    Menu_Item := Get_Item_Choice;
  1475.  
  1476.    WHILE( Menu_Item > 0 ) DO
  1477.       BEGIN
  1478.                                    (* Update the selected item *)
  1479.  
  1480.          Update_Parameter( Menu_Item );
  1481.  
  1482.                                    (* Call post-processor if any *)
  1483.  
  1484.          CASE Post_Proc OF
  1485.             'I'   : Input_Post_Processor ( Menu_Item );
  1486.             'F'   : File_Post_Processor  ( Menu_Item );
  1487.             'K'   : Kermit_Post_Processor( Menu_Item );
  1488.             'M'   : Modem_Post_Processor ( Menu_Item );
  1489.             ELSE;
  1490.          END (* Post_Proc *);
  1491.                                    (* Display revised item    *)
  1492.  
  1493.          Display_Parameter( Menu_Item );
  1494.  
  1495.                                    (* Get next item to revise *)
  1496.  
  1497.          Menu_Item := Get_Item_Choice;
  1498.  
  1499.       END;
  1500.                                    (* Restore previous screen *)
  1501.    Restore_Screen( Local_Save );
  1502.                                    (* Restore previous parameter info *)
  1503.  
  1504.    Restore_Params( Save_P_Count , Save_PNums );
  1505.  
  1506. END   (* Get_General_Setup *);
  1507.  
  1508.