home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / library / dos / pibsoft / terminal / source / pibansib.mod < prev    next >
Encoding:
Text File  |  1988-03-04  |  58.7 KB  |  1,698 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.    TType : Transfer_Type;
  814.  
  815. (*----------------------------------------------------------------------*)
  816.  
  817. PROCEDURE Normal_Char;
  818.  
  819. BEGIN (* Normal_Char *)
  820.  
  821.    Display_Character( Comm_Ch );
  822.    IF Do_Script_Tests THEN
  823.       Do_Script_Checks( Comm_Ch );
  824.  
  825. END   (* Normal_Char *);
  826.  
  827. (*----------------------------------------------------------------------*)
  828.  
  829. BEGIN (* Handle_VT100_Special *)
  830.  
  831.    Do_Graphics_Mode := Graphics_Mode;
  832.    Graphics_Mode    := OFF;
  833.  
  834.    CASE ORD( Comm_Ch ) OF
  835.  
  836.       ESC:  BEGIN (* ESC found *)
  837.  
  838.                IF Escape_Mode THEN Ansi_Write_Escape;
  839.  
  840.                Escape_Str         := '';
  841.                Escape_Number      := 1;
  842.                Escape_Register[1] := 0;
  843.                Escape_Mode        := TRUE;
  844.                Escape_Type        := ' ';
  845.                Getting_Music      := FALSE;
  846.  
  847.             END;
  848.  
  849.       LF,
  850.       FF,
  851.       VT:   BEGIN (* go down one line *)
  852.  
  853.                Save_Y   := WhereY;
  854.  
  855.                IF Auto_Print_Mode THEN
  856.                   BEGIN
  857.                      Get_Screen_Text_Line( Print_Line, Save_Y, 1 );
  858.                      Write_Prt_Str( Print_Line );
  859.                      Write_Prt_Str( CRLF_String );
  860.                   END;
  861.  
  862.                IF VT100_Allowed THEN
  863.                   BEGIN
  864.                      Save_FG1 := FG;
  865.                      Save_BG1 := BG;
  866.                      TextColor     ( Ansi_ForeGround_Color );
  867.                      TextBackGround( Ansi_BackGround_Color );
  868.                   END;
  869.  
  870.                IF ( Save_Y <= Bottom_Scroll  ) THEN
  871.                   BEGIN
  872.  
  873.                      IF ( Save_Y = Bottom_Scroll ) THEN
  874.                          BEGIN
  875.  
  876.                             PibTerm_Window( 1, Top_Scroll, Max_Screen_Col,
  877.                                             Bottom_Scroll );
  878.  
  879.                             Display_Character( Comm_Ch );
  880. {==
  881.                             IF ( NOT Origin_Mode ) THEN
  882. ==}
  883.                                PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  884.  
  885.                             MOVE( Line_Attributes[ Top_Scroll + 1 ],
  886.                                   Line_Attributes[ Top_Scroll     ],
  887.                                   Bottom_Scroll - Top_Scroll );
  888.  
  889.                             Line_Attributes[ Bottom_Scroll ] := 0;
  890.                             ClrEol;
  891.  
  892.                          END
  893.                       ELSE
  894.                          Display_Character( Comm_Ch );
  895.  
  896.                       IF Do_Script_Tests THEN
  897.                          Do_Script_Checks( Comm_Ch );
  898.  
  899.                   END
  900.                ELSE
  901.                   BEGIN
  902.  
  903.                      IF ( Save_Y < Ansi_Last_Line ) THEN
  904.                         Display_Character( Comm_Ch );
  905.  
  906.                      IF Capture_On THEN
  907.                         Capture_Char( Comm_Ch );
  908.  
  909.                      IF Printer_On THEN
  910.                          Write_Prt( Comm_Ch );
  911.  
  912.                      IF Review_On THEN
  913.                          Update_Review_Pointers;
  914.  
  915.                      IF Do_Script_Tests THEN
  916.                         Do_Script_Checks( Comm_Ch );
  917.  
  918.                   END;
  919.  
  920.                IF VT100_Allowed THEN
  921.                   BEGIN
  922.                      TextColor     ( Save_FG1 );
  923.                      TextBackGround( Save_BG1 );
  924.                   END;
  925.  
  926.             END   (* go down one line *);
  927.  
  928.                                    (* Move to specified tab column *)
  929.  
  930.       HT:   IF VT100_Allowed THEN
  931.                Handle_Tab( VT100_Tabs , Number_VT100_Tabs )
  932.             ELSE
  933.                Normal_Char;
  934.  
  935.       BS:   BEGIN
  936.                Display_Character( Comm_Ch );
  937.                IF Double_Width_Mode THEN
  938.                   Display_Character( Comm_Ch );
  939.                IF Do_Script_Tests THEN
  940.                   Do_Script_Checks( Comm_Ch );
  941.             END;
  942.  
  943.       SO:   IF VT100_Allowed THEN
  944.                BEGIN
  945.                   VT100_G0_State   := FALSE;
  946.                   Do_Graphics_Mode := ( VT100_G1_Set = '0' );
  947.                END
  948.             ELSE
  949.                BEGIN
  950.                   IF ( Play_Music_On ) AND ( NOT Silent_Mode ) THEN
  951.                      PibPlay( Escape_Str );
  952.                   Escape_Mode   := FALSE;
  953.                   Escape_Str    := '';
  954.                END;
  955.  
  956.       SI:   IF VT100_Allowed THEN
  957.                BEGIN
  958.                   VT100_G0_State   := TRUE;
  959.                   Do_Graphics_Mode := ( VT100_G0_Set = '0' );
  960.                END
  961.             ELSE
  962.                Normal_Char;
  963.                                    (* Kermit autodownload request *)
  964.  
  965.       SOH:  IF Kermit_Autodownload THEN
  966.                BEGIN
  967.                   Doing_Kermit_Autodown := TRUE;
  968.                   PibDownLoad( Kermit );
  969.                END
  970.             ELSE
  971.                Normal_Char;
  972.                                    (* CompuServe B protocol request *)
  973.  
  974.       ENQ:  IF CompuServe_B_On THEN
  975.                CISB_Term_ENQ
  976.             ELSE
  977.                IF VT100_Allowed THEN
  978.                   Async_Send_String( VT100_Answerback_Message )
  979.                ELSE
  980.                   Normal_Char;
  981.  
  982.       ETX:  IF CompuServe_B_On THEN
  983.                CISB_Term_ENQ
  984.             ELSE
  985.                Normal_Char;
  986.  
  987.       DLE:  IF CompuServe_B_On THEN
  988.                CISB_DLE_Seen
  989.             ELSE
  990.                Normal_Char;
  991.                                    (* Cancel escape sequence in progress *)
  992.                                    (* or Zmodem download.                *)
  993.       CAN:  IF Escape_Mode THEN
  994.                Escape_Mode := FALSE
  995.             ELSE
  996.                IF Zmodem_Autodownload THEN
  997.                   BEGIN
  998.                      TType := Get_Zmodem_Type;
  999.                      IF ( TType = None ) THEN
  1000.                         Normal_Char
  1001.                      ELSE
  1002.                         PibDownLoad( TType );
  1003.                   END
  1004.                ELSE
  1005.                   Normal_Char;
  1006.  
  1007.                                    (* Cancel escape sequence in progress *)
  1008.       SUB:  IF Escape_Mode THEN
  1009.                Escape_Mode := FALSE
  1010.             ELSE
  1011.                Normal_Char;
  1012.  
  1013.       ELSE
  1014.             Normal_Char;
  1015.  
  1016.    END  (* CASE *);
  1017.  
  1018.    Graphics_Mode := Do_Graphics_Mode;
  1019.  
  1020.    Ansi_Check_Line_Attributes( WhereY );
  1021.  
  1022. END   (* Handle_VT100_Special *);
  1023.  
  1024. (*----------------------------------------------------------------------*)
  1025. (*         VT100_Process_Escape --- Process VT100 escape sequence       *)
  1026. (*----------------------------------------------------------------------*)
  1027.  
  1028. PROCEDURE VT100_Process_Escape(     Ch   : CHAR;
  1029.                                 VAR Done : BOOLEAN );
  1030.  
  1031. (*----------------------------------------------------------------------*)
  1032. (*                                                                      *)
  1033. (*     Procedure: VT100_Process_Escape                                  *)
  1034. (*                                                                      *)
  1035. (*     Purpose:   Processes escape sequence for DEC VT100 emulation     *)
  1036. (*                                                                      *)
  1037. (*     Calling Sequence:                                                *)
  1038. (*                                                                      *)
  1039. (*        VT100_Process_Escape( Ch: CHAR; VAR Done: BOOLEAN );          *)
  1040. (*                                                                      *)
  1041. (*           Ch --- Next character in escape sequence                   *)
  1042. (*           Done --- Set TRUE to exit ANSI/VT100 mode                  *)
  1043. (*                                                                      *)
  1044. (*     Called by:  Emulate_Ansi                                         *)
  1045. (*                                                                      *)
  1046. (*     Remarks:                                                         *)
  1047. (*                                                                      *)
  1048. (*        This version processes private DEC escape sequences.          *)
  1049. (*                                                                      *)
  1050. (*----------------------------------------------------------------------*)
  1051.  
  1052. VAR
  1053.    Reg_Val     : INTEGER;
  1054.    Save_X      : INTEGER;
  1055.    Save_Y      : INTEGER;
  1056.    I           : INTEGER;
  1057.    J           : INTEGER;
  1058.    More_Escape : BOOLEAN;
  1059.    S           : AnyStr;
  1060.    Regs        : Registers;
  1061.  
  1062. (* STRUCTURED *) CONST
  1063.    VT100_Char_Sets : SET OF CHAR = ['A','B','0','1','2'];
  1064.  
  1065. BEGIN (* VT100_Process_Escape *)
  1066.  
  1067.    More_Escape := FALSE;
  1068.                                    (* Ignore blanks *)
  1069.    IF ( Ch = ' ' ) THEN EXIT;
  1070.                                    (* Process char depending upon current *)
  1071.                                    (* escape type mode                    *)
  1072.    CASE Escape_Type OF
  1073.  
  1074.       ' ':  CASE Ch OF
  1075.  
  1076.                '#',
  1077.                '[',
  1078.                'O',
  1079.                '?':   BEGIN
  1080.                          Escape_Type := Ch;
  1081.                          EXIT;
  1082.                       END;
  1083.  
  1084.                'D':   BEGIN
  1085.                          IF ( WhereY < Bottom_Scroll ) THEN
  1086.                             BEGIN
  1087.                                MoveToXY( WhereX , WhereY + 1 );
  1088.                                Last_Column_Hit := FALSE;
  1089.                             END
  1090.                          ELSE
  1091.                             BEGIN
  1092.                                Save_X := WhereX;
  1093.                                Save_Y := WhereY;
  1094.                                Scroll( Top_Scroll, Bottom_Scroll, 1,
  1095.                                        Max_Screen_Col, 1, FG, BG );
  1096.                                MoveToXY( Save_X, Save_Y );
  1097.                                Ansi_Scroll_Attributes( Top_Scroll ,
  1098.                                                        Bottom_Scroll , 1 );
  1099.                             END;
  1100.                       END;
  1101.  
  1102.                'E':   BEGIN
  1103.                          IF ( WhereY < Bottom_Scroll ) THEN
  1104.                             BEGIN
  1105.                                MoveToXY( 1 , WhereY + 1 );
  1106.                                Last_Column_Hit := FALSE;
  1107.                             END
  1108.                          ELSE
  1109.                             BEGIN
  1110.                                Save_Y := WhereY;
  1111.                                Scroll( Top_Scroll, Bottom_Scroll, 1,
  1112.                                        Max_Screen_Col, 1, FG, BG );
  1113.                                MoveToXY( 1 , Save_Y );
  1114.                                Ansi_Scroll_Attributes( Top_Scroll ,
  1115.                                                        Bottom_Scroll ,
  1116.                                                        1 );
  1117.                             END;
  1118.                       END;
  1119.  
  1120.                'M':   BEGIN
  1121. {==
  1122.                          PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  1123. ==}
  1124.                          IF WhereY > Top_Scroll THEN
  1125.                             BEGIN
  1126.                                MoveToXY( WhereX ,  WhereY - 1 );
  1127.                                Last_Column_Hit := FALSE;
  1128.                             END
  1129.                          ELSE
  1130.                             BEGIN
  1131.  
  1132.                                Save_X  := WhereX;
  1133.                                Save_Y  := WhereY;
  1134.                                Save_FG := FG;
  1135.                                Save_BG := BG;
  1136.                                FG      := Ansi_ForeGround_Color;
  1137.                                BG      := Ansi_BackGround_Color;
  1138.  
  1139.                                Scroll( Top_Scroll, Bottom_Scroll, 1, Max_Screen_Col,
  1140.                                        -1, FG, BG );
  1141.  
  1142.                                FG      := Save_FG;
  1143.                                BG      := Save_BG;
  1144.  
  1145.                                Ansi_Scroll_Attributes( Top_Scroll ,
  1146.                                                        Bottom_Scroll ,
  1147.                                                        -1 );
  1148.  
  1149.                                MoveToXY( Save_X, Save_Y );
  1150.  
  1151.                             END;
  1152. {==
  1153.                          IF Origin_Mode THEN
  1154.                             PibTerm_Window( 1, Top_Scroll, Max_Screen_Col, Bottom_Scroll );
  1155. ==}
  1156.                       END;
  1157.  
  1158.                '7':   BEGIN
  1159.                          Regs.Ah            := 3;
  1160.                          Regs.Bh            := 0;
  1161.                          INTR( $10 , Regs );
  1162.                          Save_Col_Position  := Regs.Dl;
  1163.                          Save_Row_Position  := Regs.Dh;
  1164.                          Save_FG_Color      := FG;
  1165.                          Save_BG_Color      := BG;
  1166.                          Save_Graphics_Mode := Graphics_Mode;
  1167.                          Save_Bolding       := Bolding_On;
  1168.                          Save_Blinking      := Blinking_On;
  1169.                          Save_Done          := TRUE;
  1170.                          Save_Top_Scroll    := Top_Scroll;
  1171.                          Save_Bottom_Scroll := Bottom_Scroll;
  1172.                          Save_Origin_Mode   := Origin_Mode;
  1173.                       END;
  1174.  
  1175.                '8':   BEGIN
  1176.                          Regs.Ah       := 2;
  1177.                          Regs.Bh       := 0;
  1178.                          Regs.Dh       := Save_Row_Position;
  1179.                          Regs.Dl       := Save_Col_Position;
  1180.                          INTR( $10 , Regs );
  1181.                          FG            := Save_FG_Color;
  1182.                          BG            := Save_BG_Color;
  1183.                          Bolding_On    := Save_Bolding;
  1184.                          Blinking_On   := Save_Blinking;
  1185.                          Graphics_Mode := Save_Graphics_Mode;
  1186. {
  1187.                          Top_Scroll    := Save_Top_Scroll;
  1188.                          Bottom_Scroll := Save_Bottom_Scroll;
  1189.                          Origin_Mode   := Save_Origin_Mode;
  1190. }
  1191.                          IF Blinking_On THEN
  1192.                            TextColor( FG + Blink )
  1193.                          ELSE
  1194.                            TextColor( FG );
  1195.                          TextBackGround( BG );
  1196.                          Set_Global_Colors( FG , BG );
  1197.                       END;
  1198.  
  1199.                'H':   VT100_Set_Tab;
  1200.  
  1201.                ')':   BEGIN
  1202.                          Escape_Type   := ')';
  1203.                          Ch            := Ansi_Next_Char;
  1204.                          IF ( Ch IN VT100_Char_Sets ) THEN
  1205.                             BEGIN
  1206.                                VT100_G1_Set := Ch;
  1207.                                IF ( NOT VT100_G0_State ) THEN
  1208.                                   Graphics_Mode := ( VT100_G1_Set = '0' );
  1209.                             END;
  1210.                       END;
  1211.  
  1212.                '(':   BEGIN
  1213.                          Escape_Type   := '(';
  1214.                          Ch            := Ansi_Next_Char;
  1215.                          IF ( Ch IN VT100_Char_Sets ) THEN
  1216.                             BEGIN
  1217.                                VT100_G0_Set := Ch;
  1218.                                IF VT100_G0_State THEN
  1219.                                   Graphics_Mode := ( VT100_G0_Set = '0' );
  1220.                             END;
  1221.                       END;
  1222.  
  1223.                '<':   BEGIN
  1224.                          Escape_Mode := FALSE;
  1225.                          EXIT;
  1226.                       END;
  1227.  
  1228.                'r':   BEGIN               (* Terminal Reset      *)
  1229.                          Top_Scroll    := 1;
  1230.                          Bottom_Scroll := Ansi_Last_Line;
  1231.                          Clear_Window;
  1232.                          FillChar( Line_Attributes, Max_Screen_Line, 0 );
  1233.                       END;
  1234.  
  1235.                'Z':   Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1236.  
  1237.                '=':   Alt_Keypad_Mode := ON;
  1238.  
  1239.                '>':   Alt_Keypad_Mode := OFF;
  1240.  
  1241.                'c':   Ansi_Reset_Terminal;
  1242.  
  1243.                'I':   IF CompuServe_B_On THEN
  1244.                          CISB_Term_ESC_I;
  1245.  
  1246.                ELSE   More_Escape := TRUE;
  1247.  
  1248.             END (* CASE *);
  1249.  
  1250.       '[':  CASE Ch OF
  1251.  
  1252.                '?':   BEGIN
  1253.                          Escape_Type := Ch;
  1254.                          EXIT;
  1255.                       END;
  1256.  
  1257.                'A':   Ansi_Cursor_Up;
  1258.  
  1259.                'B':   Ansi_Cursor_Down;
  1260.  
  1261.                'C':   Ansi_Cursor_Right;
  1262.  
  1263.                'D':   Ansi_Cursor_Left;
  1264.  
  1265.                'H':   Ansi_Set_Cursor;
  1266.  
  1267.                'J':   Ansi_Clear_Screen;
  1268.  
  1269.                'K':   Ansi_Clear_Line;
  1270.  
  1271.                'L':   Ansi_Insert_Lines;
  1272.  
  1273.                'f':   Ansi_Set_Cursor;
  1274.  
  1275.                '}',
  1276.                'm':   Ansi_Set_Graphics;
  1277.  
  1278.                'r':   Ansi_Set_Scrolling_Region;
  1279.  
  1280.                'h':   Ansi_Set_Mode(' ');
  1281.  
  1282.                'i':   Ansi_Printer_Control(' ');
  1283.  
  1284.                'l':   Ansi_Reset_Mode( ' ' , Done );
  1285.  
  1286.                'g':   VT100_Clear_Tabs;
  1287.  
  1288.                'M':   Ansi_Delete_Lines;
  1289.  
  1290.                'c':   Async_Send_String( CHR( 27 ) + '[?1;0c' );
  1291.  
  1292.                'n':   Ansi_Status_Report;
  1293.  
  1294.                'P':   Ansi_Delete_Chars;
  1295.  
  1296.                'q':   VT100_Set_LEDs;
  1297.  
  1298.                's':   (* Protected fields not implemented *);
  1299.  
  1300.                'x':   VT100_Send_Terminal_Parameters;
  1301.  
  1302.                'y':   ;
  1303.  
  1304.                '@':   Ansi_Insert_Chars;
  1305.  
  1306.                ELSE   More_Escape := TRUE;
  1307.  
  1308.             END (* CASE *);
  1309.  
  1310.       '?':  CASE Ch OF
  1311.  
  1312.                'h':   Ansi_Set_Mode('?');
  1313.  
  1314.                'i':   Ansi_Printer_Control('?');
  1315.  
  1316.                'l':   Ansi_Reset_Mode( '?' , Done );
  1317.  
  1318.                ELSE   More_Escape := TRUE;
  1319.  
  1320.             END (* CASE *);
  1321.  
  1322.       '#':  CASE Ch OF
  1323.  
  1324.                '3',
  1325.                '4',
  1326.                '5',
  1327.                '6':  BEGIN
  1328.                         Reg_Val := ORD( Ch ) - ORD('0');
  1329.                         IF ( Reg_Val = 5 ) THEN
  1330.                            Reg_Val := 0;
  1331.                         VT100_Fix_Line_Width( WhereY , Reg_Val );
  1332.                      END;
  1333.  
  1334.                '8':  BEGIN
  1335.                         S := DUPL( 'E', Wrap_Screen_Col );
  1336.                         FOR I := 1 TO PRED( Max_Screen_Line ) DO
  1337.                             WriteSXY( S, 1, I,
  1338.                                       ( Global_BackGround_Color AND 7 ) SHL 4  +
  1339.                                       Global_ForeGround_Color );
  1340.                      END;
  1341.  
  1342.                ELSE   More_Escape := TRUE;
  1343.  
  1344.             END (* CASE *);
  1345.  
  1346.       'O':  CASE Ch OF
  1347.  
  1348.                'A':   Ansi_Cursor_Up;
  1349.  
  1350.                'B':   Ansi_Cursor_Down;
  1351.  
  1352.                'C':   Ansi_Cursor_Right;
  1353.  
  1354.                'D':   Ansi_Cursor_Left;
  1355.  
  1356.                ELSE   More_Escape := TRUE;
  1357.  
  1358.             END (* CASE *);
  1359.  
  1360.       ELSE  More_Escape := TRUE;
  1361.  
  1362.    END (* CASE Escape_Type *);
  1363.  
  1364.    IF ( NOT More_Escape ) THEN
  1365.       Escape_Mode := FALSE
  1366.    ELSE
  1367.       BEGIN
  1368.  
  1369.          Ch         := UpCase( Ch );
  1370.          Escape_Str := Escape_Str + Ch;
  1371.  
  1372.          IF Ch IN Lets THEN EXIT;
  1373.  
  1374.          IF Ch IN Digits THEN
  1375.             BEGIN
  1376.                Escape_Register[Escape_Number] :=
  1377.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1378.                                                             ORD( '0' );
  1379.                EXIT;
  1380.             END;
  1381.  
  1382.          CASE Ch OF
  1383.  
  1384.             ';', ',' : BEGIN
  1385.                           INC( Escape_Number );
  1386.                           Escape_Register[Escape_Number] := 0;
  1387.                        END;
  1388.  
  1389.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1390.                         : ;
  1391.             ELSE
  1392.                Escape_Mode := FALSE;
  1393.                Ansi_Write_Escape;
  1394.  
  1395.          END  (* Case *);
  1396.  
  1397.       END (* NOT More_Escape *);
  1398.  
  1399. END   (* VT100_Process_Escape *);
  1400.  
  1401. (*----------------------------------------------------------------------*)
  1402. (*        Process_Printer_Escapes --- Process printer escape sequence   *)
  1403. (*----------------------------------------------------------------------*)
  1404.  
  1405. PROCEDURE Process_Printer_Escapes( Ch : CHAR );
  1406.  
  1407. (*----------------------------------------------------------------------*)
  1408. (*                                                                      *)
  1409. (*     Procedure: Process_Printer_Escapes                               *)
  1410. (*                                                                      *)
  1411. (*     Purpose:   Processes printer control escape sequences only       *)
  1412. (*                                                                      *)
  1413. (*     Calling Sequence:                                                *)
  1414. (*                                                                      *)
  1415. (*        Process_Printer_Escapes( Ch: CHAR );                          *)
  1416. (*                                                                      *)
  1417. (*           Ch --- Next character in escape sequence                   *)
  1418. (*                                                                      *)
  1419. (*     Called by:  Emulate_Ansi                                         *)
  1420. (*                                                                      *)
  1421. (*----------------------------------------------------------------------*)
  1422.  
  1423. VAR
  1424.    More_Escape : BOOLEAN;
  1425.  
  1426. BEGIN (* Process_Printer_Escapes *)
  1427.  
  1428.    More_Escape := TRUE;
  1429.                                    (* Ignore blanks *)
  1430.    IF ( Ch = ' ' ) THEN
  1431.       BEGIN
  1432.          Escape_Str := Escape_Str + Ch;
  1433.          EXIT;
  1434.       END;
  1435.                                    (* Process char depending upon current *)
  1436.                                    (* escape type mode                    *)
  1437.    CASE Escape_Type OF
  1438.  
  1439.       ' ':  CASE Ch OF
  1440.  
  1441.                '#',
  1442.                '[',
  1443.                'O',
  1444.                '?':   BEGIN
  1445.                          Escape_Str  := Escape_Str + Ch;
  1446.                          Escape_Type := Ch;
  1447.                          EXIT;
  1448.                       END;
  1449.  
  1450.                ELSE;
  1451.  
  1452.             END (* CASE *);
  1453.  
  1454.       '[':  IF ( Ch = 'i' ) THEN
  1455.                BEGIN
  1456.                   Ansi_Printer_Control(' ');
  1457.                   More_Escape := FALSE;
  1458.                END;
  1459.  
  1460.       ELSE;
  1461.  
  1462.    END (* CASE Escape_Type *);
  1463.  
  1464.    IF ( NOT More_Escape ) THEN
  1465.       Escape_Mode := FALSE
  1466.    ELSE
  1467.       BEGIN
  1468.  
  1469.          Escape_Str := Escape_Str + Ch;
  1470.          Ch         := UpCase( Ch );
  1471.  
  1472.          IF Ch IN Lets THEN EXIT;
  1473.  
  1474.          IF Ch IN Digits THEN
  1475.             BEGIN
  1476.                Escape_Register[Escape_Number] :=
  1477.                   ( Escape_Register[Escape_Number] * 10 ) + ORD( Ch ) -
  1478.                                                             ORD( '0' );
  1479.                EXIT;
  1480.             END;
  1481.  
  1482.          CASE Ch OF
  1483.  
  1484.             ';', ',' : BEGIN
  1485.                           INC( Escape_Number );
  1486.                           Escape_Register[Escape_Number] := 0;
  1487.                        END;
  1488.  
  1489.             'T', 'S', '#', '+', '-', '>', '<', '.','?','='
  1490.                         : ;
  1491.             ELSE
  1492.                Escape_Mode := FALSE;
  1493.                Write_Prt_Str( Escape_Str );
  1494.  
  1495.          END  (* Case *);
  1496.  
  1497.       END (* NOT More_Escape *);
  1498.  
  1499. END   (* Process_Printer_Escapes *);
  1500.  
  1501. (*----------------------------------------------------------------------*)
  1502.  
  1503. BEGIN (* Emulate_ANSI *)
  1504.                                    (* We don't go through DOS here *)
  1505.  
  1506.    Save_Dos_Con       := Use_Dos_Con_Output;
  1507.    Use_Dos_Con_Output := FALSE;
  1508.  
  1509.                                    (* Initialize text terminal mode *)
  1510.    Init_Text_Terminal;
  1511.                                    (* Background, foreground      *)
  1512.  
  1513.    Save_Global_FG        := Global_ForeGround_Color;
  1514.    Save_Global_BG        := Global_BackGround_Color;
  1515.    Save_FG               := ForeGround_Color;
  1516.    Save_BG               := BackGround_Color;
  1517.    Save_EG               := Border_Color;
  1518.  
  1519.                                    (* Set the terminal           *)
  1520.    Ansi_Reset_Terminal;
  1521.                                    (* Loop over input until done *)
  1522.    WHILE ( NOT Done ) DO
  1523.       BEGIN
  1524.  
  1525.          IF PibTerm_KeyPressed THEN
  1526.             BEGIN (* PibTerm_KeyPressed *)
  1527.  
  1528.                Save_Do_Status     := Do_Status_Line;
  1529.                Save_FG1           := FG;
  1530.                Save_BG1           := BG;
  1531.                Use_Dos_Con_Output := Save_Dos_Con;
  1532.  
  1533.                Set_Global_Colors( Save_Global_FG , Save_Global_BG );
  1534.  
  1535.                Handle_Keyboard_Input( Done , Reset_Requested , ClrScr_Request );
  1536.  
  1537.                Set_Global_Colors( Save_FG1 , Save_BG1 );
  1538.  
  1539.                Save_Dos_Con       := Use_Dos_Con_Output;
  1540.                Use_Dos_Con_Output := FALSE;
  1541.  
  1542.                IF Reset_Requested THEN
  1543.                   BEGIN
  1544.                      Clear_Window;
  1545.                      Ansi_Reset_Terminal;
  1546.                   END
  1547.                ELSE IF ClrScr_Request THEN
  1548.                   Clear_Window
  1549.                ELSE IF ( Save_Do_Status <> Do_Status_Line ) THEN
  1550.                   BEGIN
  1551.  
  1552.                      IF Do_Status_Line THEN
  1553.                         Ansi_Last_Line := PRED( Max_Screen_Line )
  1554.                      ELSE
  1555.                         Ansi_Last_Line := Max_Screen_Line;
  1556.  
  1557.                      PibTerm_Window( 1, 1, Max_Screen_Col, Ansi_Last_Line );
  1558.  
  1559.                   END;
  1560.  
  1561.             END   (* PibTerm_KeyPressed *);
  1562.  
  1563.                                    (* Process a script command if any *)
  1564.  
  1565.          IF ( Script_File_Mode AND ( NOT ( Done OR Really_Wait_String ) ) ) THEN
  1566.             BEGIN
  1567.                Get_Script_Command( PibTerm_Command );
  1568.                Execute_Command   ( PibTerm_Command , Done , TRUE );
  1569.             END;
  1570.                                    (* Hold everything while scroll lock on *)
  1571.  
  1572.          IF Scroll_Lock_On THEN
  1573.             Handle_Scroll_Lock;
  1574.                                    (* Handle carrier drop *)
  1575.          IF Carrier_Dropped THEN
  1576.             Handle_Carrier_Drop;
  1577.  
  1578.                                    (* Process char received from comm port *)
  1579.  
  1580.          IF ( Async_Buffer_Head <> Async_Buffer_Tail ) THEN
  1581.             BEGIN  (* Comm_Ch found *)
  1582.  
  1583.                                    (* Get the character *)
  1584.  
  1585.                B := Async_Receive( Comm_Ch );
  1586.  
  1587.                                    (* Strip high bit if requested *)
  1588.  
  1589.                IF Auto_Strip_High_Bit THEN
  1590.                   Comm_Ch := CHR( ORD( Comm_Ch ) AND $7F );
  1591.  
  1592.                                    (* Perform translation *)
  1593.  
  1594.                Comm_Ch := TrTab[Comm_Ch];
  1595.  
  1596.                                    (* Handle printer control mode *)
  1597.  
  1598.                IF Printer_Ctrl_Mode THEN
  1599.                   BEGIN
  1600.                      IF Escape_Mode THEN
  1601.                         Process_Printer_Escapes( Comm_Ch )
  1602.                      ELSE IF ( Comm_Ch = CHR( ESC ) ) THEN
  1603.                         BEGIN
  1604.                            IF Escape_Mode THEN
  1605.                               Write_Prt_Str( Escape_Str );
  1606.                            Escape_Str         := Comm_Ch;
  1607.                            Escape_Number      := 1;
  1608.                            Escape_Register[1] := 0;
  1609.                            Escape_Mode        := TRUE;
  1610.                            Escape_Type        := ' ';
  1611.                            Getting_Music      := FALSE;
  1612.                         END
  1613.                      ELSE
  1614.                         Write_Prt( Comm_Ch );
  1615.                   END
  1616.                                    (* Check for special control character *)
  1617.  
  1618.                ELSE IF Special_Comm[ ORD( Comm_Ch ) ] THEN
  1619.                   Handle_VT100_Special( Comm_Ch )
  1620.  
  1621.                                    (* Check for escape sequence to process *)
  1622.  
  1623.                ELSE IF Escape_Mode THEN
  1624.  
  1625.                   CASE VT100_Allowed OF
  1626.                      TRUE:   VT100_Process_Escape( Comm_Ch , Done );
  1627.                      FALSE:  Ansi_Process_Escape( Comm_Ch );
  1628.                   END (* CASE *)
  1629.  
  1630.                ELSE
  1631.                      BEGIN  (* Ordinary character *)
  1632.  
  1633.                         Double_Ch        := ' ';
  1634.  
  1635.                         IF Graphics_Mode THEN
  1636.                            BEGIN (* Graphics Mode *)
  1637.  
  1638.                               IF ORD( Comm_Ch ) IN [ 95 .. 126 ] THEN
  1639.                                  BEGIN
  1640.                                     Graph_Ch := VT100_Graphics_Chars[ ORD( Comm_Ch ) ];
  1641.                                     Comm_Ch  := CHR( Graph_Ch );
  1642.                                  END;
  1643.  
  1644.                               IF Double_Width_Mode THEN
  1645.                                  IF ( Comm_Ch = CHR(196) ) OR
  1646.                                     ( Comm_Ch = CHR(192) ) OR
  1647.                                     ( Comm_Ch = CHR(218) ) THEN
  1648.                                        Double_Ch := CHR( 196 );
  1649.  
  1650.                            END   (* Graphics Mode *);
  1651.  
  1652.                         Display_Character( Comm_Ch );
  1653.  
  1654.                         IF Double_Width_Mode THEN
  1655.                            Display_Character( Double_Ch );
  1656.  
  1657.                         IF Do_Script_Tests THEN
  1658.                            Do_Script_Checks( Comm_Ch );
  1659.  
  1660.                      END  (* Ordinary character *);
  1661.  
  1662.             END (* Comm_Ch found *)
  1663.                                    (* Check if waitstring time exhausted *)
  1664.          ELSE
  1665.             BEGIN
  1666.                Async_Line_Status := Async_Line_Status AND $FD;
  1667.                IF Really_Wait_String THEN
  1668.                   Check_Wait_String_Time;
  1669.                IF ( ( NOT PibTerm_KeyPressed ) AND ( NOT Script_File_Mode ) ) THEN
  1670.                   IF ( Async_Buffer_Head = Async_Buffer_Tail ) THEN
  1671.                      GiveAwayTime( 1 );
  1672.             END;
  1673.  
  1674.       END  (* NOT Done *);
  1675.                                    (* Reset whole screen as window *)
  1676.  
  1677.    PibTerm_Window( 1, 1, Max_Screen_Col, Max_Screen_Line );
  1678.  
  1679.                                    (* Restore colors *)
  1680.  
  1681.    Reset_Attr              := ( ForeGround_Color <> Save_FG ) OR
  1682.                               ( BackGround_Color <> Save_BG );
  1683.    ForeGround_Color        := Save_FG;
  1684.    BackGround_Color        := Save_BG;
  1685.    Border_Color            := Save_EG;
  1686.  
  1687.    Set_Global_Colors( ForeGround_Color , BackGround_Color );
  1688.    Set_Border_Color ( Border_Color );
  1689.  
  1690.    IF Reset_Attr THEN
  1691.       Set_Text_Attributes( 1, 1, Max_Screen_Col, Max_Screen_Line,
  1692.                            ForeGround_Color, BackGround_Color );
  1693.  
  1694.    Use_Dos_Con_Output := Save_Dos_Con;
  1695.  
  1696. END   (* Emulate_ANSI *);
  1697.  
  1698.