Trailing-Edge
-
PDP-10 Archives
-
BB-H138F-BM_1988
-
7-sources/scrupdate.bli
There are 10 other files named scrupdate.bli in the archive. Click here to see a list.
%TITLE 'SCRUPDATE - update the screen'
MODULE SCRUPDATE ( ! Update the screen
IDENT = '3-003' ! File: SCRUPDATE.BLI Edit: CJG3003
) =
BEGIN
!COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1981, 1988. ALL RIGHTS RESERVED.
!
!THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED ONLY
!IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE INCLUSION OF
!THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES THEREOF MAY
!NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER PERSON. NO TITLE
!TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY TRANSFERRED.
!
!THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
!SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
!
!DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
!SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.
!
!
!++
! FACILITY: EDT -- The DEC Standard Editor
!
! ABSTRACT:
!
! This module does a screen update.
!
! ENVIRONMENT: Runs at any access mode - AST reentrant
!
! AUTHOR: Bob Kushlis, CREATION DATE: September 8, 1979
!
! MODIFIED BY:
!
! 1-001 - Original. DJS 12-Feb-1981. This module was created by
! extracting the routine EDT$$SC_UPD from module SCREEN.
! 1-002 - Regularize headers. JBS 13-Mar-1981
! 1-003 - Make sure the [EOB] test is valid when scrolling backwards.
! JBS 17-Sep-1981
! 1-004 - Revise autorepeat subroutine call. JBS 30-Jan-1982
! 1-005 - Correct some spelling errors in comments. JBS 02-Apr-1982
! 1-006 - Use new flag for scrolling logic. JBS 02-Sep-1982
! 1-007 - Use the new screen structure and logic. SMB 21-Sep-1982
! 1-008 - Remove unused external declaration of EDT$$FMT_LIT. JBS 05-Oct-1982
! 1-009 - More debugging of screen scrolling and select. SMB 08-Oct-1982
! 1-010 - Debug NOTRUNCATE mode. JBS 12-Oct-1982
! 1-011 - Add insert and delete scrolling. SMB 13-Oct-1982
! 1-012 - Clear RECS_INSERTED. JBS 21-Oct-1982
! 1-013 - Scrolling debugging. SMB 21-Oct-1982
! 1-014 - Move the code for marking select changes for repaint. JBS 23-Oct-1982
! 1-015 - Simplify the logic that repaints the old screen. JBS 24-Oct-1982
! 1-016 - Make sure all lines off the screen are marked for repaint, and
! support non-scrolling-region terminals. JBS 24-Oct-1982
! 1-017 - Fix a performance problem with deselecting. JBS 24-Oct-1982
! 1-018 - Watch out for deleted lines when updating the old screen. JBS 24-Oct-1982
! 1-019 - Create UPDATE_LINE, so we can add fancy screen stuff for inserted and
! deleted lines. JBS 23-Oct-1982
! 1-021 - Add scrolling to inset and delete line code. SMB 25-Oct-1982
! 1-022 - Fix scrolling bug - add more notruncate code. SMB 27-Oct-1982
! 1-023 - If we delete the top line, make the next line top. JBS 01-Nov-1982
! 1-024 - Don't lose the line number if we must repaint but need not rebuild
! the screen data base. JBS 01-Nov-1982
! 1-025 - Add the call to EDT$$FIX_NOTRUNC. JBS 01-Nov-1982
! 1-026 - Fix a problem scrolling up on a small screen. JBS 02-Nov-1982
! 1-027 - Speed up deselecting. JBS 09-Nov-1982
! 1-028 - Rearrange select range processing. JBS 10-Nov-1982
! 1-029 - Watch out for deleting the last line of the screen. JBS 11-Nov-1982
! 1-030 - Recover from running out of memory. JBS 15-Nov-1982
! 1-031 - Fix bug with cuts on noscroll terminal. SMB 16-Nov-1982
! 1-032 - Fix notruncate bugs. SMB 23-Nov-1982
! 1-033 - Worry about deleted lines. JBS 25-Nov-1982
! 1-034 - Make a few efficiency improvements. JBS 02-Dec-1982
! 1-035 - Add two paramaters to the SC_LNINS routine. SMB 03-Dec-1982
! 1-036 - Change calculation of distance to select line. STS 07-Dec-1982
! 1-037 - When scrolling down, if we do not have scrolling regions
! erase the line that should have scrolled out of view. JBS 14-Dec-1982
! 1-038 - Fix small bugs with boundary conditions. SMB 20-Dec-1982
! 1-039 - Remove the edit buffer. JBS 27-Dec-1982
! 1-040 - Do less repainting on select. JBS 27-Dec-1982
! 1-041 - Add a missing dot in edit 1-040. JBS 28-Dec-1982
! 1-042 - Collapse inserts and deletes together. JBS 28-Dec-1982
! 1-043 - Add more TOP logic, to recover from rebuilds better. JBS 29-Dec-1982
! 1-044 - Fix a bug that caused unnecessary rebuilding in NOTRUNCATE mode. JBS 30-Dec-1982
! 1-045 - Modify setting of scrolling regions for multiple inserts. SMB 30-Dec-1982
! 1-046 - Bug fixes on setting of top and more multiple insert work. SMB 05-Jan-198f
! 1-047 - Fix bugs introduced in edit 046. SMB 11-Jan-1983
! 1-048 - Bug fixes for "moving window" problems on deletes. SMB 14-Jan-1983
! 1-049 - Worry about deleting the only line in the buffer. JBS 18-Jan-1983
! 1-050 - Fix painting select regions on continuation lines. JBS 19-Jan-1983
! 1-051 - Be more cautious about using the old cursor line after a rebuild. JBS 20-Jan-1983
! 1-052 - Fix scrolling problems for NOSCROLL terminals. SMB 25-Jan-1983
! 1-053 - Repair backwards scrolling bug introduced by edit 1-052. SMB 26-Jan-1983
! 1-054 - We were updating the screen wrong if all of the following happened:
! 1) we reset the screen, 2) we show the current position, and 3) we
! must jump to, rather than scroll to, the new position. In showing
! the new position we should not assume that the screen is still erased. JBS 28-Jan-1983
! 1-055 - Fix unreversing of backward select ranges. JBS 28-Jan-1983
! 1-056 - Fix VT52 erase to end of screen bug with messages. SMB 01-Feb-1983
! 1-057 - Avoid excess repainting after a CUT that crosses a line boundry. JBS 25-Feb-1983
! 1-058 - Don't initialize the screen so often. JBS 02-Mar-1983
! 1-059 - Mark the select region better on continued lines. JBS 07-Mar-1983
! 3-001 - Add updates from V3 sources. GB 03-May-1983
! 3-002 - Fix translation bug in TOP command. CJG 6-Oct-1983
! 3-003 - Modify ASSERT macro to include error code. CJG 30-Jan-1984
!--
%SBTTL 'Declarations'
!
! TABLE OF CONTENTS:
!
REQUIRE 'EDTSRC:TRAROUNAM';
FORWARD ROUTINE
EDT$$SC_UPD : NOVALUE,
DELETE_LINE,
INSERT_LINE;
!
! INCLUDE FILES:
!
REQUIRE 'EDTSRC:EDTREQ';
!
! MACROS:
!
! NONE
!
! EQUATED SYMBOLS:
!
! NONE
!
! OWN STORAGE:
!
! NONE
!
! EXTERNAL REFERENCES:
!
! In the routine
%SBTTL 'EDT$$SC_UPD - update the screen'
GLOBAL ROUTINE EDT$$SC_UPD ! Update the screen
: NOVALUE =
!++
! FUNCTIONAL DESCRIPTION:
!
! This routine is called to do a screen update. Most of the work done
! by this routine involves deciding on whether or not scrolling should
! be done. Basically, it figures out which line should be on the top
! of the screen, then determines how far away from the current line it
! has moved. The actual update is handled by the EDT$$SC_RFRELN routine.
!
! FORMAL PARAMETERS:
!
! NONE
!
! IMPLICIT INPUTS:
!
! OLD_SEL
! LNO_EMPTY
! SCR_REBUILD
! EOB_SCRPTR
! SCR_CHGD
! LN_BUF
! LST_SCRPTR
! CUR_SCRPTR
! WK_LN
! EOB_LN
! SCR_BUF
! FST_SCRPTR
! CS_CHNO
! CS_OLDCHNO
! CS_LN
! CS_LNO
! CUR_COL
! LN_NO
! SEL_BUF
! TOP_LN
! CUR_BUF
! SCR_LNS
! SCLL_TOP
! SCLL_BOT
! TI_TYP
! LN_PTR
! TI_SCROLL
! CSR_SCRPTR
! TOP_SCRPTR
! BOT_SCRPTR
! CUR_SCRLN
! FST_AVLN
! TRUN
! RECS_INSERTED
! BOT_LINE
!
! IMPLICIT OUTPUTS:
!
! OLD_SEL
! SCR_REBUILD
! CSR_SCRPTR
! TOP_SCRPTR
! CUR_SCRLN
! SEL_BUF
! CS_CHNO
! CS_OLDCHNO
! CS_LN
! CS_LNO
! LN_NO
! TOP_LN
! CUR_COL
! RECS_INSERTED
! FST_AVLN
! BOT_SCRPTR
! MEM_CNT
! BOT_LINE
!
! ROUTINE VALUE:
!
! NONE
!
! SIDE EFFECTS:
!
! MANY
!
!--
BEGIN
EXTERNAL ROUTINE
EDT$$CMP_LNO, ! Compare line numbers
EDT$$SC_SETSCLLREG, ! Set the scrolling region
EDT$$SC_LNINS, ! Insert a record into the screen data base
EDT$$FMT_LIT, ! Output a literal string
EDT$$SC_FNDREC, ! Find the current screen pointer
EDT$$OUT_FMTBUF, ! Output the format buffer to the screen
EDT$$RPL_CHGDLN, ! Replace a modified line in the work file
EDT$$SC_INIT, ! Initialize the screen
EDT$$SC_CPUCSPOS : NOVALUE, ! Compute the cursor position
EDT$$SC_POSCSIF : NOVALUE, ! Position the cursor
EDT$$SC_ERAALL : NOVALUE, ! Erase the screen
EDT$$SC_MOVTOLN, ! Move to a record in the work file relative to the current record
EDT$$SC_RFRELN : NOVALUE, ! Refresh a screen lint
EDT$$SC_NONREVID : NOVALUE, ! Put the screen in normal video mode
EDT$$SC_REPAINT : NOVALUE, ! Mark some lines in the screen data base for repaint
EDT$$TI_ENBLAUTREP : NOVALUE, ! Enable or disable autorepeat
EDT$$FIX_NOTRUNC : NOVALUE; ! Fix screen data base in NOTRUNCATE mode
EXTERNAL
BOT_SCRPTR : REF SCREEN_LINE, ! Address of bottom screen line
OLD_SEL, ! Address of old select buffer
LNO_EMPTY : LN_BLOCK, ! Code for empty line
SCR_REBUILD, ! Rebuild the screen
EOB_SCRPTR : REF SCREEN_LINE, ! EOB screen pointer
SCR_CHGD, ! non-zero = the screen has been mangled
MESSAGE_LINE, ! Message line
LN_BUF, ! Start of line buffer
CSR_SCRPTR : REF SCREEN_LINE, ! Current cursor line screen info
CUR_SCRPTR : REF SCREEN_LINE, ! Current workfile line screen pointer
LST_SCRPTR : REF SCREEN_LINE, ! Last data structure pointer
WK_LN : REF LIN_BLOCK, ! Pointer to current line in work file
EOB_LN, ! Special structure for [EOB] line
SCR_BUF : REF TBCB_BLOCK, ! Current screen buffer
FST_SCRPTR : REF SCREEN_LINE, ! First screen line info address
TOP_SCRPTR : REF SCREEN_LINE, ! Top screen line info address
CUR_SCRLN : LN_BLOCK, ! Current screen line record number
CS_CHNO, ! character position of cursor
CS_OLDCHNO, ! Previous character position of cursor
CS_LN : LN_BLOCK, ! record number of cursor line
CS_LNO, ! current cursor line
CUR_COL, ! current cursor column
LN_NO, ! current line number.
SEL_POS, ! select character position
SEL_LN : LN_BLOCK, ! select record
SEL_BUF, ! select buffer.
TOP_LN : LN_BLOCK, ! Line number of enforced top line.
CUR_BUF : REF TBCB_BLOCK, ! The current buffer tbcb.
SCR_LNS, ! No of lines on screen
SCLL_TOP, ! Top line for scrolling up
SCLL_BOT, ! Bottom line for scrolling down
TI_TYP, ! Terminal type.
LN_PTR, ! Current character pointer.
TI_SCROLL, ! 1 = we have scrolling regions
RECS_INSERTED, ! Number of records inserted since the last screen update
FST_AVLN : REF SCREEN_LINE, ! List of available screen line data blocks
TRUN, ! 0 = SET NOTRUNCATE
MEM_CNT, ! Number of lines in the screen data base
LNO0, ! Line number of 1
BOT_LINE; ! All lines below this one have been erased
LOCAL
DOLOOPS, ! Code bypass flag
TOP_DIST, ! Displacement to top scrptr
TEMP_LINE : LN_BLOCK, ! Temp line number
TOP_DISP, ! Top line displacement from current
DIR, ! Direction of motion since last screen update
SCLL_NUM, ! Scroll line limit
TOP_SET, ! Top record successfully set
DISP, ! Displacement from cursor screen line
ABOVE, ! Number of lines above current
BUILD_SCR, ! Flag which says rebuild screen
SCRPTR : REF SCREEN_LINE, ! Address of a current screen line buffer
CURSOR_POS, ! Column position of cursor
CURSOR_LINE, ! Number of screen lines before cursor.
BELOW, ! No. of screen lines below cursor line.
REC_NO, ! Current relative reocrd number
OLD_TOP_RECNO, ! Rel record number of old top record
OLD_BOT_RECNO, ! Rel record number of old bottom record
TOP_RECNO, ! Rel record number of new top record
TOP_PTR : REF SCREEN_LINE, ! Address of the top line on the screen
ERASE_ALL, ! 1 = we have erased the text part of the screen
LNINS_VAL; ! Value returned by EDT$$SC_LNINS
!+
! Make sure we are in normal video if no select range.
!-
IF (.SEL_BUF NEQA .CUR_BUF) THEN EDT$$SC_NONREVID ();
!+
! Remember the original character position and relative line number in
! work file terms.
!-
LN_NO = 0;
CS_CHNO = CH$DIFF (.LN_PTR, CH$PTR (LN_BUF,, BYTE_SIZE));
MOVELINE (CUR_BUF [TBCB_CUR_LIN], CS_LN);
EDT$$RPL_CHGDLN ();
!+
! If we are in NOTRUNCATE mode, make sure lines get adjusted due to carry from
! or borrow to earlier lines.
!-
IF ( NOT .TRUN) THEN EDT$$FIX_NOTRUNC ();
SCRPTR = 0;
!+
! Compute the cursor position. We will recompute if we must rebuild the screen data base.
!-
EDT$$SC_CPUCSPOS (CURSOR_LINE, CURSOR_POS);
CURSOR_LINE = .CS_LNO;
!+
! If the screen has been mangled, or we have changed buffers, erase the screen and
! repaint all the lines.
!-
IF ((.SCR_CHGD NEQ 0) OR (.SCR_BUF NEQA .CUR_BUF))
THEN
BEGIN
!+
! Don't initialize the terminal unless it has been requested.
!-
IF (.SCR_CHGD EQL 2) THEN EDT$$SC_INIT ();
!+
! Erase the screen.
!-
CS_LNO = 0;
EDT$$SC_ERAALL ();
BOT_LINE = 0;
ERASE_ALL = 1;
END
ELSE
ERASE_ALL = 0;
!+
! Determine whether the screen structure has to be rebuilt.
!-
BUILD_SCR = .SCR_REBUILD;
!+
! If the current position is not in the screen data base, rebuild.
!-
IF ( NOT .BUILD_SCR)
THEN
BEGIN
CUR_SCRPTR = EDT$$SC_FNDREC (CH$DIFF (.LN_PTR, CH$PTR (LN_BUF,, BYTE_SIZE)), DISP);
IF ((.CUR_SCRPTR EQLA 0) OR (.TOP_SCRPTR [SCR_NXT_LINE] EQLA 0)) THEN BUILD_SCR = 1;
END;
!+
! Compute the direction of motion since the last screen update.
! If we have changed buffers, assume forward.
!-
IF ((EDT$$CMP_LNO (LNO_EMPTY, CUR_SCRLN) EQL 0) OR (.SCR_BUF NEQA .CUR_BUF))
THEN
DIR = 1
ELSE
DIR = EDT$$CMP_LNO (CS_LN, CUR_SCRLN);
IF ( NOT .BUILD_SCR)
THEN
BEGIN
IF ((.SEL_BUF NEQA .OLD_SEL) AND (.TI_TYP EQL TERM_VT100))
THEN
BEGIN
!+
! We have started or ended a selection. Repaint all selected or formerly selected lines.
!-
LOCAL
CHAR_NO,
SELDIR,
REC_OFFSET,
OUR_LINE : LN_BLOCK,
OUR_CHNO,
OUR_SCRPTR : REF SCREEN_LINE;
!+
! If this is a deselection we must repaint from the old line to the select line.
! If this is a selection we must repaint from the current line to the select line.
!-
IF (.SEL_BUF EQLA 0)
THEN
BEGIN
MOVELINE (CUR_SCRLN, OUR_LINE);
SUBLINE (CUR_SCRLN, CS_LN, TEMP_LINE);
REC_OFFSET = .(TEMP_LINE [LN_LO])<0, 18, 1>;
OUR_CHNO = .CS_OLDCHNO;
OUR_SCRPTR = .CSR_SCRPTR;
END
ELSE
BEGIN
MOVELINE (CS_LN, OUR_LINE);
REC_OFFSET = 0;
OUR_CHNO = .CS_CHNO;
OUR_SCRPTR = .CUR_SCRPTR;
END;
SUBLINE (OUR_LINE, SEL_LN, TEMP_LINE);
IF ((.TEMP_LINE [LN_HI] AND %O'400000') NEQ 0)
THEN
SELDIR = -1
ELSE
IF (.TEMP_LINE [LN_LO] NEQU 0) THEN SELDIR = 1 ELSE SELDIR = 0;
REC_NO = .(TEMP_LINE [LN_LO])<0, 18, 1> - .REC_OFFSET;
EDT$$SC_MOVTOLN (.REC_NO);
SCRPTR = EDT$$SC_FNDREC (CH$DIFF (.SEL_POS, CH$PTR (LN_BUF,, BYTE_SIZE)), DISP);
IF (.SCRPTR EQLA 0)
THEN
BUILD_SCR = 1
ELSE
BEGIN
CHAR_NO = CH$DIFF (.SEL_POS, CH$PTR (LN_BUF,, BYTE_SIZE));
IF (.SELDIR EQL 0)
THEN
BEGIN
IF (.CHAR_NO LSS .OUR_CHNO) !
THEN
EDT$$SC_REPAINT (.SCRPTR, !
.OUR_SCRPTR, !
.CHAR_NO - .SCRPTR [SCR_CHR_FROM],
.OUR_CHNO - .OUR_SCRPTR [SCR_CHR_FROM] - 1, 0)
ELSE
IF (.CHAR_NO GTR .OUR_CHNO) !
THEN
EDT$$SC_REPAINT (.OUR_SCRPTR, !
.SCRPTR, !
.OUR_CHNO - .OUR_SCRPTR [SCR_CHR_FROM], !
.CHAR_NO - .SCRPTR [SCR_CHR_FROM] - 1, 0);
END
ELSE
IF (.SELDIR GTR 0)
THEN
EDT$$SC_REPAINT (.OUR_SCRPTR, !
.SCRPTR, !
.OUR_CHNO - .OUR_SCRPTR [SCR_CHR_FROM], !
.CHAR_NO - .SCRPTR [SCR_CHR_FROM] - 1, 0)
ELSE
IF (.SELDIR LSS 0)
THEN
EDT$$SC_REPAINT (.SCRPTR, !
.OUR_SCRPTR, !
.CHAR_NO - .SCRPTR [SCR_CHR_FROM], !
.OUR_CHNO - .OUR_SCRPTR [SCR_CHR_FROM] - 1, 0)
ELSE
ASSERT (22, 0);
END;
END;
END;
IF ( NOT .BUILD_SCR)
THEN
BEGIN
IF ((.SEL_BUF EQLA .CUR_BUF) AND (.TI_TYP EQL TERM_VT100))
THEN
BEGIN
!+
! The select range is in the current buffer. Repaint lines between the previous
! and the current cursor, to be sure they are properly reversed or not.
!-
IF (.DIR LSS 0)
THEN
EDT$$SC_REPAINT (.CUR_SCRPTR, .CSR_SCRPTR,
.CS_CHNO - .CUR_SCRPTR [SCR_CHR_FROM],
.CS_OLDCHNO - .CSR_SCRPTR [SCR_CHR_FROM] - 1, 0)
ELSE
IF (.DIR GTR 0)
THEN
EDT$$SC_REPAINT (.CSR_SCRPTR, .CUR_SCRPTR,
.CS_OLDCHNO - .CSR_SCRPTR [SCR_CHR_FROM], !
.CS_CHNO - .CUR_SCRPTR [SCR_CHR_FROM] - 1, 0)
ELSE
IF (.CS_CHNO LSS .CS_OLDCHNO) !
THEN
EDT$$SC_REPAINT (.CUR_SCRPTR, !
.CSR_SCRPTR, !
.CS_CHNO - .CUR_SCRPTR [SCR_CHR_FROM],
.CS_OLDCHNO - .CSR_SCRPTR [SCR_CHR_FROM] - 1, 0)
ELSE
IF (.CS_CHNO GTR .CS_OLDCHNO) !
THEN
EDT$$SC_REPAINT (.CSR_SCRPTR, !
.CUR_SCRPTR, !
.CS_OLDCHNO - .CSR_SCRPTR [SCR_CHR_FROM], !
.CS_CHNO - .CUR_SCRPTR [SCR_CHR_FROM] - 1, 0);
END;
END;
!+
! Mark all lines off the screen for repaint.
!-
IF ( NOT .BUILD_SCR)
THEN
BEGIN
!+
! If the screen has been erased we must repaint everything, otherwise only lines
! off the screen will need to be repainted. Marking the lines off the screen for
! repaint removes the deleted lines from the screen data base, to avoid confusing
! our count of the number of lines above and below the current line.
!-
IF .ERASE_ALL
THEN
EDT$$SC_REPAINT (.FST_SCRPTR, .LST_SCRPTR, 0, 255, 1)
ELSE
BEGIN
IF (.RECS_INSERTED GTR 0)
THEN
BEGIN
IF (.TOP_SCRPTR NEQA 0)
THEN
BEGIN
SCRPTR = .TOP_SCRPTR [SCR_PRV_LINE];
IF (.SCRPTR NEQA 0) THEN EDT$$SC_REPAINT (.FST_SCRPTR, .SCRPTR, 0, 255, 1);
END;
IF (.BOT_SCRPTR NEQA 0)
THEN
BEGIN
SCRPTR = .BOT_SCRPTR [SCR_NXT_LINE];
IF (.SCRPTR NEQA 0) THEN EDT$$SC_REPAINT (.SCRPTR, .LST_SCRPTR, 0, 255, 1);
END;
END;
END;
END;
!+
! If we have lost our record of the top of the screen we must rebuild.
!-
IF (.TOP_SCRPTR EQLA 0) THEN BUILD_SCR = 1;
IF ( NOT .BUILD_SCR)
THEN
BEGIN
!+
! Find the relative record number of the old cursor line.
! We must be careful of deleted lines. The convention is that a deleted line
! has the record number of the next lower line. This prevents deleted
! lines before record zero from having negative absolute record numbers.
!-
SCRPTR = .CUR_SCRPTR;
REC_NO = 0;
CASE .DIR FROM -1 TO 1 OF
SET
[1] :
BEGIN
!+
! The new line is after the old. We must move back in the work file.
!-
DO
BEGIN
IF ((.SCRPTR [SCR_LINE_IDX] EQL 0) OR !
((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0))
THEN
BEGIN
LOCAL
PREV_SCRPTR : REF SCREEN_LINE;
PREV_SCRPTR = .SCRPTR [SCR_PRV_LINE];
IF (.PREV_SCRPTR NEQA 0)
THEN
BEGIN
IF ((.PREV_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0)
THEN
REC_NO = .REC_NO - 1;
END;
END;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
END
UNTIL ((.SCRPTR EQLA .CSR_SCRPTR) OR (.SCRPTR EQLA 0));
END;
[0] :
BEGIN
!+
! We are positioned correctly in the work file.
!-
SCRPTR = .CSR_SCRPTR;
END;
[-1] :
BEGIN
!+
! The new line is before the old. We must move forward in the work file.
!-
DO
BEGIN
LOCAL
NEXT_SCRPTR : REF SCREEN_LINE;
NEXT_SCRPTR = .SCRPTR [SCR_NXT_LINE];
IF (.NEXT_SCRPTR NEQA 0)
THEN
BEGIN
IF (((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0) AND !
((.NEXT_SCRPTR [SCR_LINE_IDX] EQL 0) OR !
((.NEXT_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0)))
THEN
REC_NO = .REC_NO + 1;
END;
SCRPTR = .SCRPTR [SCR_NXT_LINE];
END
UNTIL ((.SCRPTR EQLA .CSR_SCRPTR) OR (.SCRPTR EQLA 0));
END;
[OUTRANGE] :
ASSERT (11, 0);
TES;
!+
! If we couldn't find it, rebuild the screen.
!-
IF (.SCRPTR NEQA .CSR_SCRPTR) THEN BUILD_SCR = 1;
END;
IF ( NOT .BUILD_SCR)
THEN
BEGIN
!+
! Now work backwards to the old top line.
!-
WHILE ((.SCRPTR NEQA .TOP_SCRPTR) AND (.SCRPTR NEQA 0)) DO
BEGIN
IF ((.SCRPTR [SCR_LINE_IDX] EQL 0) OR !
((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0))
THEN
BEGIN
LOCAL
PREV_SCRPTR : REF SCREEN_LINE;
PREV_SCRPTR = .SCRPTR [SCR_PRV_LINE];
IF (.PREV_SCRPTR NEQA 0)
THEN
BEGIN
IF ((.PREV_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0) THEN REC_NO = .REC_NO - 1;
END;
END;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
END;
OLD_TOP_RECNO = .REC_NO;
END;
!+
! If we didn't find it, rebuild the screen data base.
!-
IF (.SCRPTR NEQA .TOP_SCRPTR) THEN BUILD_SCR = 1;
IF ( NOT .BUILD_SCR)
THEN
!+
! Update the lines which are on the screen.
!-
BEGIN
LOCAL
UPDATE_DONE,
ANOTHER_PASS,
BEG_SCRPTR : REF SCREEN_LINE,
INS_COUNT,
PREV_INS_COUNT;
!+
! Check for regions containing an equal number of inserted and deleted lines.
! Avoid double scrolling (and scrolling lines off the screen then back on) by
! changing all inserted lines in such regions into modified lines, and freeing
! the deleted lines.
!-
DO
BEGIN
ANOTHER_PASS = 0;
INS_COUNT = 0;
SCRPTR = .TOP_SCRPTR;
DO
BEGIN
UPDATE_DONE = 0;
PREV_INS_COUNT = .INS_COUNT;
IF ((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_INSLN) NEQ 0) THEN INS_COUNT = .INS_COUNT + 1;
IF ((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0) THEN INS_COUNT = .INS_COUNT - 1;
IF ((.INS_COUNT NEQ 0) AND (.PREV_INS_COUNT EQL 0)) THEN BEG_SCRPTR = .SCRPTR;
IF ((.INS_COUNT EQL 0) AND (.PREV_INS_COUNT NEQ 0))
THEN
BEGIN
!+
! Move the top line down, if it was deleted.
!-
IF (.BEG_SCRPTR EQLA .TOP_SCRPTR)
THEN
WHILE ((.TOP_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0) DO
TOP_SCRPTR = .TOP_SCRPTR [SCR_NXT_LINE];
!+
! Free deleted lines and mark all other lines to be repainted.
!-
EDT$$SC_REPAINT (.BEG_SCRPTR, .SCRPTR, 0, 255, 1);
UPDATE_DONE = 1;
ANOTHER_PASS = 1;
END
ELSE
BEGIN
IF (.SCRPTR EQLA .BOT_SCRPTR) OR (.SCRPTR [SCR_NXT_LINE] EQLA 0)
THEN
UPDATE_DONE = 1
ELSE
SCRPTR = .SCRPTR [SCR_NXT_LINE];
END;
END
UNTIL .UPDATE_DONE;
!+
! The screen is no longer erased. Subsequent lines painted must issue an "erase to end of line" to
! blank out the end of a completely painted line, except in special cases such as scrolling a line
! onto the screen.
!-
ERASE_ALL = 0;
END
UNTIL ( NOT .ANOTHER_PASS);
!+
! Now repaint all the lines so marked, and do any residual inserts and deletes on the screen.
!-
DO
BEGIN
LOCAL
STATUS; ! Insert or Delete status
ANOTHER_PASS = 0;
REC_NO = .OLD_TOP_RECNO;
SCRPTR = .TOP_SCRPTR;
CS_LNO = 0;
DO
BEGIN
UPDATE_DONE = 0;
IF ((.SCRPTR [SCR_EDIT_FLAGS] AND !
(SCR_EDIT_MODIFY OR SCR_EDIT_INSLN OR SCR_EDIT_DELLN)) NEQ 0)
THEN
BEGIN
!+
! Is this a deleted line?
!-
IF ((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0)
THEN
BEGIN
STATUS = DELETE_LINE (.SCRPTR, .REC_NO, .ERASE_ALL, OLD_TOP_RECNO);
END
ELSE
IF ((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_INSLN) NEQ 0)
THEN
BEGIN
STATUS = INSERT_LINE (.SCRPTR, .REC_NO, .ERASE_ALL, OLD_TOP_RECNO);
END
ELSE
BEGIN
!+
! The line is neither inserted nor deleted. Just paint it on the screen.
!-
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
EDT$$SC_RFRELN (.SCRPTR, .ERASE_ALL);
STATUS = 1;
END;
IF ( NOT .STATUS)
THEN
BEGIN
UPDATE_DONE = 1;
ANOTHER_PASS = 1;
END;
END;
IF ( NOT .UPDATE_DONE)
THEN
BEGIN
CS_LNO = .CS_LNO + 1;
IF (.CS_LNO EQL .SCR_LNS)
THEN
UPDATE_DONE = 1
ELSE
BEGIN
IF (.SCRPTR [SCR_NXT_LINE] EQLA 0)
THEN
BEGIN
!+
! We have run out of screen data base, but we have not yet filled the screen. If we
! are at [EOB] that is OK, otherwise extend the screen data base.
!-
IF (.SCRPTR EQLA .EOB_SCRPTR)
THEN
BEGIN
!+
! We have reached [EOB] before filling the screen. This will be fixed by scrolling later,
! if that is possible. Erase the rest of the screen unless the whole screen has been
! erased already.
!-
IF (.CS_LNO LSS .BOT_LINE) THEN EDT$$SC_ERAALL ();
UPDATE_DONE = 1
END
ELSE
BEGIN
!+
! We are not at [EOB]. Add another record to the screen data base, and keep
! painting the screen.
!-
REC_NO = .REC_NO + 1;
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
LNINS_VAL = EDT$$SC_LNINS (0, WK_LN [LIN_TEXT],
.WK_LN [LIN_LENGTH]);
IF (.LNINS_VAL EQL 0)
THEN
UPDATE_DONE = 1
ELSE
BEGIN
SCRPTR = .SCRPTR;
ASSERT (23, .SCRPTR [SCR_NXT_LINE] NEQA 0);
SCRPTR = .SCRPTR [SCR_NXT_LINE];
ASSERT (23, .SCRPTR [SCR_LINE_IDX] EQL 0);
END;
END;
END
ELSE
BEGIN
LOCAL
NEXT_SCRPTR : REF SCREEN_LINE;
NEXT_SCRPTR = .SCRPTR [SCR_NXT_LINE];
IF (.NEXT_SCRPTR NEQA 0)
THEN
BEGIN
IF (((.SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0) AND !
((.NEXT_SCRPTR [SCR_LINE_IDX] EQL 0) OR !
((.NEXT_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0)))
THEN
REC_NO = .REC_NO + 1;
END;
SCRPTR = .SCRPTR [SCR_NXT_LINE];
END;
END;
END;
END
UNTIL .UPDATE_DONE;
END
UNTIL ( NOT .ANOTHER_PASS);
EDT$$SC_SETSCLLREG (0, .SCR_LNS);
BOT_LINE = .CS_LNO;
OLD_BOT_RECNO = .REC_NO;
BOT_SCRPTR = .SCRPTR;
END;
IF .BUILD_SCR
THEN
BEGIN
!+
! We must rebuild the screen data base. Put all the screen line
! blocks on the free list.
!-
IF (.FST_SCRPTR NEQA 0)
THEN
BEGIN
LST_SCRPTR [SCR_NXT_LINE] = .FST_AVLN;
FST_AVLN = .FST_SCRPTR;
END;
FST_SCRPTR = 0;
LST_SCRPTR = 0;
TOP_SCRPTR = 0;
CUR_SCRPTR = 0;
BOT_SCRPTR = 0;
EOB_SCRPTR = 0;
MEM_CNT = 0;
END;
!+
! Align the cursor screen pointer with the current screen pointer.
!-
REC_NO = 0;
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
SCR_BUF = .CUR_BUF;
MOVELINE (CUR_BUF [TBCB_CUR_LIN], CUR_SCRLN);
IF .BUILD_SCR
THEN
BEGIN
EDT$$SC_LNINS (0, WK_LN [LIN_TEXT], .WK_LN [LIN_LENGTH]);
CSR_SCRPTR = .FST_SCRPTR;
IF (.TRUN EQL 0) !
THEN
CUR_SCRPTR = EDT$$SC_FNDREC (.CS_CHNO, DISP)
ELSE
CUR_SCRPTR = .CSR_SCRPTR;
END;
!+
! When we reach this point either the old screen has been updated
! or we will be rebuilding the screen data base.
! Determine which line should be at the top of the screen
!-
SCRPTR = .CUR_SCRPTR;
REC_NO = 0;
BELOW = 0;
ABOVE = 0;
!+
! Calculate the number of lines above and below the current line
! because we might have to move the cursor. This may cause the screen
! data structure to be extended.
!-
DOLOOPS = 0;
IF ((.RECS_INSERTED GTR 0) !
OR (.CSR_SCRPTR NEQA .CUR_SCRPTR) !
OR (.BUILD_SCR) !
OR (EDT$$CMP_LNO (TOP_LN, LNO_EMPTY) NEQ 0))
THEN
BEGIN
LOCAL
AT_BOTTOM;
DOLOOPS = 1;
AT_BOTTOM = 0;
WHILE ((.BELOW LSS (.SCR_LNS*2)) AND ( NOT .AT_BOTTOM)) DO
BEGIN
IF (.SCRPTR EQLA 0)
THEN
BEGIN
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
LNINS_VAL = EDT$$SC_LNINS (0, WK_LN [LIN_TEXT], .WK_LN [LIN_LENGTH]);
IF (.LNINS_VAL EQL 0)
THEN
AT_BOTTOM = 1
ELSE
BEGIN
BELOW = .BELOW + .LNINS_VAL;
REC_NO = .REC_NO + 1;
IF (.WK_LN EQLA EOB_LN)
THEN
BEGIN
EOB_SCRPTR = .LST_SCRPTR;
AT_BOTTOM = 1;
END;
END;
END
ELSE
BEGIN
BELOW = .BELOW + 1;
IF (.SCRPTR EQLA .EOB_SCRPTR)
THEN
AT_BOTTOM = 1
ELSE
BEGIN
SCRPTR = .SCRPTR [SCR_NXT_LINE];
IF (.SCRPTR EQLA 0)
THEN
REC_NO = .REC_NO + 1
ELSE
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO + 1;
END;
END;
END;
END;
!+
! Now see how many lines are available above the current line.
!-
SCRPTR = .CUR_SCRPTR;
REC_NO = 0;
IF (.DOLOOPS)
THEN
BEGIN
BEGIN
LOCAL
AT_TOP;
AT_TOP = 0;
WHILE ((.ABOVE LSS (.SCR_LNS*2)) AND ( NOT .AT_TOP)) DO
BEGIN
IF (.SCRPTR NEQA 0)
THEN
BEGIN
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO - 1;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
END;
!+
! If the screen data structure ends, try to add new items to the front of it.
!-
IF (.SCRPTR EQLA 0)
THEN
BEGIN
IF EDT$$SC_MOVTOLN (.REC_NO)
THEN
BEGIN
LNINS_VAL = EDT$$SC_LNINS (.FST_SCRPTR, WK_LN [LIN_TEXT],
.WK_LN [LIN_LENGTH]);
IF (.LNINS_VAL EQL 0)
THEN
AT_TOP = 1
ELSE
BEGIN
ABOVE = .ABOVE + .LNINS_VAL;
SCRPTR = .FST_SCRPTR;
END;
END
ELSE
AT_TOP = 1;
END
ELSE
ABOVE = .ABOVE + 1;
END;
END;
SCRPTR = .CUR_SCRPTR;
!+
! Now compute the top line. If there is an enforced top line, we try to use it.
! If there is not, we try to use the old top line. Otherwise we go up a number of
! lines depending on the direction of the last move, to preserve as much context
! as possible.
!-
TOP_SET = 0;
IF (EDT$$CMP_LNO (TOP_LN, LNO_EMPTY) NEQ 0)
THEN
BEGIN
!+
! There is a request for a top line. If it is below the current line, reject it.
!-
IF (EDT$$CMP_LNO (TOP_LN, CS_LN) GTR 0)
THEN
MOVELINE (LNO_EMPTY, TOP_LN)
ELSE
BEGIN
!+
! The requested top line is above or on the current line. If it is too far above, reject it.
!-
TOP_DIST = 0;
SCRPTR = .CUR_SCRPTR;
MOVELINE (CS_LN, TEMP_LINE);
WHILE ((EDT$$CMP_LNO (TEMP_LINE, TOP_LN) NEQ 0) AND !
(.TOP_DIST LSS .SCLL_BOT) AND !
(.SCRPTR NEQA 0)) DO
BEGIN
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN SUBLINE (LNO0, TEMP_LINE, TEMP_LINE);
SCRPTR = .SCRPTR [SCR_PRV_LINE];
IF (.SCRPTR NEQA 0) THEN TOP_DIST = .TOP_DIST + 1;
END;
!+
! If we found the line and it would not require [EOB] to be above the bottom
! of the screen, accept it.
!-
IF ((EDT$$CMP_LNO (TEMP_LINE, TOP_LN) EQL 0) AND ((.BELOW + .TOP_DIST) GEQ .SCR_LNS))
THEN
TOP_SET = 1
ELSE
MOVELINE (LNO_EMPTY, TOP_LN);
END;
END;
!+
! If we have no top determined yet, try to use the old top.
!-
IF (( NOT .TOP_SET) AND (.TOP_SCRPTR NEQA 0))
THEN
BEGIN
SCRPTR = .CUR_SCRPTR;
REC_NO = 0;
TOP_DIST = 0;
WHILE ((.TOP_DIST LEQ .SCLL_BOT) AND !
(.SCRPTR NEQA .TOP_SCRPTR) AND !
(.SCRPTR NEQA 0)) DO
BEGIN
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO - 1;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
IF (.SCRPTR NEQA 0) THEN TOP_DIST = .TOP_DIST + 1;
END;
!+
! If we found the old top line and it will leave the cursor line in range
! and not put the [EOB] above the bottom of the screen, use it.
!-
IF ((.TOP_DIST LEQ .SCLL_BOT) AND !
(.TOP_DIST GEQ .SCLL_TOP) AND !
((.BELOW + .TOP_DIST) GEQ .SCR_LNS) AND !
(.SCRPTR EQLA .TOP_SCRPTR))
THEN
TOP_SET = 1;
END;
!+
! If top is still not set and there is a record of a previous cursor line
! and we are rebuilding the screen data base, try to compute the top line
! such that the cursor stays where it was. This is useful in case the code
! for fixing notruncated lines must force a rebuild of the screen data base.
!-
IF (( NOT .TOP_SET) AND .SCR_REBUILD AND (.CURSOR_LINE GEQ .SCLL_TOP) AND !
(.CURSOR_LINE LEQ .SCLL_BOT) AND ((.BELOW + .CURSOR_LINE) GEQ .SCR_LNS))
THEN
BEGIN
SCRPTR = .CUR_SCRPTR;
TOP_DIST = -1;
WHILE ((.SCRPTR NEQA 0) AND (.TOP_DIST NEQ .CURSOR_LINE)) DO
BEGIN
SCRPTR = .SCRPTR [SCR_PRV_LINE];
TOP_DIST = .TOP_DIST + 1;
END;
IF (.TOP_DIST EQL .CURSOR_LINE) THEN TOP_SET = 1;
END;
!+
! If top is still not set, try to find a new top line a suitable distance
! above the current line.
!-
IF ( NOT .TOP_SET)
THEN
BEGIN
!+
! Work back until the beginning of the screen data structure or until TOP_DIST is
! big enough for the direction we are moving.
!-
!+
! The (.CURSOR_LINE + .RECS_INSERTED) code is here to fix a problem on VT52's
! with the screen scrolling too far up on a paste.
!-
IF ((.DIR GEQ 0) OR (((.CURSOR_LINE + .RECS_INSERTED) GTR .SCLL_BOT) !
AND (.RECS_INSERTED GTR 0)))
THEN
SCLL_NUM = .SCLL_BOT
ELSE
SCLL_NUM = .SCLL_TOP;
!+
! If necessary, work back further to avoid lifting the [EOB] above the last line
! of the screen.
!-
SCLL_NUM = MAX (.SCLL_NUM, .SCR_LNS - .BELOW);
!
REC_NO = 0;
SCRPTR = .CUR_SCRPTR;
TOP_DIST = -1;
WHILE ((.SCRPTR NEQA 0) AND (.TOP_DIST NEQ .SCLL_NUM)) DO
BEGIN
SCRPTR = .SCRPTR [SCR_PRV_LINE];
TOP_DIST = .TOP_DIST + 1;
END;
!+
! If we found the line we were looking for, accept it.
!-
IF (.TOP_DIST EQL .SCLL_NUM) THEN TOP_SET = 1;
END;
!+
! If no line is suitable, use the first line in the screen data base. This can happen when we
! have a buffer that fits on the screen.
!-
IF ( NOT .TOP_SET)
THEN
BEGIN
TOP_DIST = -1;
SCRPTR = .CUR_SCRPTR;
WHILE (.SCRPTR NEQA 0) DO
BEGIN
TOP_DIST = .TOP_DIST + 1;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
END;
END;
!+
! Now that TOP_DIST is computed, find the new top screen pointer.
!-
SCRPTR = .CUR_SCRPTR;
REC_NO = 0;
INCR I FROM 1 TO .TOP_DIST DO
BEGIN
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO - 1;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
END;
TOP_RECNO = .REC_NO;
TOP_PTR = .SCRPTR;
!+
! Compute the number of lines between the old and new top lines,
! so we can see how far to scroll, and in which direction.
!-
IF ((.TOP_SCRPTR NEQA 0) AND (.TOP_SCRPTR NEQA .TOP_PTR))
THEN
BEGIN
LOCAL
SEEN_OLD,
SEEN_NEW;
SEEN_OLD = 0;
SEEN_NEW = 0;
SCLL_NUM = 0;
SCRPTR = .FST_SCRPTR;
WHILE ((.SCRPTR NEQA 0) AND ( NOT (.SEEN_OLD AND .SEEN_NEW))) DO
BEGIN
IF (.SEEN_OLD AND ( NOT .SEEN_NEW)) THEN SCLL_NUM = .SCLL_NUM + 1;
IF (.SEEN_NEW AND ( NOT .SEEN_OLD)) THEN SCLL_NUM = .SCLL_NUM - 1;
IF (.SCRPTR EQLA .TOP_PTR) THEN SEEN_NEW = 1;
IF (.SCRPTR EQLA .TOP_SCRPTR) THEN SEEN_OLD = 1;
SCRPTR = .SCRPTR [SCR_NXT_LINE];
END;
ASSERT (23, .SEEN_NEW);
!+
! If the old top line is not in the data base, it must be too far away
! to scroll.
!-
IF ( NOT .SEEN_OLD) THEN SCLL_NUM = 0;
!+
! If the amount to scroll is too large, don't do any scrolling.
!-
IF (ABS (.SCLL_NUM) GEQ .SCR_LNS) THEN SCLL_NUM = 0;
!+
! The sign of SCLL_NUM says which way to scroll, and the magnitude says
! how much. First position to the bottom or top of the old screen,
! depending on which way we are scrolling.
!-
WHILE (.SCLL_NUM NEQ 0) DO
IF (.SCLL_NUM GTR 0)
THEN
BEGIN
!+
! The cursor is moving down, so scroll the screen up.
!-
SCRPTR = .BOT_SCRPTR;
REC_NO = .OLD_BOT_RECNO;
SCRPTR = .SCRPTR [SCR_NXT_LINE];
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO + 1;
OLD_BOT_RECNO = .REC_NO;
IF .TI_SCROLL
THEN
BEGIN
EDT$$SC_POSCSIF (.SCR_LNS - 1, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_LF)))), 1);
END
ELSE
BEGIN
EDT$$SC_POSCSIF (.MESSAGE_LINE + 1, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_LF)))), 1);
EDT$$SC_POSCSIF (.SCR_LNS - 1, 0);
END;
CS_LNO = .SCR_LNS - 1;
EDT$$SC_REPAINT (.SCRPTR, .SCRPTR, 0, 255, 1);
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
EDT$$SC_RFRELN (.SCRPTR, .TI_SCROLL);
TOP_SCRPTR = .TOP_SCRPTR [SCR_NXT_LINE];
BOT_SCRPTR = .SCRPTR;
SCLL_NUM = .SCLL_NUM - 1;
END
ELSE
BEGIN
!+
! The cursor is moving up, so scroll the screen down.
!-
SCRPTR = .TOP_SCRPTR;
REC_NO = .OLD_TOP_RECNO;
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO - 1;
OLD_TOP_RECNO = .REC_NO;
SCRPTR = .SCRPTR [SCR_PRV_LINE];
EDT$$SC_POSCSIF (0, 0);
IF (.TI_TYP EQL TERM_VT52)
THEN
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), 'I'))), 2)
ELSE
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), 'M'))), 2);
IF ( NOT .TI_SCROLL)
THEN
BEGIN
CS_LNO = .SCR_LNS;
EDT$$SC_ERAALL ();
END;
CS_LNO = 0;
EDT$$SC_REPAINT (.SCRPTR, .SCRPTR, 0, 255, 1);
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
EDT$$SC_RFRELN (.SCRPTR, 1);
TOP_SCRPTR = .SCRPTR;
BOT_SCRPTR = .BOT_SCRPTR [SCR_PRV_LINE];
SCLL_NUM = .SCLL_NUM + 1;
END;
END;
!+
! Make a final update pass over the screen. This will be needed if
! no scrolling took place because the new screen is too far from
! the old screen.
!-
REC_NO = .TOP_RECNO;
SCRPTR = .TOP_PTR;
CURSOR_LINE = -1;
TOP_SCRPTR = .TOP_PTR;
CS_LNO = 0;
WHILE ((.CS_LNO LSS .SCR_LNS) AND (.SCRPTR NEQA 0)) DO
BEGIN
IF ((.SCRPTR [SCR_EDIT_FLAGS] AND (SCR_EDIT_MODIFY OR SCR_EDIT_INSLN OR SCR_EDIT_DELLN)) NEQ 0)
THEN
BEGIN
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
EDT$$SC_RFRELN (.SCRPTR, .ERASE_ALL);
END;
BOT_SCRPTR = .SCRPTR;
IF (.SCRPTR EQLA .CUR_SCRPTR) THEN CURSOR_LINE = .CS_LNO;
SCRPTR = .SCRPTR [SCR_NXT_LINE];
CS_LNO = .CS_LNO + 1;
IF (.SCRPTR NEQA 0)
THEN
BEGIN
IF (.SCRPTR [SCR_LINE_IDX] EQL 0) THEN REC_NO = .REC_NO + 1;
END;
END;
!+
! If there is more room on the screen, erase it if necessary.
!-
IF (.CS_LNO LSS .BOT_LINE) THEN EDT$$SC_ERAALL ();
BOT_LINE = .CS_LNO;
!+
! Mark the lines off the screen for repaint in case we have to scroll
! them back on in the next pass thru SC_UPD.
!-
IF (.FST_SCRPTR NEQA .TOP_SCRPTR)
THEN
BEGIN
SCRPTR = .TOP_SCRPTR [SCR_PRV_LINE];
EDT$$SC_REPAINT (.FST_SCRPTR, .SCRPTR, 0, 255, 1);
END;
IF (.BOT_SCRPTR NEQA .LST_SCRPTR)
THEN
BEGIN
SCRPTR = .BOT_SCRPTR [SCR_NXT_LINE];
EDT$$SC_REPAINT (.SCRPTR, .LST_SCRPTR, 0, 255, 1);
END;
END;
!+
! Do the clean-up on the screen data pointers.
!-
OLD_SEL = .SEL_BUF;
SCR_REBUILD = 0;
REC_NO = 0;
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
MOVELINE (CS_LN, CUR_SCRLN);
CSR_SCRPTR = .CUR_SCRPTR;
CS_OLDCHNO = .CS_CHNO;
EDT$$SC_POSCSIF (.CURSOR_LINE, .CURSOR_POS);
CS_LNO = .CURSOR_LINE;
CUR_COL = .CURSOR_POS;
EDT$$TI_ENBLAUTREP (1);
EDT$$OUT_FMTBUF ();
LN_PTR = CH$PTR (LN_BUF, .CS_CHNO, BYTE_SIZE);
RECS_INSERTED = 0;
END; ! of routine EDT$$SC_UPD
%SBTTL 'DELETE_LINE - delete a line on the screen'
ROUTINE DELETE_LINE ( ! Delete a line on the screen
SCRPTR, ! The line to delete
REC_NO, ! It's relative record number
ERASE_ALL, ! 1 = screen has been erased
OLD_TOP_RECNO ! Record number of the top line
) =
!++
! FUNCTIONAL DESCRIPTION:
!
! Delete one screen line.
!
! FORMAL PARAMETERS:
!
! SCRPTR The screen data block to delete
!
! REC_NO The relative record number of that line
!
! ERASE_ALL 1 = the screen has been erased
!
! OLD_TOP_RECNO Record number of the top line
!
! IMPLICIT INPUTS:
!
! FST_SCRPTR
! LST_SCRPTR
! TI_SCROLL
! TOP_SCRPTR
! SCR_LNS
! SCLL_BOT
! BOT_SCRPTR
! CS_LNO
! LST_SCRPTR
! BOT_LINE
!
! IMPLICIT OUTPUTS:
!
! TOP_SCRPTR
! BOT_SCRPTR
! BOT_LINE
!
! ROUTINE VALUE:
!
! 1 = OK, 0 = must start update over
!
! SIDE EFFECTS:
!
! Will store into the format buffer
!
!--
BEGIN
MAP
SCRPTR : REF SCREEN_LINE;
EXTERNAL ROUTINE
EDT$$SC_ERAALL, ! Erase to end of screen
EDT$$SC_MOVTOLN, ! Move to a record in the work file relative to the current record
EDT$$SC_RFRELN : NOVALUE, ! Refresh a screen line
EDT$$SC_LNDEL, ! Delete a line from data structure
EDT$$SC_SETSCLLREG, ! Set scrolling region
EDT$$FMT_LIT, ! Format a literal for output
EDT$$SC_POSCSIF : NOVALUE, ! Position the cursor
EDT$$SC_REPAINT : NOVALUE; ! Mark some lines in the screen data base for repaint
EXTERNAL
MSGFLG, ! Is a message on the screen
MESSAGE_LINE, ! Line number for prompts
TI_TYP, ! Terminal type
TI_EDIT, ! VT102 editing features
SCR_LNS, ! Number of lines on screen
SCLL_BOT, ! Cursor screen line
FST_SCRPTR : REF SCREEN_LINE, ! First data structure pointer
BOT_SCRPTR : REF SCREEN_LINE, ! Bottom screen pointer
LST_SCRPTR : REF SCREEN_LINE, ! Last data structure pointer
TOP_SCRPTR : REF SCREEN_LINE, ! Top screen line info address
EOB_SCRPTR : REF SCREEN_LINE, ! EOB screen pointer
CS_LNO, ! current cursor line
TI_SCROLL, ! 1 = we have scrolling regions
BOT_LINE; ! All lines below this one have been erased
LOCAL
PRV_SCRPTR : REF SCREEN_LINE, ! Previous screen pointer
NXT_SCRPTR : REF SCREEN_LINE; ! Next screen pointer
NXT_SCRPTR = .SCRPTR [SCR_NXT_LINE];
!+
! If we are deleting the top line, make the following line the top line
! unless there are lines preceding it that have been modified or inserted,
! in which case we paint over the deleted line instead of scrolling.
!-
IF (.SCRPTR EQLA .TOP_SCRPTR)
THEN
BEGIN
PRV_SCRPTR = .SCRPTR [SCR_PRV_LINE];
IF (.PRV_SCRPTR NEQA 0)
THEN
!+
! Test for insertion or modification of previous lines.
!-
IF ((.PRV_SCRPTR [SCR_EDIT_FLAGS] AND (SCR_EDIT_INSLN OR SCR_EDIT_MODIFY)) NEQ 0)
THEN
BEGIN
!+
! Delete the current line and backup to the previous line for a
! repaint. The top screen pointer and record number offsets
! must also be updated. No further processing is needed on this pass.
!-
EDT$$SC_LNDEL (.SCRPTR);
TOP_SCRPTR = .PRV_SCRPTR;
IF ((.PRV_SCRPTR [SCR_LINE_IDX] EQL 0) AND !
((.PRV_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0))
THEN
BEGIN
.OLD_TOP_RECNO = ..OLD_TOP_RECNO - 1;
REC_NO = .REC_NO - 1;
END;
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
EDT$$SC_RFRELN (.PRV_SCRPTR, .ERASE_ALL);
RETURN (0);
END;
!+
! The previous line is non-existent or has not been modified. Handle this in the usual way.
!-
END;
IF ((.EOB_SCRPTR EQLA .BOT_SCRPTR) AND (.TOP_SCRPTR [SCR_PRV_LINE] NEQA 0))
THEN
BEGIN
!+
! The [EOB] appears on the screen, but the buffer is long enough that there is a line
! before the top line that appears on the screen.
! Move the top screen pointer up one line. This must be done before deleting
! the current line in case the top line is the current line.
!-
TOP_SCRPTR = .TOP_SCRPTR [SCR_PRV_LINE];
!+
! Adjust the record number of the top line.
!-
IF ((.TOP_SCRPTR [SCR_LINE_IDX] EQL 0) AND !
((.TOP_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0))
THEN
.OLD_TOP_RECNO = ..OLD_TOP_RECNO - 1;
IF (.TI_SCROLL)
THEN
BEGIN
LOCAL
TMP_SCRPTR : REF SCREEN_LINE,
SCLL_LINE;
SCLL_LINE = .CS_LNO;
TMP_SCRPTR = .SCRPTR;
!+
! To speed up deletes, the scrolling line will be the last line which is
! marked for delete.
!-
DO
BEGIN
SCLL_LINE = .SCLL_LINE + 1;
TMP_SCRPTR = .TMP_SCRPTR [SCR_NXT_LINE];
END
UNTIL ((.TMP_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0);
!+
! Scroll down
!-
EDT$$SC_SETSCLLREG (0, .SCLL_LINE);
EDT$$SC_POSCSIF (0, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), 'M'))), 2);
EDT$$SC_LNDEL (.SCRPTR);
END
ELSE
!+
! Repaint from the first line to the current line on a noscroll terminal.
!-
BEGIN
LOCAL
SAV_CS_LN;
EDT$$SC_LNDEL (.SCRPTR);
IF (.NXT_SCRPTR NEQA 0) THEN EDT$$SC_REPAINT (.NXT_SCRPTR, .LST_SCRPTR, 0, 255, 0);
SAV_CS_LN = .CS_LNO;
EDT$$SC_POSCSIF (0, 0);
!+
! Scroll down.
!-
IF (.TI_TYP EQL TERM_VT52)
THEN
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), 'I'))), 2)
ELSE
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), 'M'))), 2);
!+
! If we've done a scroll then the message is no longer on the screen.
!-
MSGFLG = 0;
BOT_LINE = .BOT_LINE + 1;
CS_LNO = .SCR_LNS;
EDT$$SC_ERAALL ();
CS_LNO = .SAV_CS_LN;
END;
END
ELSE
BEGIN
!+
! Either [EOB] does not appear on the screen or, if it does, the buffer is short enough
! that it all fits on the screen. We will be scrolling up.
! If we are deleting the top line, make the next line the top line. We don't need to
! worry about the top line record number since deleted lines have the record number
! of the next following non-deleted line.
!-
PRV_SCRPTR = .TOP_SCRPTR;
IF (.SCRPTR EQLA .TOP_SCRPTR) THEN TOP_SCRPTR = .NXT_SCRPTR;
IF ((.TI_SCROLL) AND (.CS_LNO LSS (.SCR_LNS - 1)))
THEN
BEGIN
!+
! Set the scrolling region so we can update the screen without repainting text
! that has moved up.
!-
IF (.TI_EDIT)
THEN
!+
! Use VT102 edit feature
!-
BEGIN
EDT$$SC_POSCSIF (.CS_LNO, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), '[M'))), 3);
END
ELSE
BEGIN
!+
! Simulate edit feature.
!-
EDT$$SC_SETSCLLREG (.CS_LNO, .SCR_LNS);
EDT$$SC_POSCSIF (.SCR_LNS - 1, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_LF)))), 1);
END;
!+
! Free the deleted line.
!-
EDT$$SC_LNDEL (.SCRPTR);
END
ELSE
BEGIN
!+
! If we cannot use the scrolling region, repaint the screen from the point
! of the deletion to the bottom. If we're deleting the top line, then
! just scroll up instead of repainting.
!-
IF (.SCRPTR EQLA .PRV_SCRPTR)
THEN
BEGIN
EDT$$SC_LNDEL (.SCRPTR);
EDT$$SC_POSCSIF (.MESSAGE_LINE + 1, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_LF)))), 1);
END
ELSE
BEGIN
EDT$$SC_LNDEL (.SCRPTR);
IF (.NXT_SCRPTR NEQA 0)
THEN
IF (.NXT_SCRPTR EQLA .EOB_SCRPTR) OR ((.NXT_SCRPTR [SCR_EDIT_FLAGS] AND
SCR_EDIT_DELLN) EQL 0)
THEN
EDT$$SC_REPAINT (.NXT_SCRPTR, .LST_SCRPTR, 0, 255, 0);
END;
END;
!+
! Adjust the bottom screen pointer if it is not the EOB.
!-
IF ((.BOT_SCRPTR NEQA 0) AND (.BOT_SCRPTR NEQA .EOB_SCRPTR))
THEN
BOT_SCRPTR = .BOT_SCRPTR [SCR_NXT_LINE];
END;
!+
! Make another pass over the screen data.
!-
RETURN (0);
END; ! of routine DELETE_LINE
%SBTTL 'INSERT_LINE - insert a line on the screen'
ROUTINE INSERT_LINE ( ! Insert a line on the screen
SCRPTR, ! The line to insert
REC_NO, ! It's relative record number
ERASE_ALL, ! 1 = screen has been erased
OLD_TOP_RECNO ! Record number of the top line
) =
!++
! FUNCTIONAL DESCRIPTION:
!
! Insert one screen line. It may be marked inserted or deleted.
! This routine is not called unless it has some kind of edit.
!
! FORMAL PARAMETERS:
!
! SCRPTR The screen data block to insert
!
! REC_NO The relative record number of that line
!
! ERASE_ALL 1 = the screen has been erased
!
! OLD_TOP_RECNO Record number of the top line
!
! IMPLICIT INPUTS:
!
! TI_SCROLL
! TOP_SCRPTR
! SCR_LNS
! SCLL_BOT
! BOT_SCRPTR
! CS_LNO
! LST_SCRPTR
! BOT_LINE
!
! IMPLICIT OUTPUTS:
!
! TOP_SCRPTR
! BOT_SCRPTR
! BOT_LINE
!
! ROUTINE VALUE:
!
! 1 = OK, 0 = must start update over
!
! SIDE EFFECTS:
!
! Will store into the format buffer
!
!--
BEGIN
MAP
SCRPTR : REF SCREEN_LINE;
EXTERNAL ROUTINE
EDT$$SC_LNDEL, ! Free a deleted line
EDT$$SC_SETSCLLREG, ! Set scrolling region
EDT$$FMT_LIT, ! Format a literal for output
EDT$$SC_POSCSIF : NOVALUE, ! Position the cursor
EDT$$SC_MOVTOLN, ! Move to a record in the work file relative to the current record
EDT$$SC_RFRELN : NOVALUE, ! Refresh a screen line
EDT$$SC_REPAINT : NOVALUE; ! Mark some lines in the screen data base for repaint
EXTERNAL
MESSAGE_LINE, ! Line number for error msgs
TI_EDIT, ! VT102 editing features
SCR_LNS, ! Number of lines on screen
SCLL_BOT, ! Cursor screen line
BOT_SCRPTR : REF SCREEN_LINE, ! Bottom screen pointer
LST_SCRPTR : REF SCREEN_LINE, ! Last data structure pointer
TOP_SCRPTR : REF SCREEN_LINE, ! Top screen line info address
EOB_SCRPTR : REF SCREEN_LINE, ! EOB screen pointer
CS_LNO, ! current cursor line
TI_SCROLL, ! 1 = we have scrolling regions
BOT_LINE; ! All lines below this one have been erased
LOCAL
NXT_SCRPTR : REF SCREEN_LINE; ! Next screen pointer
!+
! Now check for inserted lines and perform scrolls based upon this information
!-
IF ((.CS_LNO GEQ .SCLL_BOT) AND (.BOT_LINE GEQ .SCR_LNS))
THEN
BEGIN
NXT_SCRPTR = .SCRPTR [SCR_NXT_LINE];
IF (.TI_SCROLL)
THEN
BEGIN
IF (.NXT_SCRPTR NEQA 0)
THEN
IF ((.NXT_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0)
THEN
EDT$$SC_LNDEL (.NXT_SCRPTR)
ELSE
BEGIN
!+
! Scroll up.
!-
CS_LNO = .CS_LNO - 1;
EDT$$SC_SETSCLLREG (0, .CS_LNO + 1);
EDT$$SC_POSCSIF (.CS_LNO, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_LF)))), 1); ! Scroll up
!+
! Mark the top line for repaint since it is moving off the screen.
!-
EDT$$SC_REPAINT (.TOP_SCRPTR, .TOP_SCRPTR, 0, 255, -1);
TOP_SCRPTR = .TOP_SCRPTR [SCR_NXT_LINE];
!+
! Adjust the record number of the top line.
!-
IF ((.TOP_SCRPTR [SCR_LINE_IDX] EQL 0) AND !
((.TOP_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0))
THEN
.OLD_TOP_RECNO = ..OLD_TOP_RECNO + 1;
END;
END
ELSE
BEGIN
!+
! Do a repaint from the top down and scroll up once if we have a noscroll terminal.
!-
EDT$$SC_REPAINT (.SCRPTR, .LST_SCRPTR, 0, 255, 1);
EDT$$SC_POSCSIF (.MESSAGE_LINE + 1, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_LF)))), 1);
TOP_SCRPTR = .TOP_SCRPTR [SCR_NXT_LINE];
!+
! Adjust the record number of the top line.
!-
IF ((.TOP_SCRPTR [SCR_LINE_IDX] EQL 0) AND !
((.TOP_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) EQL 0))
THEN
.OLD_TOP_RECNO = ..OLD_TOP_RECNO + 1;
RETURN (0);
END;
END
ELSE
BEGIN
IF (.TI_SCROLL)
THEN
BEGIN
NXT_SCRPTR = .SCRPTR [SCR_NXT_LINE];
IF (.NXT_SCRPTR NEQA 0)
THEN
IF ((.NXT_SCRPTR [SCR_EDIT_FLAGS] AND SCR_EDIT_DELLN) NEQ 0)
THEN
EDT$$SC_LNDEL (.NXT_SCRPTR)
ELSE
BEGIN
!+
! Scroll down.
!-
IF (.TI_EDIT)
THEN
!+
! Use VT102 edit feature
!-
BEGIN
EDT$$SC_POSCSIF (.CS_LNO, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), '[L'))), 3);
END
ELSE
BEGIN
!+
! Simulate edit feature
!-
EDT$$SC_SETSCLLREG (.CS_LNO, .SCR_LNS);
EDT$$SC_POSCSIF (.CS_LNO, 0);
EDT$$FMT_LIT (CH$PTR (UPLIT (%STRING (%CHAR (ASC_K_ESC), 'M'))), 2); ! Scroll down
END;
!+
! If the bottom line will move off the screen, arrange to repaint it if it should move back on.
!-
IF ((.BOT_SCRPTR NEQA 0) AND (.BOT_LINE GEQ (.SCR_LNS - 1)))
THEN
BEGIN
EDT$$SC_REPAINT (.BOT_SCRPTR, .BOT_SCRPTR, 0, 255, 0);
BOT_SCRPTR = .BOT_SCRPTR [SCR_PRV_LINE];
END;
!+
! The bottom line may be lower on the screen. It doesn't matter much if BOT_LINE is too large.
!-
BOT_LINE = .BOT_LINE + 1;
END;
END
ELSE
BEGIN
EDT$$SC_REPAINT (.SCRPTR, .LST_SCRPTR, 0, 255, 1);
!+
! If the bottom line will move off the screen, arrange to repaint it if it should move back on.
!-
IF ((.BOT_SCRPTR NEQA 0) AND (.BOT_LINE GEQ (.SCR_LNS - 1)))
THEN
BEGIN
EDT$$SC_REPAINT (.BOT_SCRPTR, .BOT_SCRPTR, 0, 255, 0);
BOT_SCRPTR = .BOT_SCRPTR [SCR_PRV_LINE];
END;
!+
! The bottom line may be lower on the screen. It doesn't matter much if BOT_LINE is too large.
!-
BOT_LINE = .BOT_LINE + 1;
RETURN (0);
END;
END;
ASSERT (12, EDT$$SC_MOVTOLN (.REC_NO));
EDT$$SC_RFRELN (.SCRPTR, .ERASE_ALL);
RETURN (1);
END; ! of routine INSERT_LINE
!<BLF/PAGE>
END ! of module EDT$SCRUPDATE
ELUDOM