home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / PIBTERM / PIBT41S4.ARC / VIEWSUB2.MOD < prev    next >
Encoding:
Text File  |  1988-03-21  |  27.7 KB  |  776 lines
  1. (*---------------------------------------------------------------------------*)
  2. (*                 Format_Line -- Format text for screen display             *)
  3. (*---------------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Format_Line( Txt: AnyStr; ScrLin : INTEGER );
  6.  
  7. (*---------------------------------------------------------------------------*)
  8. (*                                                                           *)
  9. (*     Routine:  Format_Line                                                 *)
  10. (*                                                                           *)
  11. (*     Purpose:  Format text for screen display                              *)
  12. (*                                                                           *)
  13. (*     Calling Sequence:                                                     *)
  14. (*                                                                           *)
  15. (*        Format_Line( Txt: AnyStr; ScrLin: INTEGER );                       *)
  16. (*                                                                           *)
  17. (*           Txt    --- The text to be displayed                             *)
  18. (*           ScrLin --- Screen row  of 'Txt'                                 *)
  19. (*                                                                           *)
  20. (*     Calls:       TextColor                                                *)
  21. (*                                                                           *)
  22. (*     Called By:   Display_Screen                                           *)
  23. (*                                                                           *)
  24. (*     Remarks:                                                              *)
  25. (*                                                                           *)
  26. (*        Up to a maximum of 'width' characters will be displayed            *)
  27. (*        starting at 'First_Col'.  Column one is always displayed           *)
  28. (*        if line-printer controls are requested.  Unprintable               *)
  29. (*        characters are printed as their ASCII mnemonics enclosed           *)
  30. (*        in angular brackets.                                               *)
  31. (*                                                                           *)
  32. (*---------------------------------------------------------------------------*)
  33.  
  34. TYPE
  35.    My_Line_Type = ARRAY[1..264] OF CHAR;
  36.  
  37. VAR
  38.    I       : INTEGER;
  39.    J       : INTEGER;
  40.    N       : INTEGER;
  41.    Len     : INTEGER;
  42.    C       : CHAR;
  43.    IPos    : INTEGER;
  44.    LColor  : CHAR;
  45.    My_Line : My_Line_Type;
  46.    Spec_C  : CHAR;
  47.  
  48. BEGIN  (* Format_Line *)
  49.  
  50.    Len  := LENGTH( Txt );
  51.  
  52.    IPos := 1;
  53.                                    (* If this line is string-search *)
  54.                                    (* result, high-light it.        *)
  55.  
  56.    IF ( ScrLin = Search_Lpos ) THEN
  57.       BEGIN
  58.          LColor      := CHR( Search_Color );
  59.          Spec_C      := CHR( Spec_Chars_Color_2 );
  60.          Search_Lpos := 0;
  61.       END
  62.    ELSE
  63.       BEGIN
  64.          LColor := CHR( Normal_Color     );
  65.          Spec_C := CHR( Spec_Chars_Color );
  66.       END;
  67.  
  68.    FillChar( My_Line, 2 * Max_Screen_Col, LColor );
  69.  
  70.    N := 0;
  71.    I := First_Col;
  72.                                    (* Insert each character into work line *)
  73.  
  74.    WHILE ( ( I <= Len ) AND ( N < Width ) ) DO
  75.       BEGIN
  76.  
  77.          C := Txt[I];
  78.  
  79.          INC( I );
  80.  
  81.          IF ( Spec_Chars[C] ) THEN
  82.             BEGIN
  83.                My_Line[ IPos + 1 ] := Spec_C;
  84.                My_Line[ IPos     ] := C;
  85.                INC( IPos , 2 );
  86.                INC( N );
  87.             END
  88.          ELSE
  89.             BEGIN
  90.                My_Line[ IPos ] := C;
  91.                INC( IPos , 2 );
  92.                INC( N );
  93.             END;
  94.  
  95.       END;
  96.  
  97.    WriteLXY( My_Line, 1, SUCC( ScrLin ), N );
  98.  
  99. END   (* Format_Line *);
  100.  
  101. (*---------------------------------------------------------------------------*)
  102. (*                Display_Screen -- Display formatted screen                 *)
  103. (*---------------------------------------------------------------------------*)
  104.  
  105. PROCEDURE Display_Screen;
  106.  
  107. (*---------------------------------------------------------------------------*)
  108. (*                                                                           *)
  109. (*     Routine:  Display_Screen                                              *)
  110. (*                                                                           *)
  111. (*     Purpose:  Displays formatted screen                                   *)
  112. (*                                                                           *)
  113. (*     Calling Sequence:                                                     *)
  114. (*                                                                           *)
  115. (*        Display_Screen;                                                    *)
  116. (*                                                                           *)
  117. (*     Calls:                                                                *)
  118. (*                                                                           *)
  119. (*        Read_Line                                                          *)
  120. (*        Format_Line                                                        *)
  121. (*        Move                                                               *)
  122. (*        PibTerm_Window                                                     *)
  123. (*        InsLine                                                            *)
  124. (*        DelLine                                                            *)
  125. (*        GoToXY                                                             *)
  126. (*                                                                           *)
  127. (*     Remarks:                                                              *)
  128. (*                                                                           *)
  129. (*        On entry Eod=FALSE if the viewing window contains at least one     *)
  130. (*        line.  In this case top points to the first line in the window.    *)
  131. (*        On exit Bot points to the Last Line in the window, and top_Line    *)
  132. (*        is equal to the Line number of the top Line in the window.  If     *)
  133. (*        the viewing window extends beyond the end of the file then the     *)
  134. (*        extra Line <End of file> is displayed.                             *)
  135. (*                                                                           *)
  136. (*        On entry Eod=TRUE if the viewing window is beyond the end of the   *)
  137. (*        file. In this case top points to the Last line in the buffer,      *)
  138. (*        which is the Last line in the file.  Only the message              *)
  139. (*        <End of file> is displayed.  On exit Bot=top and top_Line is       *)
  140. (*        the line number of the Last line in the file plus 1.               *)
  141. (*        The <END of file> message is considered in this case               *)
  142. (*        to be an "extra" line on the file with line number Max_Line+1.     *)
  143. (*        This gives proper behavior on subsequent backwards line and screen *)
  144. (*        skipping commands.                                                 *)
  145. (*                                                                           *)
  146. (*        Note:  Requests for 1 line up or down scrolls are handled          *)
  147. (*               as special cases.                                           *)
  148. (*                                                                           *)
  149. (*---------------------------------------------------------------------------*)
  150.  
  151. VAR
  152.    N       : INTEGER;
  153.    LineNo  : INTEGER;
  154.    Nothing : BOOLEAN;
  155.    Save_Bot: Line_Ptr;
  156.  
  157. (*---------------------------------------------------------------------------*)
  158.  
  159. PROCEDURE Display_Remaining_Lines( Do_Each : BOOLEAN );
  160.  
  161. BEGIN (* Display_Remaining_Lines *);
  162.  
  163.    WHILE ( N > 0 ) AND ( NOT Eod ) DO
  164.       BEGIN
  165.          INC( LineNo );
  166.          IF Do_Each THEN
  167.             Format_Line( Bot^.Txt, LineNo );
  168.          DEC( N );
  169.          Save_Bot := Bot;
  170.          IF ( N > 0 ) THEN
  171.             IF Bot = Last THEN
  172.                BEGIN
  173.                   Read_Line;
  174.                   Bot := Last;
  175.                END
  176.             ELSE
  177.                Bot := Bot^.Next;
  178.          Eod := ( Save_Bot = Bot );
  179.       END;
  180.  
  181. END   (* Display_Remaining_Lines *);
  182.  
  183. (*---------------------------------------------------------------------------*)
  184.  
  185. BEGIN  (* Display_Screen *)
  186.  
  187.    PibTerm_Window( 1 , 2 , Max_Screen_Col , PRED( PS_Size ) );
  188.  
  189.    Bot    := Top;
  190.    N      := Height;
  191.    LineNo := 0;
  192.  
  193.    IF ( One_Up AND ( Top^.Lnum = 1 ) ) THEN
  194.       One_Up := FALSE;
  195.  
  196.    IF Eod THEN
  197.       Top_Line := SUCC( Top^.Lnum )
  198.    ELSE
  199.       Top_Line := Top^.Lnum;
  200.  
  201.                                    (* Case one: scroll screen down 1 line *)
  202.    IF One_Up THEN
  203.       BEGIN
  204.  
  205.          Scroll( 2 , PRED( PS_Size ), 1, Max_Screen_Col, -1,
  206.                  ForeGround_Color, BackGround_Color );
  207.  
  208.          Format_Line( Bot^.Txt, 1 );
  209.  
  210.          Display_Remaining_Lines( FALSE );
  211.  
  212.       END
  213.                                    (* Case 2: Scroll screen up 1 line *)
  214.    ELSE IF One_Down THEN
  215.       BEGIN
  216.  
  217.          Scroll( 2 , PRED( PS_Size ), 1, Max_Screen_Col, 1,
  218.                  ForeGround_Color, BackGround_Color );
  219.  
  220.          Display_Remaining_Lines( FALSE );
  221.  
  222.          IF ( N <= 0 ) THEN
  223.             Format_Line( Bot^.Txt, LineNo )
  224.         ELSE
  225.            BEGIN
  226.               INC( LineNo );
  227.               Format_Line( '<End of File>', LineNo );
  228.               DEC( N );
  229.            END;
  230.  
  231.       END
  232.                                    (* Case 3:  Everything else *)
  233.    ELSE
  234.       BEGIN
  235.  
  236.          Scroll( 2 , PRED( PS_Size ), 1, Max_Screen_Col, 0,
  237.                  ForeGround_Color, BackGround_Color );
  238.  
  239.          Display_Remaining_Lines( TRUE );
  240.  
  241.          IF ( N > 0 ) THEN
  242.             BEGIN
  243.                INC( LineNo );
  244.                Format_Line( '<End of File>', LineNo );
  245.                DEC( N );
  246.             END;
  247.  
  248.       END;
  249.  
  250. END   (* Display_Screen  *);
  251.  
  252. (*----------------------------------------------------------------------*)
  253. (*          Get_View_Command --- Get viewing command key                *)
  254. (*----------------------------------------------------------------------*)
  255.  
  256. FUNCTION Get_View_Command : CHAR;
  257.  
  258. (*----------------------------------------------------------------------*)
  259. (*                                                                      *)
  260. (*   Function:    Get_View_Command                                      *)
  261. (*                                                                      *)
  262. (*   Purpose:     Gets viewing command key                              *)
  263. (*                                                                      *)
  264. (*   Calling sequence:                                                  *)
  265. (*                                                                      *)
  266. (*      Ch := Get_View_Command : CHAR;                                  *)
  267. (*                                                                      *)
  268. (*----------------------------------------------------------------------*)
  269.  
  270. VAR
  271.    C : CHAR;
  272.  
  273. BEGIN (* Prompt *)
  274.                                    (* Toss stuff in keyboard to try *)
  275.                                    (* to avoid keyboard overflow    *)
  276.    WHILE( PibTerm_KeyPressed ) DO
  277.       Read_Kbd_Old( C );
  278.                                    (* Get command character *)
  279.    Read_Kbd_Old( C );
  280.                                    (* Convert to upper case *)
  281.    C := UpCase( C );
  282.                                    (* Convert keypad keys and WordStar *)
  283.                                    (* commands to letters              *)
  284.    CASE C OF
  285.  
  286.       ^[   : IF PibTerm_KeyPressed THEN
  287.                 BEGIN
  288.  
  289.                    Read_Kbd_Old( C );
  290.  
  291.                    CASE ORD( C ) OF
  292.  
  293.                      PgUp:    C := 'B';
  294.                      PgDn:    C := 'F';
  295.                      U_Arrow: C := 'U';
  296.                      D_Arrow: C := 'D';
  297.                      L_Arrow: C := '<';
  298.                      R_Arrow: C := '>';
  299.                      End_Key: C := 'E';
  300.                      Home:    C := 'T';
  301.                      ELSE     C := 'Z';
  302.  
  303.                   END (* CASE *)
  304.  
  305.                 END;
  306.  
  307.       ' '  : C := ^M;
  308.  
  309.       ^M   ,
  310.       'S'  ,
  311.       'N'  ,
  312.       'L'  : ;
  313.  
  314.       ^E   : C := 'U';
  315.       ^X   : C := 'D';
  316.       ^S   : C := '<';
  317.       ^D   : C := '>';
  318.       ^T   : C := 'B';
  319.       ^Z   : C := 'F';
  320.       ^Q   : C := 'T';
  321.       ^L   : C := 'E';
  322.  
  323.       ELSE   C := 'Z';
  324.  
  325.    END (* CASE *);
  326.                                    (* Return command character *)
  327.    Get_View_Command := C;
  328.  
  329. END   (* Get_View_Command *);
  330.  
  331. (*----------------------------------------------------------------------*)
  332. (*                   Prompt --- Prompt for Command Entry                *)
  333. (*----------------------------------------------------------------------*)
  334.  
  335. PROCEDURE Prompt;
  336.  
  337. (*----------------------------------------------------------------------*)
  338. (*                                                                      *)
  339. (*   Procedure:   Prompt                                                *)
  340. (*                                                                      *)
  341. (*   Purpose:     Prompts for, reads, parses, and executes command.     *)
  342. (*                                                                      *)
  343. (*   Calling sequence:                                                  *)
  344. (*                                                                      *)
  345. (*      Prompt;                                                         *)
  346. (*                                                                      *)
  347. (*----------------------------------------------------------------------*)
  348.  
  349. VAR
  350.    Legal   : BOOLEAN;
  351.    Question: BOOLEAN;
  352.    C       : CHAR;
  353.    SNum    : STRING[6];
  354.    SCol    : STRING[6];
  355.    N       : LONGINT;
  356.  
  357. BEGIN (* Prompt *)
  358.  
  359.    REPEAT
  360.  
  361.       Legal    := TRUE;
  362.       Question := FALSE;
  363.                                    (* Update line/column display *)
  364.       STR( Bot^.LNum : 6 , SNum );
  365.       STR( First_Col : 5 , SCol );
  366.  
  367.       WriteSXY( ' Line' + SNum + '   Column' + SCol, 1, PS_Size,
  368.                 Status_Line_Color );
  369.  
  370.                                    (* Not single line move yet *)
  371.       One_Up   := FALSE;
  372.       One_Down := FALSE;
  373.                                    (* Get and execute next command request *)
  374.       CASE Get_View_Command OF
  375.  
  376.          'U'  : BEGIN
  377.                    Find_Line( RMax( PRED( Top_Line ) , 1 ) );
  378.                    One_Up := TRUE;
  379.                 END;
  380.          'D'  : BEGIN
  381.                    Find_Line( SUCC( Top_Line ) );
  382.                    One_Down := TRUE;
  383.                 END;
  384.          'F'  : Find_Line( Top_Line + Height );
  385.          'B'  : Find_Line( RMAX( Top_Line - Height , 1 ) );
  386.          'T'  : Find_Line( 1 );
  387.          'E'  : Find_Line( 99999999 );
  388.          '<'  : BEGIN
  389.                    First_Col := RMax( PRED( First_Col ) , 1 );
  390.                    Find_Line( Top_Line );
  391.                 END;
  392.          '>'  : BEGIN
  393.                    INC( First_Col );
  394.                    Find_Line( Top_Line );
  395.                 END;
  396.          ^M   : Find_Line( SUCC( Bot^.LNum ) );
  397.          'S'  : BEGIN
  398.                    Get_Search_String;
  399.                    Find_Line( RMAX( SUCC( Search_Line ) , Top^.LNum ) );
  400.                    Find_String( Search_Str );
  401.                 END;
  402.          'N'  : BEGIN
  403.                    Find_Line( RMAX( SUCC( Search_Line ) , Top^.LNum ) );
  404.                    Find_String( Search_Str );
  405.                 END;
  406.          'L'  : BEGIN
  407.                    Get_Line_Number( N );
  408.                    IF ( N > 0 ) THEN
  409.                       Find_Line( N )
  410.                    ELSE
  411.                       Find_Line( Top_Line );
  412.                 END;
  413.          ^[   : BEGIN
  414.                    All_Done := TRUE;
  415.                    Done     := TRUE;
  416.                 END;
  417.          ELSE   Legal := FALSE;
  418.  
  419.       END (* CASE *);
  420.  
  421.       IF ( NOT Legal ) THEN
  422.          Menu_Beep;
  423.  
  424.    UNTIL ( Legal AND ( NOT Question ) );
  425.  
  426. END   (* Prompt *);
  427.  
  428. (*----------------------------------------------------------------------*)
  429. (*               Init_File --- Initialize File to be listed             *)
  430. (*----------------------------------------------------------------------*)
  431.  
  432. FUNCTION Init_File( VAR File_Spec: AnyStr ) : BOOLEAN;
  433.  
  434. (*----------------------------------------------------------------------*)
  435. (*                                                                      *)
  436. (*   Function:    Init_File                                             *)
  437. (*                                                                      *)
  438. (*   Purpose:     Initializes File to be listed                         *)
  439. (*                                                                      *)
  440. (*   Calling sequence:                                                  *)
  441. (*                                                                      *)
  442. (*      OK := Init_File( VAR File_Spec: AnyStr ) : BOOLEAN;             *)
  443. (*                                                                      *)
  444. (*         File_Spec: Name of file to be listed.                        *)
  445. (*                                                                      *)
  446. (*         OK = TRUE if file opened OK.                                 *)
  447. (*                                                                      *)
  448. (*----------------------------------------------------------------------*)
  449.  
  450. VAR
  451.    SFSize     : STRING[8];
  452.    SFDate     : STRING[8];
  453.    SFTime     : STRING[8];
  454.    SFName     : STRING[12];
  455.    File_Entry : SearchRec;
  456.  
  457. BEGIN (* Init_File *)
  458.                                    (* Attach file to be listed *)
  459.    FileMode     := 0;
  460.  
  461.    ASSIGN( F, File_Spec );
  462.    SetTextBuf( F , Sector_Data );
  463.    RESET( F );
  464.  
  465.    FileMode     := 2;
  466.                                     (* Reset file for I/O *)
  467.    Reset_F;
  468.                                     (* File OK *)
  469.    Init_File := TRUE;
  470.                                     (* Turn off cursor   *)
  471.    CursorOff;
  472.                                     (* Clear screen      *)
  473.  
  474.    Scroll( 1, PS_Size, 1, Max_Screen_Col, 0,
  475.            ForeGround_Color, BackGround_Color );
  476.  
  477.                                    (* Set color in status line *)
  478.  
  479.    WriteSXY( DUPL( ' ', Max_Screen_Col ), 1,  PS_Size,
  480.              Status_Line_Color );
  481.  
  482.                                    (* Write options in status line *)
  483.  
  484.    WriteSXY( CHR( 24 ) + '/' + CHR( 25 ) + '/' +
  485.              CHR( 26 ) + '/' + CHR( 27 ) + '/' +
  486.              'PgUp/PgDn/Home/End/S/N/L/<ESC>', 40, PS_Size, Status_Line_Color );
  487.  
  488.                                    (* Set color in file name line *)
  489.  
  490.    WriteSXY( DUPL( ' ', Max_Screen_Col ), 1,  1,
  491.              Status_Line_Color );
  492.                                     (* Display file spec *)
  493.  
  494.    FindFirst( File_Spec, AnyFile, File_Entry );
  495.  
  496.    WITH File_Entry DO
  497.       BEGIN
  498.          SFName := Name;
  499.          STR( Size , SFSize );
  500.          SFSize := SFSize + DUPL( ' ' , 8 - LENGTH( SFSize ) );
  501.          Dir_Convert_File_Date_And_Time( Time, SFDate, SFTime );
  502.       END;
  503.  
  504.    WriteSXY( 'File: '    + SFName +
  505.              '     Size: ' + SFSize +
  506.              '   Date: ' + SFDate +
  507.              '   Time: ' + SFTime,
  508.              1, 1, Status_Line_Color );
  509.  
  510. END   (* Init_File *);
  511.  
  512. (*----------------------------------------------------------------------*)
  513. (*      Initialize_Viewing --- Initialize file viewing                  *)
  514. (*----------------------------------------------------------------------*)
  515.  
  516. FUNCTION Initialize_Viewing : BOOLEAN;
  517.  
  518. (*----------------------------------------------------------------------*)
  519. (*                                                                      *)
  520. (*   Function:    Initialize_Viewing                                    *)
  521. (*                                                                      *)
  522. (*   Purpose:     Initializes file viewing                              *)
  523. (*                                                                      *)
  524. (*   Calling sequence:                                                  *)
  525. (*                                                                      *)
  526. (*      OK := Initialize_Viewing : BOOLEAN;                             *)
  527. (*                                                                      *)
  528. (*         OK --- FALSE if not enough memory to hold buffered lines     *)
  529. (*                for file viewing.                                     *)
  530. (*                                                                      *)
  531. (*----------------------------------------------------------------------*)
  532.  
  533. VAR
  534.    I:         INTEGER;
  535.    J:         INTEGER;
  536.    K:         INTEGER;
  537.    Len:       INTEGER;
  538.    Last_Col:  INTEGER;
  539.    P:         Line_Ptr;
  540.    Param_Str: AnyStr;
  541.    Ch       : CHAR;
  542.  
  543. BEGIN  (* Initialize_Viewing *)
  544.  
  545.    Max_Line     := 0;
  546.    Done         := FALSE;
  547.    Eod          := FALSE;
  548.    Width        := Max_Screen_Col;
  549.    Expand_Tabs  := FALSE;
  550.    Strip_High   := FALSE;
  551.    File_Pattern := '';
  552.  
  553.    PS_Size      := Max_Screen_Line;
  554.  
  555.    FOR Ch := CHR(0) TO CHR(31) DO
  556.       Spec_Chars[Ch] := TRUE;
  557.  
  558.    FOR Ch := CHR(32) TO CHR(255) DO
  559.       Spec_Chars[Ch] := FALSE;
  560.  
  561.    Spec_Chars[#127] := TRUE;
  562.                                    (* Figure # of lines that will fit   *)
  563.                                    (* in memory.                        *)
  564.  
  565.    Max_Buf_Lines := MIN( 200 ,
  566.                          MAX( 0 ,
  567.                               TRUNC( ( MemAvail - 4000 ) DIV Max_String ) ) );
  568.  
  569.                                    (* If space for less than two screen- *)
  570.                                    (* fulls of lines, skip viewing.      *)
  571.  
  572.    IF ( Max_Buf_Lines < ( 2 * Max_Screen_Line ) ) THEN
  573.       BEGIN
  574.           WRITELN('Not enough memory to view file, viewing cancelled.');
  575.           Press_Any;
  576.           Initialize_Viewing := FALSE;
  577.           EXIT;
  578.       END;
  579.                                    (* Get the circular text line buffer *)
  580.    NEW( First );
  581.  
  582.    Last := First;
  583.  
  584.    FOR I := 1 TO PRED( Max_Buf_Lines ) DO
  585.       BEGIN
  586.          NEW( P );
  587.          Last^.Next := P;
  588.          Last       := P
  589.       END;
  590.  
  591.    Last^.Next := First;
  592.    Last       := NIL;
  593.                                    (* No current search string *)
  594.    Search_Str  := '';
  595.    Search_Line := 0;
  596.    Search_Lpos := 0;
  597.    Search_Col  := 0;
  598.  
  599.    One_Up      := FALSE;
  600.    One_Down    := FALSE;
  601.                                    (* Get height of display area *)
  602.    Height      := PS_Size - 2;
  603.                                    (* Set colors *)
  604.  
  605.    Normal_Color       := 16 * ( Background_Color AND 7 ) +
  606.                          ForeGround_Color;
  607.    Search_Color       := 16 * ( ForeGround_Color AND 7 ) +
  608.                          BackGround_Color;
  609.    Status_Line_Color  := 16 * ( Menu_Text_Color AND 7 ) +
  610.                          BackGround_Color;
  611.    Spec_Chars_Color   := Normal_Color;
  612.    Spec_Chars_Color_2 := Search_Color;
  613.    Help_Text_Color    := 16 * ( BackGround_Color AND 7 ) +
  614.                          Menu_Text_Color;
  615.  
  616.    Initialize_Viewing := TRUE;
  617.  
  618. END   (* Initialize_Viewing *);
  619.  
  620. (*----------------------------------------------------------------------*)
  621. (*          Init_This_File --- Initialize current file to be listed     *)
  622. (*----------------------------------------------------------------------*)
  623.  
  624. FUNCTION Init_This_File( File_Spec : AnyStr ) : BOOLEAN;
  625.  
  626. (*----------------------------------------------------------------------*)
  627. (*                                                                      *)
  628. (*   Function:    Init_This_File                                        *)
  629. (*                                                                      *)
  630. (*   Purpose:     Initializes current file to be listed                 *)
  631. (*                                                                      *)
  632. (*   Calling sequence:                                                  *)
  633. (*                                                                      *)
  634. (*      OK := Init_This_File( Dir_Entry : SearchRec );                  *)
  635. (*                                                                      *)
  636. (*         Dir_Entry: Directory record for file to be listed.           *)
  637. (*                                                                      *)
  638. (*         OK = TRUE if file OK to be listed.                           *)
  639. (*                                                                      *)
  640. (*----------------------------------------------------------------------*)
  641.  
  642. VAR
  643.    I:         INTEGER;
  644.    J:         INTEGER;
  645.    K:         INTEGER;
  646.    Len:       INTEGER;
  647.    Last_Col:  INTEGER;
  648.    P:         Line_Ptr;
  649.    Ch       : CHAR;
  650.  
  651. BEGIN (* Init_This_File *)
  652.                                    (* Get the file name to list and open it *)
  653.  
  654.    IF ( NOT Init_File( File_Spec ) ) THEN
  655.       BEGIN
  656.          Init_This_File := FALSE;
  657.          EXIT;
  658.       END
  659.    ELSE
  660.       Init_This_File := TRUE;
  661.  
  662.    I        := 1;
  663.    Last_Col := 1;
  664.    Last     := NIL;
  665.                                    (* Read in the First Max_Buf_Lines lines *)
  666.    REPEAT
  667.  
  668.       Read_Line;
  669.  
  670.       INC( I );
  671.  
  672.       Last_Col := MAX( Last_Col , LENGTH( Last^.Txt ) );
  673.  
  674.    UNTIL ( ( I = Max_Buf_Lines ) OR EOF( F ) );
  675.  
  676.    Top := First;
  677.  
  678.    J   := 1;
  679.  
  680.    IF ( Last_Col <= Width ) THEN
  681.       First_Col := J
  682.    ELSE
  683.       BEGIN
  684.  
  685.          P := First;
  686.          K := Max_String + 1;
  687.  
  688.          REPEAT
  689.  
  690.             I := J;
  691.  
  692.             WITH P^ DO
  693.                BEGIN
  694.  
  695.                   Len := LENGTH( P^.Txt );
  696.  
  697.                   WHILE ( ( I < Len ) AND ( Txt[I] IN [' ',FF] ) ) DO INC( I );
  698.  
  699.                   IF I < Len THEN K := MIN( K , I )
  700.  
  701.                END;
  702.  
  703.             P := P^.Next
  704.  
  705.          UNTIL ( P = Last^.Next );
  706.  
  707.          First_Col := MIN( K , Last_Col + J - Width );
  708.  
  709.      END;
  710.  
  711.    One_Up      := FALSE;
  712.    One_Down    := FALSE;
  713.  
  714. END   (* Init_This_File *);
  715.  
  716. (*----------------------------------------------------------------------*)
  717. (*          Release_Line_Buffer --- Release linked list of lines        *)
  718. (*----------------------------------------------------------------------*)
  719.  
  720. PROCEDURE Release_Line_Buffer;
  721.  
  722. VAR
  723.    P1: Line_Ptr;
  724.    P2: Line_Ptr;
  725.    I : INTEGER;
  726.  
  727. BEGIN (* Release_Line_Buffer *)
  728.  
  729.    P1 := First;
  730.  
  731.    FOR I := 1 TO PRED( Max_Buf_Lines ) DO
  732.       BEGIN
  733.          P2 := P1;
  734.          P1 := P1^.Next;
  735.          DISPOSE( P2 );
  736.       END;
  737.  
  738.    DISPOSE( P1 );
  739.  
  740. END   (* Release_Line_Buffer *);
  741.  
  742. (*----------------------------------------------------------------------*)
  743. (*             List_One_File --- P R O C E D U R E   B O D Y            *)
  744. (*----------------------------------------------------------------------*)
  745.  
  746. BEGIN (* List_One_File *)
  747.                                    (* General initialization *)
  748.  
  749.    IF ( NOT Initialize_Viewing ) THEN
  750.       EXIT;
  751.                                    (* Initialize file *)
  752.  
  753.    IF ( NOT Init_This_File( View_File_Name ) ) THEN
  754.       EXIT;
  755.                                    (* Not done with this file yet *)
  756.    Done := FALSE;
  757.                                    (* Loop until no more commands *)
  758.    WHILE ( NOT Done ) DO
  759.       BEGIN
  760.                                    (* Display screenful of lines  *)
  761.          Display_Screen;
  762.                                    (* Get input command *)
  763.          Prompt;
  764.  
  765.       END;
  766.                                    (* Close current file *)
  767.    CLOSE( F );
  768.  
  769.    IF ( Int24Result <> 0 ) THEN;
  770.                                    (* Release view buffer memory *)
  771.    Release_Line_Buffer;
  772.                                    (* Re-enable cursor           *)
  773.    CursorOn;
  774.  
  775. END   (* List_One_File *);
  776.