DIRECTORY
Carets USING [pCaretViewer, sCaretViewer, StopCaret],
EditSpan USING [afterMoved1, afterMoved2],
Imager,
NodeStyle,
Process USING [Detach],
RopeReader USING [Ref, GetRopeReader, FreeRopeReader, SetPosition, Backwards, Get, GetIndex],
Scaled,
TextEdit USING [Offset, RefTextNode, Size],
TextNode USING [FirstChild, ForwardClipped, Level, Location, NarrowToTextNode, pZone, Ref, Root, StepForward],
TEditCompile USING [minAvgLineLeading],
TEditDisplay,
TEditDocument USING [LineBreak, LineTable, LineTableRec, maxClip, Selection, SelectionRec, SpinAndLock, SelectionId, TEditDocumentData, Unlock],
TEditFormat,
TEditImpl,
TEditLocks USING [LockDocAndTdd, LockRef, UnlockDocAndTdd, WaitingForWrite],
TEditScrolling USING [AutoScroll],
TEditSelection USING [AdjustSelStates, FixUpAfterDisplay, InsertionPoint, InvalidateLineCache, pSel, sSel, fSel, SelectionRoot, ShowSelection, TakeDownForRedisplay, TakeSelectionDown],
TEditTouchup,
ViewerClasses USING [PaintProc, Viewer, PaintRectangle],
ViewerOps USING [UserToScreenCoords];
PaintTEditDocument:
PUBLIC ViewerClasses.PaintProc =
BEGIN
tdd: TEditDocument.TEditDocumentData = NARROW[self.data];
lock: TEditLocks.LockRef;
moveDownLines, moveDownDistance: INTEGER ← 0; -- used with scrolling down
redisplay, refreshing: BOOL ← FALSE;
Cleanup:
PROC = { TEditLocks.UnlockDocAndTdd[tdd]; TEditTouchup.RefreshOver[] };
BEGIN ENABLE UNWIND => Cleanup[];
interrupt: BOOL = clear OR whatChanged=TEditTouchup.fullUpdate OR whatChanged=NIL;
typescript: BOOL;
IF self.destroyed OR tdd=NIL THEN RETURN; -- the viewer changed while this was forked
tdd.invisible ← FALSE; -- or else we wouldn't have been called
lock ← TEditLocks.LockDocAndTdd[tdd, "PaintTEditDocument", read, interrupt, TRUE];
IF lock=NIL THEN { IF NOT interrupt THEN ERROR; RETURN }; -- someone else will do the display
IF Carets.pCaretViewer=self THEN Carets.StopCaret[primary];
IF Carets.sCaretViewer=self THEN Carets.StopCaret[secondary];
IF (self.ch/TEditCompile.minAvgLineLeading)+1 > tdd.lineTable.maxLines
THEN
BEGIN
-- make bigger line table
oldTable: TEditDocument.LineTable ← tdd.lineTable;
tdd.lineTable ← TextNode.pZone.
NEW[TEditDocument.LineTableRec[(self.ch/TEditCompile.minAvgLineLeading)+1] ←
[lastLine: oldTable.lastLine, lastY: oldTable.lastY, lines: NULL]];
FOR n:
INTEGER
IN [0..oldTable.lastLine]
DO
-- copy old data
tdd.lineTable[n] ← oldTable[n];
ENDLOOP;
END;
typescript ← tdd.tsInfo # NIL;
refreshing ← whatChanged=TEditTouchup.refresh;
IF clear
OR refreshing
OR whatChanged=TEditTouchup.fullUpdate
OR whatChanged=
NIL
THEN {
IF clear THEN TEditSelection.AdjustSelStates[self];
IF
NOT refreshing
THEN
FOR n:
INTEGER
IN [0..tdd.lineTable.lastLine]
DO
-- invalidate all lines
tdd.lineTable[n].valid ← FALSE;
ENDLOOP;
redisplay ← TRUE;
}
ELSE {
SELECT whatChanged FROM
$TakeDownPSel => TEditSelection.TakeSelectionDown[primary, self, context];
$ShowPSel => TEditSelection.ShowSelection[primary, self, context];
$TakeDownSSel => TEditSelection.TakeSelectionDown[secondary, self, context];
$ShowSSel => TEditSelection.ShowSelection[secondary, self, context];
$TakeDownFSel => TEditSelection.TakeSelectionDown[feedback, self, context];
$ShowFSel => TEditSelection.ShowSelection[feedback, self, context];
ENDCASE =>
WITH whatChanged
SELECT
FROM
x:
REF TEditTouchup.PreScrollDownRec => {
move down to make room for new lines at top
IF clear THEN ERROR;
moveDownLines ← x.lines;
moveDownDistance ← x.distance;
refreshing ← redisplay ← TRUE
};
x: ViewerClasses.PaintRectangle => {
-- fix up after Viewer blt
IF x.flavor # blt
-- or if width has changed
-- THEN {
Repaint all when width changes. Could try to be smart here, but probably better not to. Would have to worry about right indent and line formatting (e.g., centered lines).
FOR n:
INTEGER
IN [0..tdd.lineTable.lastLine]
DO
-- invalidate all lines
tdd.lineTable[n].valid ← FALSE;
ENDLOOP }
ELSE {
-- height has changed
n: INTEGER ← 0;
h: INTEGER ← ViewerOps.UserToScreenCoords[self, 0, self.ch].sy-x.y; -- new height
UNTIL n > tdd.lineTable.lastLine
OR tdd.lineTable[n].yOffset+tdd.lineTable[n].descent >= h
DO
n ← n+1; ENDLOOP;
n ← MIN[n, tdd.lineTable.lastLine]; -- make sure invalidate at least one line
UNTIL n > tdd.lineTable.lastLine
DO
tdd.lineTable[n].valid ← FALSE; n ← n+1; ENDLOOP };
refreshing ← redisplay ← TRUE;
};
ENDCASE => ERROR;
};
IF redisplay
THEN {
TEditSelection.TakeDownForRedisplay[primary, self, context];
TEditSelection.TakeDownForRedisplay[secondary, self, context];
TEditSelection.TakeDownForRedisplay[feedback, self, context];
IF typescript
AND self.ch < tdd.lineTable[tdd.lineTable.lastLine].yOffset
THEN {
If a typescript viewer gets smaller such that bottom line is no longer visible, automatically scroll it up to keep bottom line on screen.
delta: INTEGER = tdd.lineTable[tdd.lineTable.lastLine].yOffset - self.ch;
n: INTEGER ← 0;
UNTIL n=tdd.lineTable.lastLine
OR tdd.lineTable[n].yOffset > delta
DO
n ← n+1; ENDLOOP;
tdd.lineTable[0] ← tdd.lineTable[MIN[tdd.lineTable.lastLine, n+1]];
tdd.lineTable[0].valid ← FALSE };
IF
NOT tdd.lineTable[0].valid
THEN {
-- check start location
startLoc: TextNode.Location;
node: TextEdit.RefTextNode;
CheckLocNode:
PROC [loc: TextNode.Location]
RETURNS [
BOOL] = {
startLoc ← loc;
RETURN [ loc.node # NIL AND TextNode.Root[loc.node] = tdd.text ]
};
IF CheckLocNode[tdd.lineTable[0].pos] THEN NULL
ELSE {
IF CheckLocNode[TEditSelection.InsertionPoint[]]
OR CheckLocNode[EditSpan.afterMoved1]
OR CheckLocNode[EditSpan.afterMoved2] THEN tdd.fixStart ← TRUE
ELSE startLoc ← [TextNode.FirstChild[tdd.text],0]
};
IF (node ← TextNode.NarrowToTextNode[startLoc.node]) #
NIL
THEN {
size: TextEdit.Offset = TextEdit.Size[node];
IF startLoc.where
NOT
IN [0..size)
THEN {
tdd.lineTable[0].valid ← FALSE;
tdd.fixStart ← TRUE;
startLoc.where ← MAX[MIN[size-1,startLoc.where],0]
}
};
IF tdd.fixStart
AND node #
NIL
AND startLoc.where > 0
THEN {
OPEN RopeReader;
Move startLoc to after CR or at start of node
rdr: Ref = GetRopeReader[];
cnt: INTEGER ← 0;
foundBreak: BOOL ← FALSE;
SetPosition[rdr,node.rope,startLoc.where];
FOR i:
INT ← 0, i+1
DO
char: CHAR;
IF i=startLoc.where THEN { foundBreak ← TRUE; EXIT }; -- out of chars
IF cnt > 200 THEN EXIT; -- give up
char ← Backwards[rdr];
IF char = 15C THEN { foundBreak ← TRUE; [] ← Get[rdr]; EXIT };
cnt ← cnt+1;
ENDLOOP;
IF foundBreak THEN startLoc.where ← GetIndex[rdr];
FreeRopeReader[rdr];
};
tdd.fixStart ← FALSE;
tdd.lineTable[0].pos ← startLoc;
IF tdd.clipLevel < TEditDocument.maxClip
THEN
-- check level of startLoc
tdd.clipLevel ← MAX[tdd.clipLevel, TextNode.Level[startLoc.node]]; };
TEditSelection.InvalidateLineCache; -- since selection impl keeps accelerators
RefreshViewer[self, tdd, context, clear, (whatChanged=TEditTouchup.refresh
AND
NOT typescript),
lock, moveDownLines, moveDownDistance];
};
IF whatChanged=$TakeDownPSel
OR
whatChanged=$TakeDownSSel OR
whatChanged=$TakeDownFSel THEN NULL
ELSE
IF whatChanged=TEditTouchup.refresh
AND
NOT typescript
AND
TEditLocks.WaitingForWrite[lock] THEN NULL
ELSE {
--fix up the selections
TEditSelection.FixUpAfterDisplay[primary, self, context, NOT tdd.readOnly];
TEditSelection.FixUpAfterDisplay[secondary, self, context, TRUE];
TEditSelection.FixUpAfterDisplay[feedback, self, context, FALSE]
};
IF
NOT tdd.dirty
THEN
SELECT tdd.scroll
FROM
no => NULL;
endofdoc => {
TRUSTED {Process.Detach[FORK AutoScroll[self, tdd.scrollGlitch, TRUE, primary]]};
tdd.scroll ← no };
endofsel => {
sel: TEditDocument.Selection =
SELECT tdd.scrollSelectionId
FROM
primary => TEditSelection.pSel,
secondary => TEditSelection.sSel,
feedback => TEditSelection.fSel,
ENDCASE => ERROR;
IF TEditSelection.SelectionRoot[sel]=tdd.text
THEN
TRUSTED {Process.Detach[FORK AutoScroll[self, tdd.scrollGlitch, FALSE, tdd.scrollSelectionId]]} };
ENDCASE => ERROR;
Cleanup[];
END; END; -- of unwind and PaintProc
WhileInPosRange:
PROCEDURE [
viewer: ViewerClasses.Viewer,
tdd: TEditDocument.TEditDocumentData,
dc: Imager.Context,
start, end: INTEGER,
displayClear, refresh: BOOLEAN,
lock: TEditLocks.LockRef,
moveDownLines, moveDownDistance: INTEGER
] RETURNS [line: INTEGER] = {
lines: TEditDocument.LineTable ← tdd.lineTable;
oldBottomY: INTEGER ← ComputeInitialBottomY[];
ComputeInitialBottomY:
PROC
RETURNS [y:
INTEGER] = {
Has to be done before node, pos, etc. are computed.
y ← MAX[0, lines[start].yOffset - lines[start].ascent];
WHILE start>0
AND lines[start-1].yOffset + lines[start-1].descent > y
DO
start ← start-1;
lines[start].valid ← FALSE;
ENDLOOP;
};
node: TextEdit.RefTextNode ← TextNode.NarrowToTextNode[lines[start].pos.node];
pos: TextEdit.Offset ← lines[start].pos.where;
leading, topLeading, bottomLeading, nodeLeading: INTEGER ← 0;
knowBottomLeading: BOOL ← start=0; -- otherwise need to get it
y: INTEGER ← 0;
nodeSize: TextEdit.Offset ← TextEdit.Size[node];
styleInit, yMatchRun: BOOL ← TRUE;
yMatch, eraseToEnd: BOOL ← FALSE;
lineInfo: TEditFormat.LineInfo ← TEditFormat.Allocate[];
nodeStyle: NodeStyle.Ref ← NodeStyle.Alloc[];
Cleanup: PROC = {lineInfo.Release[]; lineInfo ← NIL; nodeStyle.Free[]; nodeStyle ← NIL};
styleInfoNode: TextNode.Ref;
-- node for which we were last called to get style info
This is used to avoid redoing GetStyleInfo after have peeked at next node style as part of trying to move lines down.
GetStyleInfo:
PROC [node: TextNode.Ref] = {
IF node = styleInfoNode THEN RETURN; -- already have the style info
styleInfoNode ← node;
IF
NOT knowBottomLeading
AND pos=0
THEN {
-- get it from previous node
NodeStyle.ApplyAll[nodeStyle, lines[line-1].pos.node];
bottomLeading ← NodeStyle.GetBottomLeadingI[nodeStyle]
};
NodeStyle.ApplyAll[nodeStyle, node];
leading ← NodeStyle.GetLeadingI[nodeStyle];
topLeading ←
MAX[bottomLeading, NodeStyle.GetTopLeadingI[nodeStyle]];
use value of bottomLeading left from previous node
nodeLeading ← MAX[bottomLeading, topLeading]; -- use previous value of bottomLeading
bottomLeading ← NodeStyle.GetBottomLeadingI[nodeStyle];
knowBottomLeading ← TRUE;
};
FullyVisible:
PROC
RETURNS [
BOOL] =
INLINE {
IF
NOT checkedVisible
THEN {
fullyVisible ← dc.TestRectangle[x: 0, y: 0, w: viewer.cw, h: viewer.ch] = visible;
checkedVisible ← TRUE;
};
RETURN [fullyVisible]
};
checkedVisible, fullyVisible: BOOL ← FALSE;
found: INTEGER ← 0; -- set by FindBelow
TryMoveUp:
PROC
RETURNS [ok:
BOOL] = {
Returns true if found the desired line at a lower location on the screen. Blts the line and all following lines, clears out screen below them, then updates line table.
to, from, num, dist, bottom, diff: INTEGER;
dirtyScanlinesInFirstTextline: NAT ← 0;
FindBelow:
PROC
RETURNS [ok:
BOOL] =
INLINE {
-- returns true if finds the desired line
Looks for valid line at or below current line with desired start location. Assumes oldBottomY has been set to bottom of previous line, so if found line starts below that it will be ok on the screen still. If finds such a line, stores its index in "found" and returns true.
FOR n:
INTEGER
IN [line..lines.lastLine]
DO
IF lines[n].valid
AND lines[n].pos=[node,pos]
THEN {
found ← n;
RETURN [lines[n].yOffset-lines[n].ascent > oldBottomY]
};
ENDLOOP;
RETURN [FALSE]
};
IF NOT FullyVisible[] OR NOT FindBelow[] THEN RETURN [FALSE];
IF found=lines.lastLine
AND lines[found].yOffset+lines[found].descent >= viewer.ch
THEN RETURN [FALSE]; -- bottom is clipped
IF found>0
AND (
dirtyScanlinesInFirstTextline ←
MAX[0,
lines[found-1].yOffset+lines[found-1].descent - lines[found].yOffset-lines[found].ascent
]
) > 0 THEN lines[found].valid ← FALSE;
to ← y-lines[found].ascent + dirtyScanlinesInFirstTextline;
top of clean part of new line is destination for blt
from ← lines[found].yOffset-lines[found].ascent + dirtyScanlinesInFirstTextline;
uppermost source scan line
IF to < 0
THEN {
-- top of line is clipped
from ← from-to; -- move source down by amount to be clipped
to ← 0 };
dist ← from-to; -- the distance to move
IF dist < 0 THEN RETURN [FALSE]; -- skip this bizarre case
bottom ← MIN[viewer.ch, lines.lastY];
num ← bottom-from; -- number of scan lines to move
IF num <= 0 THEN RETURN [FALSE];
ClearLine[oldBottomY, to]; -- clear gap above destination
MoveScanLines[to, from, num]; -- move the good scan lines up
ClearLine[bottom-dist, bottom]; -- clear the space at the bottom
oldBottomY ← bottom;
lines.lastY ← lines.lastY-dist; -- lastY tells last used scan line in viewer
diff ← found-line; -- number of lines skipped
IF diff # 0
THEN {
-- update the line table info
FOR n:
INTEGER
IN [line..lines.lastLine-diff]
DO
lines[n] ← lines[n+diff]; -- move all the info up to new location
ENDLOOP;
ClearEntries[lines.lastLine-diff+1, lines.lastLine]; -- these lines no longer in use
lines.lastLine ← lines.lastLine-diff;
end ← end-diff
};
FOR n:
INTEGER
IN [line..lines.lastLine]
DO
-- adjust the baselines
lines[n].yOffset ← lines[n].yOffset-dist; ENDLOOP;
lines[lines.lastLine].valid ←
FALSE;
Set the last line invalid to force repaint to fill in gap at bottom of viewer.
RETURN [TRUE]
};
ClearEntries:
PROC [from, to:
INTEGER] = {
FOR n:
INTEGER
IN [from..to]
DO
lines[n] ← [
pos: [NIL, 0],
valid: TRUE,
yOffset: 0,
xOffset: 0,
width: 0,
ascent: 0,
descent: 0];
ENDLOOP };
MoveScanLines:
PROC [to, from, num:
INTEGER] =
BEGIN
bounds: Imager.IntRectangle ← Imager.GetViewBounds[dc];
yBase: INTEGER ← bounds.h + bounds.y - num;
IF num > 0
THEN Imager.MoveSurfaceRectangle[context: dc,
source: [x: bounds.x, y: yBase - from, w: bounds.w, h: num],
dest: [x: bounds.x, y: yBase - to]
];
END;
TryMoveDown:
PROC [nchars:
INTEGER, end: TEditDocument.LineBreak] = {
We are about to put [node, pos] in line. It will contain nchars with break specified by end. This procedure looks to see if we will overwrite what we will next want to put in line+1. If so, move it down now. This happens whenever we insert a single line.
This proc may need to call GetStyleInfo, so use all the style info you're interested in before you call it.
next: TextNode.Location;
from, lead, dist: INTEGER;
IF NOT FullyVisible[] OR NOT lines[line].valid THEN RETURN;
from ← lines[line].yOffset-lines[line].ascent;
IF oldBottomY > from THEN RETURN; -- overwritten it already
next ← IF end=eon THEN [NextNode[],0] ELSE [node,pos+nchars];
IF lines[line].pos # next THEN RETURN;
IF end=eon
THEN {
-- need to get leading info for the next node
GetStyleInfo[next.node]; lead ← nodeLeading }
ELSE lead ← leading;
dist ← y+lead-lines[line].yOffset; -- how far down to move it
MoveLinesDown[line, 1, from, dist]
};
MoveLinesDown:
PROC [startLine, numLines, from, dist:
INTEGER] = {
to, num, bottom: INTEGER;
visible: BOOL ← FALSE;
dirtyScanlinesInFirstTextline: INTEGER;
IF dist <= 0 THEN RETURN; -- skip this weird case
to ← from+dist;
bottom ← MIN[viewer.ch, lines.lastY+dist]; -- new bottom after blt
num ← bottom-to; -- the number of scan lines to blt
IF num <= 0 THEN RETURN; -- stuff to move down won't be visible
MoveScanLines[from+dist, from, num];
IF startLine > 0
AND (
dirtyScanlinesInFirstTextline ←
lines[startLine-1].yOffset+lines[startLine-1].descent -
lines[startLine].yOffset-lines[startLine].ascent
) > 0 THEN {
Repaint the top line if it got dirtied by descenders.
lines[startLine].valid ← FALSE;
ClearLine[from, to + dirtyScanlinesInFirstTextline];
}
ELSE ClearLine[from, to]; -- clear the gap
FOR n:
INTEGER
DECREASING
IN [startLine..lines.lastLine]
DO
newOffset: INTEGER;
IF n+numLines >= lines.maxLines THEN LOOP; -- avoid bounds fault
newOffset ← lines[n].yOffset+dist; -- the new baseline
IF newOffset-lines[n].ascent > viewer.ch THEN LOOP; -- off the bottom of viewer
IF
NOT visible
AND newOffset+lines[n].descent <= viewer.ch
THEN {
-- first fully visible line
visible ← TRUE;
lines.lastLine ← n+numLines;
lines[n].valid ← FALSE; -- force repaint at bottom of viewer
lines.lastY ← newOffset+lines[n].descent;
ClearLine[lines.lastY, viewer.ch] };
lines[n+numLines] ← lines[n]; -- move all the info down by numLines
lines[n+numLines].yOffset ← newOffset; -- adjust the baseline
IF
NOT visible
THEN {
-- line must be partly visible at bottom of screen
lines.lastLine ← n+numLines;
lines.lastY ← newOffset+lines[n].descent;
lines[n+numLines].valid ← FALSE };
ENDLOOP;
};
level: INTEGER ← 0; -- in case we are doing level clipping
maxLevel: INTEGER = tdd.clipLevel;
levelClipping: BOOL = maxLevel < TEditDocument.maxClip;
last, next: TextNode.Ref;
NextNode:
PROC
RETURNS [TextNode.Ref] = {
-- returns next node to display
For future reference, TEditScrollingImpl.ScrollTEditDocument also has code to calculate next node for display to handle scrolling up in 1 line viewers.
IF node=last THEN RETURN [next]; -- 1 entry cache
last ← node;
IF levelClipping THEN [next,level] ← TextNode.ForwardClipped[node,maxLevel,level]
ELSE next ← TextNode.StepForward[node];
RETURN [next]
};
ClearLine:
PROC [oldBottomY, newBottomY:
INTEGER] = {
IF oldBottomY >= newBottomY THEN RETURN;
Imager.SetColor[dc, Imager.white];
Imager.MaskRectangle[dc, 0, viewer.ch-newBottomY, viewer.cw, newBottomY-oldBottomY];
Imager.SetColor[dc, Imager.black];
};
IF (line ← start) > lines.lastLine
OR end < 0
THEN
update not on screen
{Cleanup[]; RETURN};
IF moveDownLines > 0
AND FullyVisible[]
THEN {
Move things down before start repainting. This accelerates scrolling down.
MoveLinesDown[0, moveDownLines, 0, moveDownDistance];
};
Paint lines until the line we would paint is:
(1) valid,
(2) past the range we were told to paint,
(3) matches the line table offsets (i.e. no ripple going forward), and
(4) matches in the Y coord.
An exit for end of text and off end of viewer are included below.
UNTIL line>=lines.maxLines
OR (
line>end
AND lines[line].valid
AND lines[line].pos=[node, pos]
AND yMatch
AND line<=lines.lastLine
) DO
IF (refresh AND TEditLocks.WaitingForWrite[lock])
OR tdd.interrupt > 0
THEN {
Either an edit is pending or a complete repaint is pending. In either case, we quit.
lines.lastLine ← MAX[line, lines.lastLine];
lines[line].pos ← [node, pos];
lines[line].valid ← FALSE;
Cleanup[]; RETURN
};
IF pos >= nodeSize
THEN {
Nothing more to display in this node; pos is where this line should start, so we are done with the node.
DO
-- stay in this loop until have a non-empty node or have reached end of document
IF (pos > 0 AND (line=0 OR lines[line-1].end=cr))
OR (nodeSize=0
AND node#tdd.text)
THEN {
Show blank line
Line 0 starts at end of node, or CR at end of node on previous line, or empty node other than root node.
GetStyleInfo[node];
IF line=start THEN y ← IF line=0 THEN 0 ELSE lines[line-1].yOffset; -- initialize y
y ← y + (
IF line=0
THEN NodeStyle.GetTopIndentI[nodeStyle]
ELSE
IF pos=0 THEN nodeLeading ELSE leading);
IF y>=viewer.ch
AND line>0
THEN {node ←
NIL;
EXIT};
If baseline would be off bottom of viewer and not the first line, don't show it.
IF NOT displayClear AND TryMoveUp[] THEN NULL
ELSE {
indent: INTEGER ← IF pos=0 THEN nodeStyle.GetFirstIndentI[] ELSE nodeStyle.GetBodyIndentI[];
lineStart: INTEGER ← nodeStyle.GetLeftIndentI[] + indent;
lineWidth: INTEGER ← viewer.cw - nodeStyle.GetRightIndentI[] - indent;
xoffset:
INTEGER ←
SELECT nodeStyle.GetLineFormatting[]
FROM
FlushLeft, Justified => lineStart,
FlushRight => lineStart + lineWidth,
Centered => lineStart + lineWidth/2,
ENDCASE => ERROR;
IF
NOT displayClear
THEN TryMoveDown[0, eon];
Need to finish with style info before call this.
lines[line] ← [
valid: TRUE,
pos: [node, pos],
nChars: 0,
end: eon,
yOffset: y,
xOffset: xoffset,
width: 0,
ascent: 1,
descent: 0
];
};
line ← line+1;
};
pos ← 0;
step to the next node in the tree.
node ← TextNode.NarrowToTextNode[NextNode[]];
IF node=NIL OR (nodeSize←TextEdit.Size[node]) > 0 THEN EXIT;
ENDLOOP;
IF NOT displayClear THEN {ClearLine[oldBottomY, y]; oldBottomY ← y};
IF node#NIL THEN {styleInit ← TRUE; LOOP} -- reapply termination test
ELSE {eraseToEnd ← TRUE; EXIT}; -- off end of text
}
ELSE IF styleInit THEN {GetStyleInfo[node]; styleInit ← FALSE}; -- first time for this node
y
--baseline-- ←
IF line=0
THEN NodeStyle.GetTopIndentI[nodeStyle]
ELSE (
IF line#start
THEN y
ELSE lines[line-1].yOffset)
-- baseline --
+ (IF pos=0 THEN nodeLeading ELSE leading) -- leading --;
IF y>=viewer.ch
AND line>0
THEN {eraseToEnd ←
TRUE;
EXIT};
if baseline would be off bottom of viewer and not the first line, don't show it.
yMatch ← y=lines[line].yOffset;
true if the new line is baseline aligned with the previous bits on the screen
oldBottomY ←
IF line=0
THEN 0
ELSE lines[line-1].yOffset+lines[line-1].descent;
bottom of the previous line
IF NOT displayClear AND TryMoveUp[] THEN NULL
ELSE {
TEditFormat.FormatLine[
self: lineInfo,
tdd: tdd,
node: node,
startOffset: pos,
nodeStyle: nodeStyle,
lineWidth: Scaled.FromInt[viewer.cw],
forPaint: TRUE
];
IF
NOT displayClear
THEN TryMoveDown[lineInfo.nChars, lineInfo.break];
Need to finish with style info before call this. May call GetStyleInfo for next node.
Imager.SetXY[dc, [lineInfo.xOffset.Float[], viewer.ch-y]];
IF NOT displayClear THEN ClearLine[oldBottomY, y-lineInfo.ymin];
oldBottomY ← y-lineInfo.ymin;
TEditFormat.Paint[lineInfo, dc];
lines[line] ← [
valid: TRUE,
pos: [node, pos],
nChars: lineInfo.nChars,
end: lineInfo.break,
yOffset: y,
xOffset: lineInfo.xOffset.Round[],
width: lineInfo.xmax-lineInfo.xmin,
ascent: MIN[511, MAX[0, lineInfo.ymax]],
descent: MIN[127, MAX[0, -lineInfo.ymin]]
];
};
pos ← pos + lines[line].nChars;
line ← line + 1;
ENDLOOP;
Clear former bottom lines if we run off end of text or viewer (partial line must be clipped)
IF eraseToEnd
OR line>=lines.maxLines
THEN {
eraseToEnd starts false. set true if reach end of document or stop with line that would have baseline below bottom of viewer.
bottomOfNewLines:
INTEGER ←
IF line=0 THEN 0 ELSE lines[line-1].yOffset+lines[line-1].descent;
lines.lastLine ← MAX[line,1]-1; -- set end mark
ClearEntries[lines.lastLine+1, lines.maxLines-1];
IF
NOT displayClear
AND bottomOfNewLines < lines.lastY
THEN
-- white out old lines
ClearLine[bottomOfNewLines, lines.lastY];
lines.lastY ← bottomOfNewLines;
}
ELSE {
Take this branch if got back in synch during repaint
IF y>viewer.ch OR displayClear THEN ERROR;
lines.lastLine ← MAX[lines.lastLine, MAX[line,1]-1];
lines.lastY ← MAX[lines.lastY, y+lines[lines.lastLine].descent];
};
Cleanup[];
};