home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / msdos / pibterm / pibt41s2.arc / PIBANSIB.MOD < prev    next >
Encoding:
Text File  |  1988-03-18  |  58.6 KB  |  1,692 lines
  1. (*----------------------------------------------------------------------*)
  2. (*        VT100_Fix_Line_Width -- Switch from single/double width       *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE VT100_Fix_Line_Width( Y : INTEGER; New_Attr : INTEGER );
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure: VT100_Fix_Line_Width;                                 *)
  10. (*                                                                      *)
  11. (*     Purpose:   Switches line contents from between single/double wid *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        VT100_Fix_Line_Width( Y : INTEGER; New_Attr : INTEGER );      *)
  16. (*                                                                      *)
  17. (*     Called by:  VT100_Process_Escape                                 *)
  18. (*                                                                      *)
  19. (*----------------------------------------------------------------------*)
  20.  
  21. VAR
  22.    Old_Attr    : BYTE;
  23.    X           : INTEGER;
  24.    I           : INTEGER;
  25.    K           : INTEGER;
  26.    MaxC        : INTEGER;
  27.    C           : CHAR;
  28.    Attr        : BYTE;
  29.    Screen_Chars: ARRAY[1..132] OF CHAR;
  30.    Screen_Attrs: ARRAY[1..132] OF BYTE;
  31.  
  32.                                    (* Flags if attribute is double *)
  33.                                    (* width type.                  *)
  34. (* STRUCTURED *) CONST
  35.    Double_Type : ARRAY[0..6] OF BOOLEAN =
  36.                  ( FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, TRUE );
  37.  
  38. BEGIN (* VT100_Fix_Line_Width *)
  39.                                    (* Get current column *)
  40.    X        := Ansi_WhereX;
  41.                                    (* Get current line attribute *)
  42.  
  43.    Old_Attr := Line_Attributes[ Y ];
  44.  
  45.                                    (* Store new attribute type *)
  46.  
  47.    Line_Attributes[ Y ] := New_Attr;
  48.  
  49.                                    (* See if width change needed and *)
  50.                                    (* do it if so.                   *)
  51.  
  52.    IF ( Double_Type[ Old_Attr ] <> Double_Type[ New_Attr ] ) THEN
  53.       BEGIN
  54.                                    (* Figure out if we're compressing *)
  55.                                    (* or expanding this line.         *)
  56.  
  57.          MaxC  := Wrap_Screen_Col SHR 1;
  58.  
  59.          IF ( New_Attr = 0 ) THEN
  60.             BEGIN  (* Compression *)
  61.                FOR I := 1 TO MaxC DO
  62.                   BEGIN
  63.                      ReadCXY ( C, PRED( I SHL 1 ) , Y, Attr );
  64.                      WriteCXY( C, I,                Y, Attr );
  65.                   END;
  66.                FOR I := SUCC( MaxC ) TO Max_Screen_Col DO
  67.                   WriteCXY( ' ', I, Y, Global_Text_Attribute );
  68.                Double_Width_Mode := OFF;
  69.             END
  70.          ELSE
  71.             BEGIN  (* Expansion *)
  72.  
  73.                FOR I := 1 TO MaxC DO
  74.                   ReadCXY( Screen_Chars[ I ] , I, Y, Screen_Attrs[ I ] );
  75.  
  76.                K := 1;
  77.  
  78.                FOR I := 1 TO MaxC DO
  79.                   BEGIN
  80.  
  81.                      C := Screen_Chars[ I ];
  82.  
  83.                      WriteCXY( C, K, Y, Screen_Attrs[ I ] );
  84.  
  85.                      IF ( C = CHR(196) ) OR
  86.                         ( C = CHR(192) ) OR
  87.                         ( C = CHR(218) ) THEN
  88.                         C := CHR( 196 )
  89.                      ELSE
  90.                         C := ' ';
  91.  
  92.                      WriteCXY( C, SUCC( K ), Y, Screen_Attrs[ I ] );
  93.  
  94.                      INC( K , 2 );
  95.  
  96.                   END;
  97.  
  98.                Double_Width_Mode := ON;
  99.  
  100.             END;
  101.  
  102.          Set_Cursor( X , Y );
  103.  
  104.       END;
  105.  
  106. END   (* VT100_Fix_Line_Width *);
  107.  
  108. (*----------------------------------------------------------------------*)
  109. (*        Ansi_Insert_Lines --- Insert empty lines in display           *)
  110. (*----------------------------------------------------------------------*)
  111.  
  112. PROCEDURE Ansi_Insert_Lines;
  113.  
  114. (*----------------------------------------------------------------------*)
  115. (*                                                                      *)
  116. (*     Procedure: Ansi_Insert_Lines;                                    *)
  117. (*                                                                      *)
  118. (*     Purpose:   Inserts empty lines in display                        *)
  119. (*                                                                      *)
  120. (*     Calling Sequence:                                                *)
  121. (*                                                                      *)
  122. (*        Ansi_Insert_Lines;                                            *)
  123. (*                                                                      *)
  124. (*     Called by:  VT100_Process_Escape                                 *)
  125. (*                                                                      *)
  126. (*----------------------------------------------------------------------*)
  127.  
  128. VAR
  129.    L: INTEGER;
  130.    Y: INTEGER;
  131.  
  132. BEGIN (* Ansi_Insert_Lines *)
  133.  
  134.    Y := WhereY;
  135.  
  136.    IF ( ( Y >= Top_Scroll ) AND ( Y <= Bottom_Scroll ) ) THEN
  137.       BEGIN
  138.  
  139.          IF ( Escape_Number = 0 ) THEN
  140.             L := 1
  141.          ELSE
  142.             L := MAX( 1 , Escape_Register[1] );
  143.  
  144.          IF ( ( Y + L - 1 ) > Bottom_Scroll ) THEN
  145.             L := ( Bottom_Scroll - Y + 1 );
  146.  
  147.          IF ( L > 0 ) THEN
  148.             BEGIN
  149.                Scroll( Y, Bottom_Scroll, 1, Max_Screen_Col, -L, FG, BG );
  150.                Ansi_Scroll_Attributes( Y , Bottom_Scroll, -L );
  151.             END;
  152.  
  153.       END;
  154.  
  155. END   (* Ansi_Insert_Lines *);
  156.  
  157. (*----------------------------------------------------------------------*)
  158. (*        Ansi_Delete_Lines --- Delete empty lines in display           *)
  159. (*----------------------------------------------------------------------*)
  160.  
  161. PROCEDURE Ansi_Delete_Lines;
  162.  
  163. (*----------------------------------------------------------------------*)
  164. (*                                                                      *)
  165. (*     Procedure: Ansi_Delete_Lines;                                    *)
  166. (*                                                                      *)
  167. (*     Purpose:   Deletes lines in display                              *)
  168. (*                                                                      *)
  169. (*     Calling Sequence:                                                *)
  170. (*                                                                      *)
  171. (*        Ansi_Delete_Lines;                                            *)
  172. (*                                                                      *)
  173. (*     Called by:  VT100_Process_Escape                                 *)
  174. (*                                                                      *)
  175. (*----------------------------------------------------------------------*)
  176.  
  177. VAR
  178.    L: INTEGER;
  179.    Y: INTEGER;
  180.  
  181. BEGIN (* Ansi_Delete_Lines *)
  182. {==
  183.    PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  184. ==}
  185.    Y := WhereY;
  186.  
  187.    IF ( ( Y >= Top_Scroll ) AND ( Y <= Bottom_Scroll ) ) THEN
  188.       BEGIN
  189.  
  190.          IF ( Escape_Number = 0 ) THEN
  191.             L := 1
  192.          ELSE
  193.             L := MAX( Escape_Register[1] , 1 );
  194.  
  195.          IF ( ( Y + L - 1 ) > Bottom_Scroll ) THEN
  196.             L := ( Bottom_Scroll - Y + 1 );
  197.  
  198.          IF ( L > 0 ) THEN
  199.             BEGIN
  200.                Scroll( Y, Bottom_Scroll, 1, Max_Screen_Col, L, FG, BG );
  201.                Ansi_Scroll_Attributes( Y , Bottom_Scroll , L );
  202.             END;
  203.  
  204.       END;
  205. {==
  206.    IF Origin_Mode THEN
  207.       PibTerm_Window( 1, Top_Scroll, Max_Screen_Col, Bottom_Scroll );
  208. ==}
  209. END   (* Ansi_Delete_Lines *);
  210.  
  211. (*----------------------------------------------------------------------*)
  212. (*        Ansi_Delete_Chars --- Delete characters in display            *)
  213. (*----------------------------------------------------------------------*)
  214.  
  215. PROCEDURE Ansi_Delete_Chars;
  216.  
  217. (*----------------------------------------------------------------------*)
  218. (*                                                                      *)
  219. (*     Procedure: Ansi_Delete_Chars;                                    *)
  220. (*                                                                      *)
  221. (*     Purpose:   Deletes characters in display                         *)
  222. (*                                                                      *)
  223. (*     Calling Sequence:                                                *)
  224. (*                                                                      *)
  225. (*        Ansi_Delete_Chars;                                            *)
  226. (*                                                                      *)
  227. (*     Called by:  VT100_Process_Escape                                 *)
  228. (*                                                                      *)
  229. (*----------------------------------------------------------------------*)
  230.  
  231. VAR
  232.    L    : INTEGER;
  233.    I    : INTEGER;
  234.    C1   : INTEGER;
  235.    C2   : INTEGER;
  236.    Y    : INTEGER;
  237.    Ch   : CHAR;
  238.    Co   : BYTE;
  239.  
  240. BEGIN (* Ansi_Delete_Chars *)
  241.  
  242.    IF ( Escape_Number = 0 ) THEN
  243.       L := 1
  244.    ELSE
  245.       L := MAX( Escape_Register[1] , 1 );
  246.  
  247.                                    (* Need to move twice as many in *)
  248.                                    (* double width mode.            *)
  249.    IF Double_Width_Mode THEN
  250.       L := L * 2;
  251.                                    (* Get current horizontal position *)
  252.    C1 := WhereX;
  253.                                    (* Get end of deletion area *)
  254.  
  255.    C2 := MIN( C1 + L , Wrap_Screen_Col );
  256.  
  257.                                    (* Get current line *)
  258.  
  259.    Y  := WhereY + PRED( Upper_Left_Row );
  260.  
  261.                                    (* Move characters to left *)
  262.  
  263.    FOR I := C2 TO Wrap_Screen_Col DO
  264.       BEGIN
  265.          ReadCXY ( Ch, I, Y, Co );
  266.          WriteCXY( Ch, C1, Y, Co );
  267.          INC( C1 );
  268.       END;
  269.                                    (* Blank out rest of line *)
  270.  
  271.    IF ( C1 <= Wrap_Screen_Col ) THEN
  272.        BEGIN
  273.  
  274.  
  275.           FOR I := C1 TO Wrap_Screen_Col DO
  276.              WriteCXY( ' ', I, Y, Global_Text_Attribute );
  277.  
  278.        END;
  279.                                    (* Move back to proper column position *)
  280.    GoToXY( C1 , WhereY );
  281.  
  282. END   (* Ansi_Delete_Chars *);
  283.  
  284. (*----------------------------------------------------------------------*)
  285. (*        Ansi_Insert_Chars --- Insert empty lines in display           *)
  286. (*----------------------------------------------------------------------*)
  287.  
  288. PROCEDURE Ansi_Insert_Chars;
  289.  
  290. (*----------------------------------------------------------------------*)
  291. (*                                                                      *)
  292. (*     Procedure: Ansi_Insert_Chars;                                    *)
  293. (*                                                                      *)
  294. (*     Purpose:   Inserts characters in display                         *)
  295. (*                                                                      *)
  296. (*     Calling Sequence:                                                *)
  297. (*                                                                      *)
  298. (*        Ansi_Insert_Chars;                                            *)
  299. (*                                                                      *)
  300. (*     Called by:  VT100_Process_Escape                                 *)
  301. (*                                                                      *)
  302. (*----------------------------------------------------------------------*)
  303.  
  304. VAR
  305.    I                   : INTEGER;
  306.    L                   : INTEGER;
  307.    Save_Insertion_Mode : BOOLEAN;
  308.    XPos                : INTEGER;
  309.  
  310. BEGIN (* Ansi_Insert_Chars *)
  311.  
  312.    IF ( Escape_Number = 0 ) THEN
  313.       L := 1
  314.    ELSE
  315.       L := Escape_Register[1];
  316.  
  317.    IF Double_Width_Mode THEN
  318.       L := L * 2;
  319.  
  320.    Save_Insertion_Mode := Insertion_Mode;
  321.    Insertion_Mode      := TRUE;
  322.    XPos                := WhereX;
  323.  
  324.    FOR I := 1 TO L DO
  325.       Display_Character( ' ' );
  326.  
  327.    Insertion_Mode      := Save_Insertion_Mode;
  328.  
  329.    GoToXY( XPos , WhereY );
  330.  
  331. END   (* Ansi_Insert_Chars *);
  332.  
  333. (*----------------------------------------------------------------------*)
  334. (*     VT100_Send_Terminal_Parameters --- Send VT100 terminal params    *)
  335. (*----------------------------------------------------------------------*)
  336.  
  337. PROCEDURE VT100_Send_Terminal_Parameters;
  338.  
  339. (*----------------------------------------------------------------------*)
  340. (*                                                                      *)
  341. (*     Procedure: VT100_Send_Terminal_Parameters                        *)
  342. (*                                                                      *)
  343. (*     Purpose:   Sends VT100 terminal parameters                       *)
  344. (*                                                                      *)
  345. (*     Calling Sequence:                                                *)
  346. (*                                                                      *)
  347. (*        VT100_Send_Terminal_Parameters;                               *)
  348. (*                                                                      *)
  349. (*     Called by:  VT100_Process_Escape                                 *)
  350. (*                                                                      *)
  351. (*----------------------------------------------------------------------*)
  352.  
  353. VAR
  354.    PString : AnyStr;
  355.    BString : STRING[5];
  356.  
  357. BEGIN (* VT100_Send_Terminal_Parameters *)
  358.  
  359.    PString := CHR( ESC ) + '[';
  360.  
  361.    IF ( Escape_Register[1] = 1 ) THEN
  362.       PString := PString + '3;'
  363.    ELSE
  364.       PString := PString + '2;';
  365.  
  366.    CASE Parity OF
  367.       'E' : PString := PString + '5;';
  368.       'O' : PString := PString + '4;';
  369.       ELSE  PString := PString + '1;';
  370.    END (* CASE *);
  371.  
  372.    CASE Data_Bits OF
  373.       7    : PString := PString + '2;';
  374.       ELSE   PString := PString + '1;';
  375.    END (* CASE *);
  376.  
  377.    CASE Baud_Rate OF
  378.       300  : BString := '48';
  379.       600  : BString := '56';
  380.       1200 : BString := '64';
  381.       2400 : BString := '88';
  382.       4800 : BString := '104';
  383.       9600 : BString := '112';
  384.       19200: BString := '120';
  385.       ELSE   BString := '0';
  386.    END (* CASE *);
  387.  
  388.    PString := PString + BString + ';' + BString + ';' + '1;0x';
  389.  
  390.    Async_Send_String( PString );
  391.  
  392. END   (* VT100_Send_Terminal_Parameters *);
  393.  
  394. (*----------------------------------------------------------------------*)
  395. (*     VT100_Set_LEDs --- Set LED flags for VT100                       *)
  396. (*----------------------------------------------------------------------*)
  397.  
  398. PROCEDURE VT100_Set_LEDs;
  399.  
  400. (*----------------------------------------------------------------------*)
  401. (*                                                                      *)
  402. (*     Procedure: VT100_Set_LEDs;                                       *)
  403. (*                                                                      *)
  404. (*     Purpose:   Sets VT100 LED flags                                  *)
  405. (*                                                                      *)
  406. (*     Calling Sequence:                                                *)
  407. (*                                                                      *)
  408. (*        VT100_Set_LEDs;                                               *)
  409. (*                                                                      *)
  410. (*     Called by:  VT100_Process_Escape                                 *)
  411. (*                                                                      *)
  412. (*----------------------------------------------------------------------*)
  413.  
  414. VAR
  415.    Led_Number : INTEGER;
  416.    I          : INTEGER;
  417.  
  418. BEGIN (* VT100_Set_LEDs *)
  419.  
  420.    IF ( Escape_Number = 0 ) THEN
  421.       BEGIN
  422.          Escape_Number      := 1;
  423.          Escape_Register[1] := 0;
  424.       END;
  425.  
  426.    FOR I := 1 TO Escape_Number DO
  427.       CASE Escape_Register[I] OF
  428.  
  429.          0: BEGIN (* Turn off all LEDs *)
  430.                VT100_Led_Vector[1] := FALSE;
  431.                VT100_Led_Vector[2] := FALSE;
  432.                VT100_Led_Vector[3] := FALSE;
  433.                VT100_Led_Vector[4] := FALSE;
  434.             END;
  435.  
  436.          1: VT100_Led_Vector[1] := TRUE;
  437.          2: VT100_Led_Vector[2] := TRUE;
  438.          3: VT100_Led_Vector[3] := TRUE;
  439.          4: VT100_Led_Vector[4] := TRUE;
  440.  
  441.          ELSE;
  442.  
  443.       END (* CASE *);
  444.  
  445. END   (* VT100_Set_LEDs *);
  446.  
  447. (*----------------------------------------------------------------------*)
  448. (*            Ansi_Reset_Terminal --- Reset terminal defaults           *)
  449. (*----------------------------------------------------------------------*)
  450.  
  451. PROCEDURE Ansi_Reset_Terminal;
  452.  
  453. (*----------------------------------------------------------------------*)
  454. (*                                                                      *)
  455. (*     Procedure: Ansi_Reset_Terminal                                   *)
  456. (*                                                                      *)
  457. (*     Purpose:   Resets terminal defaults                              *)
  458. (*                                                                      *)
  459. (*     Calling Sequence:                                                *)
  460. (*                                                                      *)
  461. (*        Ansi_Reset_Terminal;                                          *)
  462. (*                                                                      *)
  463. (*     Called by:  Emulate_Ansi                                         *)
  464. (*                                                                      *)
  465. (*----------------------------------------------------------------------*)
  466.  
  467. VAR
  468.    ITab : INTEGER;
  469.  
  470. BEGIN (* Ansi_Reset_Terminal *)
  471.                                    (* Turn on the cursor            *)
  472.    CursorOn;
  473.                                    (* Initialize terminal state     *)
  474.    Done                  := FALSE;
  475.    Alt_Keypad_Mode       := OFF;
  476.    Graphics_Mode         := OFF;
  477.    Auto_Print_Mode       := OFF;
  478.    Origin_Mode           := OFF;
  479.    Auto_Wrap_Mode        := ON;
  480.    Printer_Ctrl_Mode     := OFF;
  481.    Escape_Mode           := FALSE;
  482.    Escape_Str            := '';
  483.    NewX                  := WhereX;
  484.    NewY                  := WhereY;
  485.    Skip_All_Mode         := FALSE;
  486.    Double_Width_Mode     := FALSE;
  487.    New_Line              := New_Line_Param;
  488.    Save_Done             := FALSE;
  489.    Insertion_Mode        := FALSE;
  490.    VT100_G0_Set          := 'A';
  491.    VT100_G1_Set          := 'A';
  492.    VT100_G0_State        := TRUE;
  493.    Wrap_Screen_Col       := 80;
  494.    Current_Status_Time   := -1;
  495.  
  496.                                    (* Set tabs *)
  497.    Number_VT100_Tabs     := 17;
  498.  
  499.    FOR ITab := 1 TO 9 DO
  500.       VT100_Tabs[ITab] := SUCC( ITab * 8 );
  501.  
  502.    FOR ITab := 10 TO 16 DO
  503.       VT100_Tabs[ITab] := 64 + ITab;
  504.  
  505.    VT100_Tabs[17] := Wrap_Screen_Col;
  506.  
  507.                                    (* Set colors.                *)
  508.  
  509.    Ansi_ForeGround_Color := VT100_ForeGround_Color;
  510.    Ansi_BackGround_Color := VT100_BackGround_Color;
  511.    Ansi_Underline_Color  := VT100_Underline_Color;
  512.    Ansi_Bold_Color       := VT100_Bold_Color;
  513.  
  514.    ForeGround_Color      := VT100_ForeGround_Color;
  515.    BackGround_Color      := VT100_BackGround_Color;
  516.    Border_Color          := VT100_Border_Color;
  517.  
  518.    FG                    := VT100_ForeGround_Color;
  519.    BG                    := VT100_BackGround_Color;
  520.  
  521.    Bolding_On            := FALSE;
  522.    Blinking_On           := FALSE;
  523.    Reverse_On            := FALSE;
  524.  
  525.    Set_Global_Colors( Ansi_ForeGround_Color , Ansi_BackGround_Color );
  526.    Set_Border_Color ( Border_Color );
  527.  
  528.                                    (* Initialize music playing   *)
  529.    PibPlaySet;
  530.    Getting_Music := FALSE;
  531.                                    (* Set status line attribute *)
  532.  
  533.    IF Reverse_Status_Colors THEN
  534.       Status_Line_Attr := 16 * ( ForeGround_Color AND 7 ) + BackGround_Color
  535.    ELSE
  536.       Status_Line_Attr := 16 * ( Status_BackGround_Color AND 7 ) + Status_ForeGround_Color;
  537.  
  538.    Do_Status_Line   := Show_Status_Line;
  539.    Do_Status_Time   := Do_Status_Line AND Show_Status_Time;
  540.  
  541.    IF VT100_Allowed THEN
  542.       Short_Terminal_Name := 'VT100'
  543.    ELSE
  544.       Short_Terminal_Name := 'ANSI/BBS';
  545.  
  546.    Ansi_Last_Line := Max_Screen_Line;
  547.  
  548.    Set_Status_Line_Name( Short_Terminal_Name );
  549.  
  550.                                    (* Status line to last line *)
  551.    IF Do_Status_Line THEN
  552.       BEGIN
  553.          Ansi_Last_Line := PRED( Max_Screen_Line );
  554.          Write_To_Status_Line( Status_Line_Name, 1 );
  555.       END;
  556.                                    (* Set screen size            *)
  557.  
  558.    PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  559.  
  560.                                    (* Change text attributes     *)
  561.  
  562.    Set_Text_Attributes( 1, 1, Max_Screen_Col, Ansi_Last_Line,
  563.                         Ansi_ForeGround_Color,
  564.                         Ansi_BackGround_Color );
  565.  
  566.                                    (* Initial scrolling region is *)
  567.                                    (* entire usable screen.       *)
  568.  
  569.    Top_Scroll            := 1;
  570.    Bottom_Scroll         := Ansi_Last_Line;
  571.  
  572.                                    (* Set line attributes all normal  *)
  573.  
  574.    FillChar( Line_Attributes, Max_Screen_Line, 0 );
  575.  
  576.                                    (* Special keyboard and output chars *)
  577.    FOR ITab := 0 TO 255 DO
  578.       Special_Comm [ITab] := FALSE;
  579.  
  580.    Special_Comm[NUL]  := TRUE;
  581.    Special_Comm[ESC]  := TRUE;
  582.    Special_Comm[LF ]  := TRUE;
  583.    Special_Comm[CR ]  := TRUE;
  584.    Special_Comm[FF ]  := TRUE;
  585.    Special_Comm[VT ]  := TRUE;
  586.    Special_Comm[HT ]  := TRUE;
  587.    Special_Comm[ENQ]  := TRUE;
  588.    Special_Comm[SO ]  := TRUE;
  589.    Special_Comm[SI ]  := TRUE;
  590.    Special_Comm[DEL]  := TRUE;
  591.    Special_Comm[BS ]  := TRUE;
  592.    Special_Comm[CAN]  := TRUE;
  593.    Special_Comm[SUB]  := TRUE;
  594.    Special_Comm[DLE]  := TRUE;
  595.    Special_Comm[ETX]  := TRUE;
  596.    Special_Comm[SOH]  := TRUE;
  597.  
  598.                                    (* Set time for status line   *)
  599.    Current_Status_Time := -1;
  600.                                    (* Check if script tests req'd *)
  601.  
  602.    Do_Script_Tests := Waitstring_Mode OR When_Mode OR
  603.                       WaitCount_Mode  OR WaitQuiet_Mode OR
  604.                       Script_Learn_Mode;
  605.  
  606.                                    (* Set save guys *)
  607.  
  608.    Save_Col_Position  := PRED( NewX );
  609.    Save_Row_Position  := PRED( NewY );
  610.    Save_FG_Color      := FG;
  611.    Save_BG_Color      := BG;
  612.    Save_Graphics_Mode := Graphics_Mode;
  613.    Save_Bolding       := Bolding_On;
  614.    Save_Blinking      := Blinking_On;
  615.    Save_Origin_Mode   := Origin_Mode;
  616.    Save_Top_Scroll    := Top_Scroll;
  617.    Save_Bottom_Scroll := Bottom_Scroll;
  618.  
  619.                                    (* No LEDs lit *)
  620.    VT100_Led_Vector[1] := FALSE;
  621.    VT100_Led_Vector[2] := FALSE;
  622.    VT100_Led_Vector[3] := FALSE;
  623.    VT100_Led_Vector[4] := FALSE;
  624.  
  625. END   (* Ansi_Reset_Terminal *);
  626.  
  627. (*----------------------------------------------------------------------*)
  628. (*            Ansi_Process_Escape --- Process ANSI escape sequence      *)
  629. (*----------------------------------------------------------------------*)
  630.  
  631. PROCEDURE Ansi_Process_Escape( Ch : CHAR );
  632.  
  633. (*----------------------------------------------------------------------*)
  634. (*                                                                      *)
  635. (*     Procedure: Ansi_Process_Escape                                   *)
  636. (*                                                                      *)
  637. (*     Purpose:   Processes escape sequence for BBS/ANSI emulation      *)
  638. (*                                                                      *)
  639. (*     Calling Sequence:                                                *)
  640. (*                                                                      *)
  641. (*        Ansi_Process_Escape( Ch: CHAR );                              *)
  642. (*                                                                      *)
  643. (*           Ch --- Next character in escape sequence                   *)
  644. (*                                                                      *)
  645. (*     Called by:  Emulate_Ansi                                         *)
  646. (*                                                                      *)
  647. (*     Remarks:                                                         *)
  648. (*                                                                      *)
  649. (*        This version doesn't process private DEC escape sequences,    *)
  650. (*        but DOES play music.                                          *)
  651. (*                                                                      *)
  652. (*----------------------------------------------------------------------*)
  653.  
  654. VAR
  655.    Reg_Val     : INTEGER;
  656.    Save_X      : INTEGER;
  657.    Save_Y      : INTEGER;
  658.    More_Escape : BOOLEAN;
  659.  
  660. BEGIN (* Ansi_Process_Escape *)
  661.  
  662.    IF Getting_Music THEN
  663.       BEGIN
  664.          IF ( ORD( Escape_Str[0] ) < 255 ) THEN
  665.             Escape_Str := Escape_Str + Ch;
  666.          EXIT;
  667.       END;
  668.  
  669.    More_Escape := FALSE;
  670.  
  671.    CASE Ch OF
  672.  
  673.       ' ' : EXIT;
  674.       ^M  : EXIT;
  675.       ^J  : EXIT;
  676.  
  677.       '[' : BEGIN
  678.                Escape_Type    := '[';
  679.                EXIT;
  680.             END;
  681.  
  682.       'A' : IF Escape_Type <> '[' THEN
  683.                More_Escape := TRUE
  684.             ELSE
  685.                Ansi_Cursor_Up;
  686.  
  687.       'B' : IF Escape_Type <> '[' THEN
  688.                More_Escape := TRUE
  689.             ELSE
  690.                Ansi_Cursor_Down;
  691.  
  692.       'C' : IF Escape_Type <> '[' THEN
  693.                More_Escape := TRUE
  694.             ELSE
  695.                Ansi_Cursor_Right;
  696.  
  697.       'D' : IF Escape_Type <> '[' THEN
  698.                More_Escape := TRUE
  699.             ELSE
  700.                Ansi_Cursor_Left;
  701.  
  702.       'f' : Ansi_Set_Cursor;
  703.  
  704.       'H' : Ansi_Set_Cursor;
  705.  
  706.       'I' : IF ( Escape_Type = ' ' ) THEN
  707.                IF CompuServe_B_On THEN
  708.                   CISB_Term_ESC_I;
  709.  
  710.       'J' : Ansi_Clear_Screen;
  711.  
  712.       'K' : Ansi_Clear_Line;
  713.  
  714.       'L' : BEGIN
  715.                Scroll( WhereY, Bottom_Scroll, 1, Max_Screen_Col, -1, FG, BG );
  716.                Ansi_Scroll_Attributes( WhereY, Bottom_Scroll, -1 );
  717.                ClrEol;
  718.             END;
  719.  
  720.       'M' : BEGIN
  721.                Getting_Music := TRUE;
  722.                More_Escape   := TRUE;
  723.             END;
  724.  
  725.       'm' : Ansi_Set_Graphics;
  726.                                    (* Indicate EXEC PC AutoDownload possible *)
  727.  
  728.       ^Q  : IF Mahoney_On THEN Async_Send_String( 'EXECPC2' );
  729.  
  730.       'O':  IF Mahoney_On THEN Exec_PC_Commands;
  731.  
  732.       's':  IF Escape_Type = '[' THEN
  733.                BEGIN
  734.                   Save_Row_Position  := WhereX;
  735.                   Save_Col_Position  := WhereY;
  736.                   Save_FG_Color      := FG;
  737.                   Save_BG_Color      := BG;
  738.                   Save_Graphics_Mode := Graphics_Mode;
  739.                   Save_Bolding       := Bolding_On;
  740.                   Save_Blinking      := Blinking_On;
  741.                   Save_Double        := Double_Width_Mode;
  742.                END
  743.             ELSE
  744.                More_Escape := TRUE;
  745.  
  746.       'u':  IF Escape_Type = '[' THEN
  747.                BEGIN
  748.                   MoveToXY( Save_Row_Position , Save_Col_Position );
  749.                   FG                := Save_FG_Color;
  750.                   BG                := Save_BG_Color;
  751.                   Bolding_On        := Save_Bolding;
  752.                   Blinking_On       := Save_Blinking;
  753.                   Double_Width_Mode := Save_Double;
  754.                   Graphics_Mode     := Save_Graphics_Mode;
  755.                   IF Blinking_On THEN
  756.                      TextColor( FG + Blink )
  757.                   ELSE
  758.                      TextColor( FG );
  759.                   TextBackGround( BG );
  760.                END
  761.             ELSE
  762.                More_Escape := TRUE;
  763.  
  764.       ELSE  More_Escape := TRUE;
  765.  
  766.    END  (* CASE *);
  767.  
  768.    IF ( NOT More_Escape ) THEN
  769.       Escape_Mode := FALSE
  770.    ELSE
  771.       BEGIN
  772.  
  773.          Ch         := UpCase( Ch );
  774.          Escape_Str := Escape_Str + Ch;
  775.  
  776.          IF Ch IN Lets THEN EXIT;
  777.  
  778.          IF Ch IN Digits THEN
  779.             BEGIN
  780.                Escape_Register[Escape_Number] :=
  781.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  782.                                                             ORD( '0' );
  783.                EXIT;
  784.             END;
  785.  
  786.          CASE Ch OF
  787.  
  788.             ';', ',' : BEGIN
  789.                           INC( Escape_Number );
  790.                           Escape_Register[Escape_Number] := 0;
  791.                        END;
  792.  
  793.             'T', 'S', '#', '+', '-', '>', '<', '.'
  794.                         : ;
  795.             ELSE
  796.                Escape_Mode := FALSE;
  797.                Ansi_Write_Escape;
  798.  
  799.          END  (* CASE *);
  800.  
  801.    END (* NOT More_Escape *);
  802.  
  803. END   (* Ansi_Process_Escape *);
  804.  
  805. (*----------------------------------------------------------------------*)
  806. (*        Handle_VT100_Special --- Process special chars in VT100       *)
  807. (*----------------------------------------------------------------------*)
  808.  
  809. PROCEDURE Handle_VT100_Special( Comm_Ch: CHAR );
  810.  
  811. VAR
  812.    Save_Y: INTEGER;
  813.  
  814. (*----------------------------------------------------------------------*)
  815.  
  816. PROCEDURE Normal_Char;
  817.  
  818. BEGIN (* Normal_Char *)
  819.  
  820.    Display_Character( Comm_Ch );
  821.    IF Do_Script_Tests THEN
  822.       Do_Script_Checks( Comm_Ch );
  823.  
  824. END   (* Normal_Char *);
  825.  
  826. (*----------------------------------------------------------------------*)
  827.  
  828. BEGIN (* Handle_VT100_Special *)
  829.  
  830.    Do_Graphics_Mode := Graphics_Mode;
  831.    Graphics_Mode    := OFF;
  832.  
  833.    CASE ORD( Comm_Ch ) OF
  834.  
  835.       ESC:  BEGIN (* ESC found *)
  836.  
  837.                IF Escape_Mode THEN Ansi_Write_Escape;
  838.  
  839.                Escape_Str         := '';
  840.                Escape_Number      := 1;
  841.                Escape_Register[1] := 0;
  842.                Escape_Mode        := TRUE;
  843.                Escape_Type        := ' ';
  844.                Getting_Music      := FALSE;
  845.  
  846.             END;
  847.  
  848.       LF,
  849.       FF,
  850.       VT:   BEGIN (* go down one line *)
  851.  
  852.                Save_Y   := WhereY;
  853.  
  854.                IF Auto_Print_Mode THEN
  855.                   BEGIN
  856.                      Get_Screen_Text_Line( Print_Line, Save_Y, 1 );
  857.                      Write_Prt_Str( Print_Line );
  858.                      Write_Prt_Str( CRLF_String );
  859.                   END;
  860.  
  861.                IF VT100_Allowed THEN
  862.                   BEGIN
  863.                      Save_FG1 := FG;
  864.                      Save_BG1 := BG;
  865.                      TextColor     ( Ansi_ForeGround_Color );
  866.                      TextBackGround( Ansi_BackGround_Color );
  867.                   END;
  868.  
  869.                IF ( Save_Y <= Bottom_Scroll  ) THEN
  870.                   BEGIN
  871.  
  872.                      IF ( Save_Y = Bottom_Scroll ) THEN
  873.                          BEGIN
  874.  
  875.                             PibTerm_Window( 1, Top_Scroll, Max_Screen_Col,
  876.                                             Bottom_Scroll );
  877.  
  878.                             Display_Character( Comm_Ch );
  879. {==
  880.                             IF ( NOT Origin_Mode ) THEN
  881. ==}
  882.                                PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  883.  
  884.                             MOVE( Line_Attributes[ Top_Scroll + 1 ],
  885.                                   Line_Attributes[ Top_Scroll     ],
  886.                                   Bottom_Scroll - Top_Scroll );
  887.  
  888.                             Line_Attributes[ Bottom_Scroll ] := 0;
  889.                             ClrEol;
  890.  
  891.                          END
  892.                       ELSE
  893.                          Display_Character( Comm_Ch );
  894.  
  895.                       IF Do_Script_Tests THEN
  896.                          Do_Script_Checks( Comm_Ch );
  897.  
  898.                   END
  899.                ELSE
  900.                   BEGIN
  901.  
  902.                      IF ( Save_Y < Ansi_Last_Line ) THEN
  903.                         Display_Character( Comm_Ch );
  904.  
  905.                      IF Capture_On THEN
  906.                         Capture_Char( Comm_Ch );
  907.  
  908.                      IF Printer_On THEN
  909.                          Write_Prt( Comm_Ch );
  910.  
  911.                      IF Review_On THEN
  912.                          Update_Review_Pointers;
  913.  
  914.                      IF Do_Script_Tests THEN
  915.                         Do_Script_Checks( Comm_Ch );
  916.  
  917.                   END;
  918.  
  919.                IF VT100_Allowed THEN
  920.                   BEGIN
  921.                      TextColor     ( Save_FG1 );
  922.                      TextBackGround( Save_BG1 );
  923.                   END;
  924.  
  925.             END   (* go down one line *);
  926.  
  927.                                    (* Move to specified tab column *)
  928.  
  929.       HT:   IF VT100_Allowed THEN
  930.                Handle_Tab( VT100_Tabs , Number_VT100_Tabs )
  931.             ELSE
  932.                Normal_Char;
  933.  
  934.       BS:   BEGIN
  935.                Display_Character( Comm_Ch );
  936.                IF Double_Width_Mode THEN
  937.                   Display_Character( Comm_Ch );
  938.                IF Do_Script_Tests THEN
  939.                   Do_Script_Checks( Comm_Ch );
  940.             END;
  941.  
  942.       SO:   IF VT100_Allowed THEN
  943.                BEGIN
  944.                   VT100_G0_State   := FALSE;
  945.                   Do_Graphics_Mode := ( VT100_G1_Set = '0' );
  946.                END
  947.             ELSE
  948.                BEGIN
  949.                   IF ( Play_Music_On ) AND ( NOT Silent_Mode ) THEN
  950.                      PibPlay( Escape_Str );
  951.                   Escape_Mode   := FALSE;
  952.                   Escape_Str    := '';
  953.                END;
  954.  
  955.       SI:   IF VT100_Allowed THEN
  956.                BEGIN
  957.                   VT100_G0_State   := TRUE;
  958.                   Do_Graphics_Mode := ( VT100_G0_Set = '0' );
  959.                END
  960.             ELSE
  961.                Normal_Char;
  962.                                    (* Kermit autodownload request *)
  963.  
  964.       SOH:  IF Kermit_Autodownload THEN
  965.                IF ( NOT Handle_Kermit_Autodownload ) THEN
  966.                   Normal_Char
  967.                ELSE
  968.             ELSE
  969.                Normal_Char;
  970.                                    (* CompuServe B protocol request *)
  971.  
  972.       ENQ:  IF CompuServe_B_On THEN
  973.                CISB_Term_ENQ
  974.             ELSE
  975.                IF VT100_Allowed THEN
  976.                   Async_Send_String( VT100_Answerback_Message )
  977.                ELSE
  978.                   Normal_Char;
  979.  
  980.       ETX:  IF CompuServe_B_On THEN
  981.                CISB_Term_ENQ
  982.             ELSE
  983.                Normal_Char;
  984.  
  985.       DLE:  IF CompuServe_B_On THEN
  986.                CISB_DLE_Seen
  987.             ELSE
  988.                Normal_Char;
  989.                                    (* Cancel escape sequence in progress *)
  990.                                    (* or Zmodem download.                *)
  991.       CAN:  IF Escape_Mode THEN
  992.                Escape_Mode := FALSE
  993.             ELSE
  994.                IF Zmodem_Autodownload THEN
  995.                   IF ( NOT Handle_Zmodem_Autodownload ) THEN
  996.                      Normal_Char
  997.                   ELSE
  998.                ELSE
  999.                   Normal_Char;
  1000.  
  1001.                                    (* Cancel escape sequence in progress *)
  1002.       SUB:  IF Escape_Mode THEN
  1003.                Escape_Mode := FALSE
  1004.             ELSE
  1005.                Normal_Char;
  1006.  
  1007.       ELSE
  1008.             Normal_Char;
  1009.  
  1010.    END  (* CASE *);
  1011.  
  1012.    Graphics_Mode := Do_Graphics_Mode;
  1013.  
  1014.    Ansi_Check_Line_Attributes( WhereY );
  1015.  
  1016. END   (* Handle_VT100_Special *);
  1017.  
  1018. (*----------------------------------------------------------------------*)
  1019. (*         VT100_Process_Escape --- Process VT100 escape sequence       *)
  1020. (*----------------------------------------------------------------------*)
  1021.  
  1022. PROCEDURE VT100_Process_Escape(     Ch   : CHAR;
  1023.                                 VAR Done : BOOLEAN );
  1024.  
  1025. (*----------------------------------------------------------------------*)
  1026. (*                                                                      *)
  1027. (*     Procedure: VT100_Process_Escape                                  *)
  1028. (*                                                                      *)
  1029. (*     Purpose:   Processes escape sequence for DEC VT100 emulation     *)
  1030. (*                                                                      *)
  1031. (*     Calling Sequence:                                                *)
  1032. (*                                                                      *)
  1033. (*        VT100_Process_Escape( Ch: CHAR; VAR Done: BOOLEAN );          *)
  1034. (*                                                                      *)
  1035. (*           Ch --- Next character in escape sequence                   *)
  1036. (*           Done --- Set TRUE to exit ANSI/VT100 mode                  *)
  1037. (*                                                                      *)
  1038. (*     Called by:  Emulate_Ansi                                         *)
  1039. (*                                                                      *)
  1040. (*     Remarks:                                                         *)
  1041. (*                                                                      *)
  1042. (*        This version processes private DEC escape sequences.          *)
  1043. (*                                                                      *)
  1044. (*----------------------------------------------------------------------*)
  1045.  
  1046. VAR
  1047.    Reg_Val     : INTEGER;
  1048.    Save_X      : INTEGER;
  1049.    Save_Y      : INTEGER;
  1050.    I           : INTEGER;
  1051.    J           : INTEGER;
  1052.    More_Escape : BOOLEAN;
  1053.    S           : AnyStr;
  1054.    Regs        : Registers;
  1055.  
  1056. (* STRUCTURED *) CONST
  1057.    VT100_Char_Sets : SET OF CHAR = ['A','B','0','1','2'];
  1058.  
  1059. BEGIN (* VT100_Process_Escape *)
  1060.  
  1061.    More_Escape := FALSE;
  1062.                                    (* Ignore blanks *)
  1063.    IF ( Ch = ' ' ) THEN EXIT;
  1064.                                    (* Process char depending upon current *)
  1065.                                    (* escape type mode                    *)
  1066.    CASE Escape_Type OF
  1067.  
  1068.       ' ':  CASE Ch OF
  1069.  
  1070.                '#',
  1071.                '[',
  1072.                'O',
  1073.                '?':   BEGIN
  1074.                          Escape_Type := Ch;
  1075.                          EXIT;
  1076.                       END;
  1077.  
  1078.                'D':   BEGIN
  1079.                          IF ( WhereY < Bottom_Scroll ) THEN
  1080.                             BEGIN
  1081.                                MoveToXY( WhereX , WhereY + 1 );
  1082.                                Last_Column_Hit := FALSE;
  1083.                             END
  1084.                          ELSE
  1085.                             BEGIN
  1086.                                Save_X := WhereX;
  1087.                                Save_Y := WhereY;
  1088.                                Scroll( Top_Scroll, Bottom_Scroll, 1,
  1089.                                        Max_Screen_Col, 1, FG, BG );
  1090.                                MoveToXY( Save_X, Save_Y );
  1091.                                Ansi_Scroll_Attributes( Top_Scroll ,
  1092.                                                        Bottom_Scroll , 1 );
  1093.                             END;
  1094.                       END;
  1095.  
  1096.                'E':   BEGIN
  1097.                          IF ( WhereY < Bottom_Scroll ) THEN
  1098.                             BEGIN
  1099.                                MoveToXY( 1 , WhereY + 1 );
  1100.                                Last_Column_Hit := FALSE;
  1101.                             END
  1102.                          ELSE
  1103.                             BEGIN
  1104.                                Save_Y := WhereY;
  1105.                                Scroll( Top_Scroll, Bottom_Scroll, 1,
  1106.                                        Max_Screen_Col, 1, FG, BG );
  1107.                                MoveToXY( 1 , Save_Y );
  1108.                                Ansi_Scroll_Attributes( Top_Scroll ,
  1109.                                                        Bottom_Scroll ,
  1110.                                                        1 );
  1111.                             END;
  1112.                       END;
  1113.  
  1114.                'M':   BEGIN
  1115. {==
  1116.                          PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  1117. ==}
  1118.                          IF WhereY > Top_Scroll THEN
  1119.                             BEGIN
  1120.                                MoveToXY( WhereX ,  WhereY - 1 );
  1121.                                Last_Column_Hit := FALSE;
  1122.                             END
  1123.                          ELSE
  1124.                             BEGIN
  1125.  
  1126.                                Save_X  := WhereX;
  1127.                                Save_Y  := WhereY;
  1128.                                Save_FG := FG;
  1129.                                Save_BG := BG;
  1130.                                FG      := Ansi_ForeGround_Color;
  1131.                                BG      := Ansi_BackGround_Color;
  1132.  
  1133.                                Scroll( Top_Scroll, Bottom_Scroll, 1, Max_Screen_Col,
  1134.                                        -1, FG, BG );
  1135.  
  1136.                                FG      := Save_FG;
  1137.                                BG      := Save_BG;
  1138.  
  1139.                                Ansi_Scroll_Attributes( Top_Scroll ,
  1140.                                                        Bottom_Scroll ,
  1141.                                                        -1 );
  1142.  
  1143.                                MoveToXY( Save_X, Save_Y );
  1144.  
  1145.                             END;
  1146. {==
  1147.                          IF Origin_Mode THEN
  1148.                             PibTerm_Window( 1, Top_Scroll, Max_Screen_Col, Bottom_Scroll );
  1149. ==}
  1150.                       END;
  1151.  
  1152.                '7':   BEGIN
  1153.                          Regs.Ah            := 3;
  1154.                          Regs.Bh            := 0;
  1155.                          INTR( $10 , Regs );
  1156.                          Save_Col_Position  := Regs.Dl;
  1157.                          Save_Row_Position  := Regs.Dh;
  1158.                          Save_FG_Color      := FG;
  1159.                          Save_BG_Color      := BG;
  1160.                          Save_Graphics_Mode := Graphics_Mode;
  1161.                          Save_Bolding       := Bolding_On;
  1162.                          Save_Blinking      := Blinking_On;
  1163.                          Save_Done          := TRUE;
  1164.                          Save_Top_Scroll    := Top_Scroll;
  1165.                          Save_Bottom_Scroll := Bottom_Scroll;
  1166.                          Save_Origin_Mode   := Origin_Mode;
  1167.                       END;
  1168.  
  1169.                '8':   BEGIN
  1170.                          Regs.Ah       := 2;
  1171.                          Regs.Bh       := 0;
  1172.                          Regs.Dh       := Save_Row_Position;
  1173.                          Regs.Dl       := Save_Col_Position;
  1174.                          INTR( $10 , Regs );
  1175.                          FG            := Save_FG_Color;
  1176.                          BG            := Save_BG_Color;
  1177.                          Bolding_On    := Save_Bolding;
  1178.                          Blinking_On   := Save_Blinking;
  1179.                          Graphics_Mode := Save_Graphics_Mode;
  1180. {
  1181.                          Top_Scroll    := Save_Top_Scroll;
  1182.                          Bottom_Scroll := Save_Bottom_Scroll;
  1183.                          Origin_Mode   := Save_Origin_Mode;
  1184. }
  1185.                          IF Blinking_On THEN
  1186.                            TextColor( FG + Blink )
  1187.                          ELSE
  1188.                            TextColor( FG );
  1189.                          TextBackGround( BG );
  1190.                          Set_Global_Colors( FG , BG );
  1191.                       END;
  1192.  
  1193.                'H':   VT100_Set_Tab;
  1194.  
  1195.                ')':   BEGIN
  1196.                          Escape_Type   := ')';
  1197.                          Ch            := Ansi_Next_Char;
  1198.                          IF ( Ch IN VT100_Char_Sets ) THEN
  1199.                             BEGIN
  1200.                                VT100_G1_Set := Ch;
  1201.                                IF ( NOT VT100_G0_State ) THEN
  1202.                                   Graphics_Mode := ( VT100_G1_Set = '0' );
  1203.                             END;
  1204.                       END;
  1205.  
  1206.                '(':   BEGIN
  1207.                          Escape_Type   := '(';
  1208.                          Ch            := Ansi_Next_Char;
  1209.                          IF ( Ch IN VT100_Char_Sets ) THEN
  1210.                             BEGIN
  1211.                                VT100_G0_Set := Ch;
  1212.                                IF VT100_G0_State THEN
  1213.                                   Graphics_Mode := ( VT100_G0_Set = '0' );
  1214.                             END;
  1215.                       END;
  1216.  
  1217.                '<':   BEGIN
  1218.                          Escape_Mode := FALSE;
  1219.                          EXIT;
  1220.                       END;
  1221.  
  1222.                'r':   BEGIN               (* Terminal Reset      *)
  1223.                          Top_Scroll    := 1;
  1224.                          Bottom_Scroll := Ansi_Last_Line;
  1225.                          Clear_Window;
  1226.                          FillChar( Line_Attributes, Max_Screen_Line, 0 );
  1227.                       END;
  1228.  
  1229.                'Z':   Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1230.  
  1231.                '=':   Alt_Keypad_Mode := ON;
  1232.  
  1233.                '>':   Alt_Keypad_Mode := OFF;
  1234.  
  1235.                'c':   Ansi_Reset_Terminal;
  1236.  
  1237.                'I':   IF CompuServe_B_On THEN
  1238.                          CISB_Term_ESC_I;
  1239.  
  1240.                ELSE   More_Escape := TRUE;
  1241.  
  1242.             END (* CASE *);
  1243.  
  1244.       '[':  CASE Ch OF
  1245.  
  1246.                '?':   BEGIN
  1247.                          Escape_Type := Ch;
  1248.                          EXIT;
  1249.                       END;
  1250.  
  1251.                'A':   Ansi_Cursor_Up;
  1252.  
  1253.                'B':   Ansi_Cursor_Down;
  1254.  
  1255.                'C':   Ansi_Cursor_Right;
  1256.  
  1257.                'D':   Ansi_Cursor_Left;
  1258.  
  1259.                'H':   Ansi_Set_Cursor;
  1260.  
  1261.                'J':   Ansi_Clear_Screen;
  1262.  
  1263.                'K':   Ansi_Clear_Line;
  1264.  
  1265.                'L':   Ansi_Insert_Lines;
  1266.  
  1267.                'f':   Ansi_Set_Cursor;
  1268.  
  1269.                '}',
  1270.                'm':   Ansi_Set_Graphics;
  1271.  
  1272.                'r':   Ansi_Set_Scrolling_Region;
  1273.  
  1274.                'h':   Ansi_Set_Mode(' ');
  1275.  
  1276.                'i':   Ansi_Printer_Control(' ');
  1277.  
  1278.                'l':   Ansi_Reset_Mode( ' ' , Done );
  1279.  
  1280.                'g':   VT100_Clear_Tabs;
  1281.  
  1282.                'M':   Ansi_Delete_Lines;
  1283.  
  1284.                'c':   Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1285.  
  1286.                'n':   Ansi_Status_Report;
  1287.  
  1288.                'P':   Ansi_Delete_Chars;
  1289.  
  1290.                'q':   VT100_Set_LEDs;
  1291.  
  1292.                's':   (* Protected fields not implemented *);
  1293.  
  1294.                'x':   VT100_Send_Terminal_Parameters;
  1295.  
  1296.                'y':   ;
  1297.  
  1298.                '@':   Ansi_Insert_Chars;
  1299.  
  1300.                ELSE   More_Escape := TRUE;
  1301.  
  1302.             END (* CASE *);
  1303.  
  1304.       '?':  CASE Ch OF
  1305.  
  1306.                'h':   Ansi_Set_Mode('?');
  1307.  
  1308.                'i':   Ansi_Printer_Control('?');
  1309.  
  1310.                'l':   Ansi_Reset_Mode( '?' , Done );
  1311.  
  1312.                ELSE   More_Escape := TRUE;
  1313.  
  1314.             END (* CASE *);
  1315.  
  1316.       '#':  CASE Ch OF
  1317.  
  1318.                '3',
  1319.                '4',
  1320.                '5',
  1321.                '6':  BEGIN
  1322.                         Reg_Val := ORD( Ch ) - ORD('0');
  1323.                         IF ( Reg_Val = 5 ) THEN
  1324.                            Reg_Val := 0;
  1325.                         VT100_Fix_Line_Width( WhereY , Reg_Val );
  1326.                      END;
  1327.  
  1328.                '8':  BEGIN
  1329.                         S := DUPL( 'E', Wrap_Screen_Col );
  1330.                         FOR I := 1 TO PRED( Max_Screen_Line ) DO
  1331.                             WriteSXY( S, 1, I,
  1332.                                       ( Global_BackGround_Color AND 7 ) SHL 4  +
  1333.                                       Global_ForeGround_Color );
  1334.                      END;
  1335.  
  1336.                ELSE   More_Escape := TRUE;
  1337.  
  1338.             END (* CASE *);
  1339.  
  1340.       'O':  CASE Ch OF
  1341.  
  1342.                'A':   Ansi_Cursor_Up;
  1343.  
  1344.                'B':   Ansi_Cursor_Down;
  1345.  
  1346.                'C':   Ansi_Cursor_Right;
  1347.  
  1348.                'D':   Ansi_Cursor_Left;
  1349.  
  1350.                ELSE   More_Escape := TRUE;
  1351.  
  1352.             END (* CASE *);
  1353.  
  1354.       ELSE  More_Escape := TRUE;
  1355.  
  1356.    END (* CASE Escape_Type *);
  1357.  
  1358.    IF ( NOT More_Escape ) THEN
  1359.       Escape_Mode := FALSE
  1360.    ELSE
  1361.       BEGIN
  1362.  
  1363.          Ch         := UpCase( Ch );
  1364.          Escape_Str := Escape_Str + Ch;
  1365.  
  1366.          IF Ch IN Lets THEN EXIT;
  1367.  
  1368.          IF Ch IN Digits THEN
  1369.             BEGIN
  1370.                Escape_Register[Escape_Number] :=
  1371.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1372.                                                             ORD( '0' );
  1373.                EXIT;
  1374.             END;
  1375.  
  1376.          CASE Ch OF
  1377.  
  1378.             ';', ',' : BEGIN
  1379.                           INC( Escape_Number );
  1380.                           Escape_Register[Escape_Number] := 0;
  1381.                        END;
  1382.  
  1383.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1384.                         : ;
  1385.             ELSE
  1386.                Escape_Mode := FALSE;
  1387.                Ansi_Write_Escape;
  1388.  
  1389.          END  (* Case *);
  1390.  
  1391.       END (* NOT More_Escape *);
  1392.  
  1393. END   (* VT100_Process_Escape *);
  1394.  
  1395. (*----------------------------------------------------------------------*)
  1396. (*        Process_Printer_Escapes --- Process printer escape sequence   *)
  1397. (*----------------------------------------------------------------------*)
  1398.  
  1399. PROCEDURE Process_Printer_Escapes( Ch : CHAR );
  1400.  
  1401. (*----------------------------------------------------------------------*)
  1402. (*                                                                      *)
  1403. (*     Procedure: Process_Printer_Escapes                               *)
  1404. (*                                                                      *)
  1405. (*     Purpose:   Processes printer control escape sequences only       *)
  1406. (*                                                                      *)
  1407. (*     Calling Sequence:                                                *)
  1408. (*                                                                      *)
  1409. (*        Process_Printer_Escapes( Ch: CHAR );                          *)
  1410. (*                                                                      *)
  1411. (*           Ch --- Next character in escape sequence                   *)
  1412. (*                                                                      *)
  1413. (*     Called by:  Emulate_Ansi                                         *)
  1414. (*                                                                      *)
  1415. (*----------------------------------------------------------------------*)
  1416.  
  1417. VAR
  1418.    More_Escape : BOOLEAN;
  1419.  
  1420. BEGIN (* Process_Printer_Escapes *)
  1421.  
  1422.    More_Escape := TRUE;
  1423.                                    (* Ignore blanks *)
  1424.    IF ( Ch = ' ' ) THEN
  1425.       BEGIN
  1426.          Escape_Str := Escape_Str + Ch;
  1427.          EXIT;
  1428.       END;
  1429.                                    (* Process char depending upon current *)
  1430.                                    (* escape type mode                    *)
  1431.    CASE Escape_Type OF
  1432.  
  1433.       ' ':  CASE Ch OF
  1434.  
  1435.                '#',
  1436.                '[',
  1437.                'O',
  1438.                '?':   BEGIN
  1439.                          Escape_Str  := Escape_Str + Ch;
  1440.                          Escape_Type := Ch;
  1441.                          EXIT;
  1442.                       END;
  1443.  
  1444.                ELSE;
  1445.  
  1446.             END (* CASE *);
  1447.  
  1448.       '[':  IF ( Ch = 'i' ) THEN
  1449.                BEGIN
  1450.                   Ansi_Printer_Control(' ');
  1451.                   More_Escape := FALSE;
  1452.                END;
  1453.  
  1454.       ELSE;
  1455.  
  1456.    END (* CASE Escape_Type *);
  1457.  
  1458.    IF ( NOT More_Escape ) THEN
  1459.       Escape_Mode := FALSE
  1460.    ELSE
  1461.       BEGIN
  1462.  
  1463.          Escape_Str := Escape_Str + Ch;
  1464.          Ch         := UpCase( Ch );
  1465.  
  1466.          IF Ch IN Lets THEN EXIT;
  1467.  
  1468.          IF Ch IN Digits THEN
  1469.             BEGIN
  1470.                Escape_Register[Escape_Number] :=
  1471.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1472.                                                             ORD( '0' );
  1473.                EXIT;
  1474.             END;
  1475.  
  1476.          CASE Ch OF
  1477.  
  1478.             ';', ',' : BEGIN
  1479.                           INC( Escape_Number );
  1480.                           Escape_Register[Escape_Number] := 0;
  1481.                        END;
  1482.  
  1483.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1484.                         : ;
  1485.             ELSE
  1486.                Escape_Mode := FALSE;
  1487.                Write_Prt_Str( Escape_Str );
  1488.  
  1489.          END  (* Case *);
  1490.  
  1491.       END (* NOT More_Escape *);
  1492.  
  1493. END   (* Process_Printer_Escapes *);
  1494.  
  1495. (*----------------------------------------------------------------------*)
  1496.  
  1497. BEGIN (* Emulate_ANSI *)
  1498.                                    (* We don't go through DOS here *)
  1499.  
  1500.    Save_Dos_Con       := Use_Dos_Con_Output;
  1501.    Use_Dos_Con_Output := FALSE;
  1502.  
  1503.                                    (* Initialize text terminal mode *)
  1504.    Init_Text_Terminal;
  1505.                                    (* Background, foreground      *)
  1506.  
  1507.    Save_Global_FG        := Global_ForeGround_Color;
  1508.    Save_Global_BG        := Global_BackGround_Color;
  1509.    Save_FG               := ForeGround_Color;
  1510.    Save_BG               := BackGround_Color;
  1511.    Save_EG               := Border_Color;
  1512.  
  1513.                                    (* Set the terminal           *)
  1514.    Ansi_Reset_Terminal;
  1515.                                    (* Loop over input until done *)
  1516.    WHILE ( NOT Done ) DO
  1517.       BEGIN
  1518.  
  1519.          IF PibTerm_KeyPressed THEN
  1520.             BEGIN (* PibTerm_KeyPressed *)
  1521.  
  1522.                Save_Do_Status     := Do_Status_Line;
  1523.                Save_FG1           := FG;
  1524.                Save_BG1           := BG;
  1525.                Use_Dos_Con_Output := Save_Dos_Con;
  1526.  
  1527.                Set_Global_Colors( Save_Global_FG , Save_Global_BG );
  1528.  
  1529.                Handle_Keyboard_Input( Done , Reset_Requested , ClrScr_Request );
  1530.  
  1531.                Set_Global_Colors( Save_FG1 , Save_BG1 );
  1532.  
  1533.                Save_Dos_Con       := Use_Dos_Con_Output;
  1534.                Use_Dos_Con_Output := FALSE;
  1535.  
  1536.                IF Reset_Requested THEN
  1537.                   BEGIN
  1538.                      Clear_Window;
  1539.                      Ansi_Reset_Terminal;
  1540.                   END
  1541.                ELSE IF ClrScr_Request THEN
  1542.                   Clear_Window
  1543.                ELSE IF ( Save_Do_Status <> Do_Status_Line ) THEN
  1544.                   BEGIN
  1545.  
  1546.                      IF Do_Status_Line THEN
  1547.                         Ansi_Last_Line := PRED( Max_Screen_Line )
  1548.                      ELSE
  1549.                         Ansi_Last_Line := Max_Screen_Line;
  1550.  
  1551.                      PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  1552.  
  1553.                   END;
  1554.  
  1555.             END   (* PibTerm_KeyPressed *);
  1556.  
  1557.                                    (* Process a script command if any *)
  1558.  
  1559.          IF ( Script_File_Mode AND ( NOT ( Done OR Really_Wait_String ) ) ) THEN
  1560.             BEGIN
  1561.                Get_Script_Command( PibTerm_Command );
  1562.                Execute_Command   ( PibTerm_Command , Done , TRUE );
  1563.             END;
  1564.                                    (* Hold everything while scroll lock on *)
  1565.  
  1566.          IF Scroll_Lock_On THEN
  1567.             Handle_Scroll_Lock;
  1568.                                    (* Handle carrier drop *)
  1569.          IF Carrier_Dropped THEN
  1570.             Handle_Carrier_Drop;
  1571.  
  1572.                                    (* Process char received from comm port *)
  1573.  
  1574.          IF ( Async_Buffer_Head <> Async_Buffer_Tail ) THEN
  1575.             BEGIN  (* Comm_Ch found *)
  1576.  
  1577.                                    (* Get the character *)
  1578.  
  1579.                B := Async_Receive( Comm_Ch );
  1580.  
  1581.                                    (* Strip high bit if requested *)
  1582.  
  1583.                IF Auto_Strip_High_Bit THEN
  1584.                   Comm_Ch := CHR( ORD( Comm_Ch ) AND $7F );
  1585.  
  1586.                                    (* Perform translation *)
  1587.  
  1588.                Comm_Ch := TrTab[Comm_Ch];
  1589.  
  1590.                                    (* Handle printer control mode *)
  1591.  
  1592.                IF Printer_Ctrl_Mode THEN
  1593.                   BEGIN
  1594.                      IF Escape_Mode THEN
  1595.                         Process_Printer_Escapes( Comm_Ch )
  1596.                      ELSE IF ( Comm_Ch = CHR( ESC ) ) THEN
  1597.                         BEGIN
  1598.                            IF Escape_Mode THEN
  1599.                               Write_Prt_Str( Escape_Str );
  1600.                            Escape_Str         := Comm_Ch;
  1601.                            Escape_Number      := 1;
  1602.                            Escape_Register[1] := 0;
  1603.                            Escape_Mode        := TRUE;
  1604.                            Escape_Type        := ' ';
  1605.                            Getting_Music      := FALSE;
  1606.                         END
  1607.                      ELSE
  1608.                         Write_Prt( Comm_Ch );
  1609.                   END
  1610.                                    (* Check for special control character *)
  1611.  
  1612.                ELSE IF Special_Comm[ ORD( Comm_Ch ) ] THEN
  1613.                   Handle_VT100_Special( Comm_Ch )
  1614.  
  1615.                                    (* Check for escape sequence to process *)
  1616.  
  1617.                ELSE IF Escape_Mode THEN
  1618.  
  1619.                   CASE VT100_Allowed OF
  1620.                      TRUE:   VT100_Process_Escape( Comm_Ch , Done );
  1621.                      FALSE:  Ansi_Process_Escape( Comm_Ch );
  1622.                   END (* CASE *)
  1623.  
  1624.                ELSE
  1625.                      BEGIN  (* Ordinary character *)
  1626.  
  1627.                         Double_Ch        := ' ';
  1628.  
  1629.                         IF Graphics_Mode THEN
  1630.                            BEGIN (* Graphics Mode *)
  1631.  
  1632.                               IF ORD( Comm_Ch ) IN [ 95 .. 126 ] THEN
  1633.                                  BEGIN
  1634.                                     Graph_Ch := VT100_Graphics_Chars[ ORD( Comm_Ch ) ];
  1635.                                     Comm_Ch  := CHR( Graph_Ch );
  1636.                                  END;
  1637.  
  1638.                               IF Double_Width_Mode THEN
  1639.                                  IF ( Comm_Ch = CHR(196) ) OR
  1640.                                     ( Comm_Ch = CHR(192) ) OR
  1641.                                     ( Comm_Ch = CHR(218) ) THEN
  1642.                                        Double_Ch := CHR( 196 );
  1643.  
  1644.                            END   (* Graphics Mode *);
  1645.  
  1646.                         Display_Character( Comm_Ch );
  1647.  
  1648.                         IF Double_Width_Mode THEN
  1649.                            Display_Character( Double_Ch );
  1650.  
  1651.                         IF Do_Script_Tests THEN
  1652.                            Do_Script_Checks( Comm_Ch );
  1653.  
  1654.                      END  (* Ordinary character *);
  1655.  
  1656.             END (* Comm_Ch found *)
  1657.                                    (* Check if waitstring time exhausted *)
  1658.          ELSE
  1659.             BEGIN
  1660.                Async_Line_Status := Async_Line_Status AND $FD;
  1661.                IF Really_Wait_String THEN
  1662.                   Check_Wait_String_Time;
  1663.                IF ( ( NOT PibTerm_KeyPressed ) AND ( NOT Script_File_Mode ) ) THEN
  1664.                   IF ( Async_Buffer_Head = Async_Buffer_Tail ) THEN
  1665.                      GiveAwayTime( 1 );
  1666.             END;
  1667.  
  1668.       END  (* NOT Done *);
  1669.                                    (* Reset whole screen as window *)
  1670.  
  1671.    PibTerm_Window( 1, 1, Max_Screen_Col, Max_Screen_Line );
  1672.  
  1673.                                    (* Restore colors *)
  1674.  
  1675.    Reset_Attr              := ( ForeGround_Color <> Save_FG ) OR
  1676.                               ( BackGround_Color <> Save_BG );
  1677.    ForeGround_Color        := Save_FG;
  1678.    BackGround_Color        := Save_BG;
  1679.    Border_Color            := Save_EG;
  1680.  
  1681.    Set_Global_Colors( ForeGround_Color , BackGround_Color );
  1682.    Set_Border_Color ( Border_Color );
  1683.  
  1684.    IF Reset_Attr THEN
  1685.       Set_Text_Attributes( 1, 1, Max_Screen_Col, Max_Screen_Line,
  1686.                            ForeGround_Color, BackGround_Color );
  1687.  
  1688.    Use_Dos_Con_Output := Save_Dos_Con;
  1689.  
  1690. END   (* Emulate_ANSI *);
  1691.  
  1692.