home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / PIBTERM / PIBT41S4.ARC / REVIEWCA.MOD < prev    next >
Encoding:
Text File  |  1988-02-15  |  18.7 KB  |  655 lines
  1. (*----------------------------------------------------------------------*)
  2. (*        Review_Captured_Text --- display internal capture buffer      *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Review_Captured_Text;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Review_Captured_Text                                 *)
  10. (*                                                                      *)
  11. (*     Purpose:    Displays contents of internal capture buffer of      *)
  12. (*                 last Max_Review_Length lines received from           *)
  13. (*                 communications port                                  *)
  14. (*                                                                      *)
  15. (*     Calling Sequence:                                                *)
  16. (*                                                                      *)
  17. (*        Review_Captured_Text;                                         *)
  18. (*                                                                      *)
  19. (*     Calls:                                                           *)
  20. (*                                                                      *)
  21. (*        Save_Screen                                                   *)
  22. (*        Restore_Screen                                                *)
  23. (*        Update_Lines_Displayed                                        *)
  24. (*        Reset_Global_Colors                                           *)
  25. (*                                                                      *)
  26. (*----------------------------------------------------------------------*)
  27.  
  28. CONST
  29.    MaxLines = 1500                 (* Maximum lines in capture buffer *);
  30.  
  31. TYPE
  32.    IntStr   = STRING[6];
  33.  
  34. VAR
  35.    I           : INTEGER;
  36.    J           : INTEGER;
  37.    L           : INTEGER;
  38.    Ch          : CHAR;
  39.    Quit        : BOOLEAN;
  40.    Bot_Line    : INTEGER;
  41.    Top_Line    : INTEGER;
  42.    Review_Len  : INTEGER;
  43.    Redraw      : BOOLEAN;
  44.    Left_Col    : INTEGER;
  45.    Right_Col   : INTEGER;
  46.    F_Name      : AnyStr;
  47.    F           : Text_File;
  48.    Attrib      : INTEGER;
  49.    Search_Str  : AnyStr;
  50.    Search_Text : AnyStr;
  51.    Line_Ptrs   : ARRAY[1..MaxLines] OF INTEGER;
  52.    Line_Lens   : ARRAY[1..MaxLines] OF INTEGER;
  53.    NLines      : INTEGER;
  54.    Page_Len    : INTEGER;
  55.  
  56. (*----------------------------------------------------------------------*)
  57. (*    Update_Lines_Displayed -- tell which lines currently displayed    *)
  58. (*----------------------------------------------------------------------*)
  59.  
  60. PROCEDURE Update_Lines_Displayed;
  61.  
  62. VAR
  63.    S: AnyStr;
  64.  
  65. BEGIN (* Update_Lines_Displayed *)
  66.  
  67.    S := ITOS( Top_Line ) + ' --> ' + ITOS( Bot_Line );
  68.    S := S + DUPL( ' ' , 11 - LENGTH( S ) );
  69.  
  70.    WriteSXY( S, 69, Page_Len + 3, Attrib );
  71.  
  72.    S := ITOS( Left_Col ) + ' --> ' + ITOS( Right_Col );
  73.    S := S + DUPL( ' ' , 11 - LENGTH( S ) );
  74.  
  75.    WriteSXY( S, 69, Page_Len + 4, Attrib );
  76.  
  77. END   (* Update_Lines_Displayed *);
  78.  
  79. (*----------------------------------------------------------------------*)
  80. (*       Display_A_Line --- Display selected line in review buffer      *)
  81. (*----------------------------------------------------------------------*)
  82.  
  83. PROCEDURE Display_A_Line( LineNo: INTEGER );
  84.  
  85. VAR
  86.    L:  INTEGER;
  87.    I:  INTEGER;
  88.    Y:  INTEGER;
  89.    S:  AnyStr;
  90.    J:  INTEGER;
  91.    K:  INTEGER;
  92.    Ch: CHAR;
  93.  
  94. BEGIN (* Display_A_Line *)
  95.  
  96.    I := Line_Ptrs[LineNo];
  97.    L := MIN( Max_Screen_Col , SUCC( Line_Lens[LineNo] - Left_Col ) );
  98.    Y := WhereY;
  99.  
  100.    FillChar( S[1], Max_Screen_Col, ' ' );
  101.  
  102.    IF ( L > 0 ) THEN
  103.       BEGIN
  104.  
  105.          I := PRED( I + Left_Col );
  106.          K := 0;
  107.          J := 0;
  108.  
  109.          REPEAT
  110.  
  111.             Ch   := Review_Buffer^[I];
  112.  
  113.             INC( K );
  114.  
  115.             IF ( I = Max_Review_Length ) THEN
  116.                I := 1
  117.             ELSE
  118.                INC( I );
  119.  
  120.             CASE ORD( Ch ) OF
  121.                BS   : J := MAX( 0 , PRED( J ) );
  122.                CR   : J := 0;
  123.                HT   : J := J + ( 8 - WhereX MOD 8 );
  124.                ELSE
  125.                       INC( J );
  126.                       S[J] := Ch;
  127.             END (* CASE *);
  128.  
  129.          UNTIL ( J >= Max_Screen_Col ) OR ( K >= L );
  130.  
  131.       END;
  132.  
  133.    S[0] := CHR( Max_Screen_Col );
  134.  
  135.    WriteSXY( S, 1, Y, Attrib );
  136.  
  137. END   (* Display_A_Line *);
  138.  
  139. (*----------------------------------------------------------------------*)
  140. (*          Search_Lines --- Search for text in review buffer           *)
  141. (*----------------------------------------------------------------------*)
  142.  
  143. PROCEDURE Search_Lines;
  144.  
  145. VAR
  146.    Local_Save_5 : Saved_Screen_Ptr;
  147.    I            : INTEGER;
  148.    J            : INTEGER;
  149.    K            : INTEGER;
  150.    L            : INTEGER;
  151.    Found        : BOOLEAN;
  152.    S            : AnyStr;
  153.  
  154. BEGIN (* Search_Lines *)
  155.  
  156.    CursorOn;
  157.  
  158.    Draw_Titled_Box( Local_Save_5, 10, 10, 65, 14, 'Search for text' );
  159.  
  160.    GoToXY( 1 , 1 );
  161.  
  162.    WRITE('String to search for? ');
  163.  
  164.    Read_Edited_String( Search_Text );
  165.    WRITELN;
  166.  
  167.    IF LENGTH( Search_Text ) > 0 THEN
  168.       Search_Str := UpperCase( Search_Text );
  169.  
  170.    IF LENGTH( Search_Str ) <= 0 THEN
  171.       BEGIN
  172.          Restore_Screen( Local_Save_5 );
  173.          EXIT;
  174.       END;
  175.  
  176.    Found := FALSE;
  177.    I     := SUCC( Top_Line );
  178.    K     := 0;
  179.  
  180.    REPEAT
  181.  
  182.       L := Line_Ptrs[I];
  183.  
  184.       FOR J := 1 TO Line_Lens[I] DO
  185.          BEGIN
  186.             S[J] := Review_Buffer^[L];
  187.             IF ( L = Max_Review_Length ) THEN
  188.                L := 1
  189.             ELSE
  190.                INC( L );
  191.          END;
  192.  
  193.       S[0] := CHR( Line_Lens[I] );
  194.  
  195.       IF ( POS( Search_Str , UpperCase( S ) ) > 0 ) THEN
  196.          BEGIN
  197.             Found    := TRUE;
  198.             Top_Line := I;
  199.             Bot_Line := MIN( Top_Line + 19 , Review_Len );
  200.             ReDraw   := TRUE;
  201.          END;
  202.  
  203.       INC( I );
  204.       IF( I > Review_Len ) THEN
  205.          I := 1;
  206.  
  207.       INC( K );
  208.  
  209.    UNTIL ( FOUND OR ( K > Review_Len ) );
  210.  
  211.    IF ( NOT Found ) THEN
  212.       BEGIN
  213.          WRITE('String not found.');
  214.          Window_Delay;
  215.       END;
  216.  
  217.    Restore_Screen_And_Colors( Local_Save_5 );
  218.  
  219.    TextColor( Menu_Text_Color );
  220.  
  221.    CursorOff;
  222.  
  223. END   (* Search_Lines *);
  224.  
  225. (*----------------------------------------------------------------------*)
  226. (*          Write_Out_Lines --- Write review buffer to text file        *)
  227. (*----------------------------------------------------------------------*)
  228.  
  229. PROCEDURE Write_Out_Lines;
  230.  
  231. VAR
  232.    I           : INTEGER;
  233.    J           : INTEGER;
  234.    K           : INTEGER;
  235.    Local_Save  : Saved_Screen_Ptr;
  236.    OK_File     : BOOLEAN;
  237.    Open_OK     : BOOLEAN;
  238.    File_Exists : BOOLEAN;
  239.    S           : AnyStr;
  240.  
  241. BEGIN (* Write_Out_Lines *)
  242.  
  243.    CursorOn;
  244.  
  245.    Draw_Titled_Box( Local_Save, 10, 10, 70, 16,
  246.                     'Write review buffer to file' );
  247.  
  248.    OK_File     := FALSE;
  249.    F_Name       := '';
  250.  
  251.    REPEAT
  252.  
  253.       Clear_Window;
  254.  
  255.       WRITELN('File name to write review buffer to: ');
  256.       WRITE('>');
  257.  
  258.       Read_Edited_String( F_Name );
  259.       WRITELN;
  260.  
  261.       ASSIGN( F , F_Name );
  262.          (*!I-*)
  263.       RESET( F );
  264.          (*!I+*)
  265.  
  266.       IF Int24Result = 0 THEN
  267.          BEGIN
  268.  
  269.             OK_File := YesNo('File ' + F_Name +
  270.                             ' already exists, append to it (Y/N) ? ');
  271.  
  272.             File_Exists := TRUE;
  273.  
  274.                (*!I-*)
  275.             CLOSE( F );
  276.                (*!I+*)
  277.  
  278.          END
  279.       ELSE
  280.          OK_File := TRUE;
  281.  
  282.    UNTIL ( OK_File ) OR ( LENGTH( F_Name ) = 0 );
  283.  
  284.    IF LENGTH( F_Name ) > 0 THEN
  285.       BEGIN
  286.             (*!I-*)
  287.          IF File_Exists THEN
  288.             Open_OK := Open_For_Append( F , F_Name , I )
  289.          ELSE
  290.             BEGIN
  291.                   (*!I-*)
  292.                 ASSIGN ( F , F_Name );
  293.                 REWRITE( F );
  294.                   (*!I+*)
  295.                 Open_OK := ( Int24Result = 0 );
  296.             END;
  297.  
  298.          IF ( NOT Open_OK ) THEN
  299.             BEGIN
  300.                WRITELN('Can''t open ',F_Name,' for output.');
  301.                WRITELN('Review buffer will not be written.');
  302.             END
  303.          ELSE
  304.             BEGIN
  305.  
  306.                WRITELN('Writing review buffer to ', F_Name );
  307.  
  308.                FOR I := 1 TO Review_Len DO
  309.                   BEGIN
  310.                      K := Line_Ptrs[I];
  311.                      FOR J := 1 TO Line_Lens[I] DO
  312.                         BEGIN
  313.                            S[J] := Review_Buffer^[K];
  314.                            IF ( K = Max_Review_Length ) THEN
  315.                               K := 1
  316.                            ELSE
  317.                               INC( K );
  318.                         END;
  319.                      S[0] := CHR( Line_Lens[I] );
  320.                      WRITELN( F , S );
  321.                   END;
  322.  
  323.                   (*!I-*)
  324.                CLOSE( F );
  325.                   (*!I+*)
  326.  
  327.             END;
  328.  
  329.       END (* Length( F_Name ) > 0 *);
  330.  
  331.    Restore_Screen_And_Colors( Local_Save );
  332.  
  333.    TextColor( Menu_Text_Color );
  334.  
  335.    CursorOff;
  336.  
  337. END   (* Write_Out_Lines *);
  338.  
  339. (*----------------------------------------------------------------------*)
  340.  
  341. PROCEDURE Get_Line_Offsets( VAR Review_Len : INTEGER );
  342.  
  343. VAR
  344.    I     : LONGINT;
  345.    IStart: LONGINT;
  346.    L     : LONGINT;
  347.    Done  : BOOLEAN;
  348.    Head_1: LONGINT;
  349.  
  350. BEGIN (* Get_Line_Offsets *)
  351.  
  352.    Review_Len   := 1;
  353.    Line_Ptrs[1] := Review_Tail;
  354.    I            := Review_Tail;
  355.  
  356.    IF ( Head_1 = Max_Review_Length ) THEN
  357.       Head_1 := 1
  358.    ELSE
  359.       Head_1 := SUCC( Review_Head );
  360.  
  361.    Done := FALSE;
  362.  
  363.    REPEAT
  364.  
  365.       IStart := PRED( I );
  366.       IF ( IStart < 1 ) THEN
  367.          IStart := IStart + PRED( Max_Review_Length );
  368.  
  369.       WHILE ( ( Review_Buffer^[I] <> CHR( CR )  ) AND
  370.               ( I <> IStart                     )     ) DO
  371.          BEGIN
  372.             IF ( I = Max_Review_Length ) THEN
  373.                I := 1
  374.             ELSE
  375.                INC( I );
  376.          END;
  377.  
  378.       L  := I - Line_Ptrs[Review_Len];
  379.       IF ( L < 0 ) THEN
  380.          L := L + PRED( Max_Review_Length );
  381.  
  382.       Line_Lens[Review_Len] := L;
  383.  
  384.       INC( Review_Len );
  385.  
  386.       INC( I , 2 );
  387.  
  388.       IF ( I > Max_Review_Length ) THEN
  389.          I := I - Max_Review_Length;
  390.  
  391.       Line_Ptrs[Review_Len] := I;
  392.       Done                  := Done OR ( I = Head_1 );
  393.  
  394.    UNTIL Done;
  395.  
  396.    DEC( Review_Len );
  397.  
  398. END   (* Get_Line_Offsets *);
  399.  
  400. (*----------------------------------------------------------------------*)
  401.  
  402. BEGIN (* Review_Captured_Text *)
  403.                                    (*  No status line time check    *)
  404.  
  405.    Save_Do_Status_Time := Do_Status_Time;
  406.    Do_Status_Time      := FALSE;
  407.                                    (* Turn off cursor               *)
  408.    CursorOff;
  409.  
  410.                                    (*  Save current screen contents *)
  411.    Save_Screen( Saved_Screen );
  412.  
  413.    PibTerm_Window( 1, 1, Max_Screen_Col, Max_Screen_Line );
  414.  
  415.                                    (*  Clear screen                 *)
  416.  
  417.    Scroll( 1, Max_Screen_Line, 1, Max_Screen_Col, 0,
  418.            Global_ForeGround_Color, Global_BackGround_Color );
  419.  
  420.                                    (*  Draw split-screen bar        *)
  421.    TextColor( Menu_Text_Color_2 );
  422.  
  423.    Page_Len := Max_Screen_Line - 5;
  424.  
  425.    GoToXY( 1 , Page_Len + 2 );
  426.  
  427.    FOR I := 1 TO 29 DO
  428.       WRITE('=');
  429.  
  430.    TextColor( Menu_Text_Color );
  431.  
  432.    WRITE(' Review Captured Text ');
  433.  
  434.    TextColor( Menu_Text_Color_2 );
  435.  
  436.    FOR I := 1 TO 29 DO
  437.       WRITE('=');
  438.                                    (* Display instructions *)
  439.    GoToXY( 1 , Page_Len + 3 );
  440.  
  441.    WRITE('Esc');
  442.    TextColor( Menu_Text_Color );
  443.    WRITE('  to quit                ');
  444.    TextColor( Menu_Text_Color_2 );
  445.    WRITE( ^Z, '/', ^[, '  ');
  446.    TextColor( Menu_Text_Color );
  447.    WRITE('to go left/right ');
  448.    GoToXY( 53 , Page_Len + 3 );
  449.    TextColor( Menu_Text_Color_2 );
  450.    WRITELN('Current lines:   ');
  451.  
  452.    WRITE('PgUp/PgDn');
  453.    TextColor( Menu_Text_Color );
  454.    WRITE('  to page          ');
  455.    TextColor( Menu_Text_Color_2 );
  456.    WRITE('/  ');
  457.    TextColor( Menu_Text_Color );
  458.    WRITE('to scroll');
  459.    GoToXY( 53 , Page_Len + 4 );
  460.    TextColor( Menu_Text_Color_2 );
  461.    WRITELN('Current columns: ');
  462.  
  463.    TextColor( Menu_Text_Color_2 );
  464.    WRITE('Home/End');
  465.    TextColor( Menu_Text_Color );
  466.    WRITE('  first/last screen ');
  467.    TextColor( Menu_Text_Color_2 );
  468.    WRITE('S');
  469.    TextColor( Menu_Text_Color );
  470.    WRITE('  search for text');
  471.    GoToXY( 53 , Page_Len + 5 );
  472.    TextColor( Menu_Text_Color_2  );
  473.    WRITE('W  ');
  474.    TextColor( Menu_Text_Color );
  475.    WRITE('Write lines to file');
  476.  
  477.    TextColor( Menu_Text_Color );
  478.  
  479.    PibTerm_Window( 1, 1, Max_Screen_Col, SUCC( Page_Len ) );
  480.  
  481.                                    (* Not done yet                  *)
  482.    Quit     := FALSE;
  483.                                    (* Text color for display        *)
  484.    TextColor( Menu_Text_Color );
  485.    Attrib   := BackGround_Color SHL 4 + Menu_Text_Color;
  486.  
  487.                                    (* Start columns 1 through 80    *)
  488.    Left_Col  := 1;
  489.    Right_Col := Max_Screen_Col;
  490.                                    (* No current search string      *)
  491.    Search_Text := '';
  492.                                    (* Get line offsets in buffer    *)
  493.    Get_Line_Offsets( Review_Len );
  494.                                    (* Last line                     *)
  495.    Bot_Line := Review_Len;
  496.    Top_Line := MAX( SUCC( Bot_Line - Page_Len ) , 1 );
  497.    Redraw   := TRUE;
  498.                                    (* List buffer contents          *)
  499.    REPEAT
  500.                                    (* Display current page          *)
  501.  
  502.       Bot_Line := MIN( PRED( Top_Line + Page_Len ) , Review_Len );
  503.       L        := 0;
  504.  
  505.       IF Redraw THEN
  506.          BEGIN
  507.  
  508.             FOR I := Top_Line TO Bot_Line DO
  509.                BEGIN
  510.                   INC( L );
  511.                   GoToXY( 1 , L );
  512.                   Display_A_Line( I );
  513.                END;
  514.  
  515.             FOR I := SUCC( L ) TO Page_Len DO
  516.                BEGIN
  517.                   GoToXY( 1 , I );
  518.                   ClrEol;
  519.                END;
  520.  
  521.          END;
  522.                                    (* Assume no need to redraw screen *)
  523.       Redraw := FALSE;
  524.                                    (* Indicate which lines displayed  *)
  525.       Update_Lines_Displayed;
  526.                                    (* Read command                  *)
  527.       Read_Kbd_Old( Ch );
  528.  
  529.       IF ( ORD( Ch ) = ESC ) AND ( NOT PibTerm_KeyPressed ) THEN
  530.          Quit := TRUE
  531.       ELSE
  532.          BEGIN
  533.  
  534.             IF ( ORD( Ch ) = ESC ) THEN
  535.                Read_Kbd_Old( Ch );
  536.  
  537.             CASE ORD( Ch ) OF
  538.  
  539.                L_Arrow:  BEGIN (* Left arrow -- move 10 cols to left *)
  540.                             Left_Col  := MAX( Left_Col - 10 , 1 );
  541.                             Right_Col := MIN( Left_Col + PRED( Max_Screen_Col ) ,
  542.                                               Max_Review_Line_Length );
  543.                             ReDraw    := TRUE;
  544.                          END;
  545.  
  546.                R_Arrow:  BEGIN (* Right arrow -- move 10 cols to right *)
  547.                             Left_Col  := MIN( Left_Col + 10 ,
  548.                                               Max_Review_Line_Length );
  549.                             Right_Col := MIN( Left_Col + PRED( Max_Screen_Col ) ,
  550.                                               Max_Review_Line_Length );
  551.                             ReDraw    := TRUE;
  552.                          END;
  553.  
  554.                U_Arrow:  BEGIN (* Up Arrow -- scroll up one line *)
  555.  
  556.                             IF Top_Line > 1 THEN
  557.                                BEGIN
  558.  
  559.                                    (* Make room for new line *)
  560.  
  561.                                   GoToXY( 1 , 1 );
  562.                                   Scroll( 1, Page_Len,
  563.                                           1, Max_Screen_Col, -1,
  564.                                           Menu_Text_Color,
  565.                                           BackGround_Color );
  566.  
  567.                                   DEC( Top_Line );
  568.                                   DEC( Bot_Line );
  569.  
  570.                                   Display_A_Line( Top_Line );
  571.  
  572.                                END;
  573.  
  574.                          END   (* Up Arrow *);
  575.  
  576.                D_Arrow:  BEGIN (* Down Arrow -- scroll down one line *)
  577.  
  578.                             IF Bot_Line < Review_Len THEN
  579.                                BEGIN
  580.  
  581.                                    (* Make room for new line *)
  582.  
  583.                                   GoToXY( 1 , 1 );
  584.                                   Scroll( 1, Page_Len,
  585.                                           1, Max_Screen_Col, 1,
  586.                                           Menu_Text_Color,
  587.                                           BackGround_Color );
  588.  
  589.                                   INC( Top_Line );
  590.                                   INC( Bot_Line );
  591.  
  592.                                   GoToXY( 1 , SUCC( Bot_Line - Top_Line ) );
  593.                                   Display_A_Line( Bot_Line );
  594.  
  595.                                END;
  596.  
  597.                          END   (* Down Arrow *);
  598.  
  599.                PgUp:     BEGIN (* PgUp -- move up one page *)
  600.  
  601.                             IF ( Top_Line > 1 ) THEN
  602.                                BEGIN
  603.                                   Redraw := TRUE;
  604.                                   Top_Line := MAX( Top_Line - Page_Len , 1 );
  605.                                END;
  606.  
  607.                          END   (* PgUp *);
  608.  
  609.                PgDn:     BEGIN (* PgDn -- move down one page *)
  610.  
  611.                             IF ( SUCC( Bot_Line ) < Review_Len ) THEN
  612.                                BEGIN
  613.                                   Redraw := TRUE;
  614.                                   Top_Line := SUCC( Bot_Line );
  615.                                END;
  616.  
  617.                          END   (* PgDn *);
  618.  
  619.                Home:     BEGIN (* Home -- move to top of buffer *)
  620.  
  621.                             Top_Line := 1;
  622.                             Redraw   := TRUE;
  623.  
  624.                          END   (* Home *);
  625.  
  626.                End_Key:  BEGIN (* End -- move to end of buffer *)
  627.                             Bot_Line := Review_Len;
  628.                             Top_Line := MAX( SUCC( Bot_Line - Page_Len ) , 1 );
  629.                             Redraw   := TRUE;
  630.                          END   (* End *);
  631.  
  632.                (* W, w *)
  633.                87, 119 : Write_Out_Lines;
  634.  
  635.                (* S, s *)
  636.                83, 115 : Search_Lines;
  637.  
  638.                ELSE                (* Sound bell for bad input *)
  639.  
  640.                          Menu_Beep;
  641.  
  642.             END (* CASE *);
  643.  
  644.          END;
  645.  
  646.    UNTIL Quit;
  647.  
  648.    CursorOn;
  649.  
  650.    Restore_Screen_And_Colors( Saved_Screen );
  651.  
  652.    Do_Status_Time := Save_Do_Status_Time;
  653.  
  654. END   (* Review_Captured_Text *);
  655.