MODULE TextSetters;
(**
project = "BlackBox"
organization = "www.oberon.ch"
contributors = "Oberon microsystems"
version = "System/Rsrc/About"
copyright = "System/Rsrc/About"
license = "Docu/BB-License"
changes = ""
issues = ""
**)
(* correct NextPage postcond in docu *)
(* make s.r, s.rd reducible? *)
(* paraShutoff needs to be controlled by an approx flag to certain ops (later ...?) *)
IMPORT
Fonts, Ports, Printers, Stores, Models, Views, Properties,
TextModels, TextRulers;
CONST
(** Pref.opts, options of setter-aware views; 0 overrides 1 **)
lineBreak* = 0; wordJoin* = 1; wordPart* = 2; flexWidth* = 3;
tab = TextModels.tab; line = TextModels.line; para = TextModels.para;
zwspace = TextModels.zwspace; nbspace = TextModels.nbspace;
hyphen = TextModels.hyphen; nbhyphen = TextModels.nbhyphen;
digitspace = TextModels.digitspace;
softhyphen = TextModels.softhyphen;
mm = Ports.mm;
minTabWidth = 2 * Ports.point; stdTabWidth = 4 * mm;
leftLineGap = 2 * Ports.point; rightLineGap = 3 * Ports.point;
adjustMask = {TextRulers.leftAdjust, TextRulers.rightAdjust};
centered = {}; leftFlush = {TextRulers.leftAdjust}; rightFlush = {TextRulers.rightAdjust};
blocked = adjustMask;
boxCacheLen = 64;
seqCacheLen = 16;
paraShutoff = MAX(INTEGER); (* longest stretch read backwards to find start of paragraph *)
(* unsafe: disabled *)
cachedRulers = FALSE; (* caching ruler objects trades speed against GC effectiveness *)
periodInWords = FALSE;
colonInWords = FALSE;
minVersion = 0; maxVersion = 0; maxStdVersion = 0;
TYPE
Pref* = RECORD (Properties.Preference)
opts*: SET;
endW*: INTEGER; (** preset (to width of view) **)
dsc*: INTEGER (** preset (to dominating line descender) **)
END;
Reader* = POINTER TO ABSTRACT RECORD
r-: TextModels.Reader; (** look-ahead state **)
(** unit **)
string*: ARRAY 64 OF CHAR; (** single chars in string[0] **)
view*: Views.View;
(** unit props **)
textOpts*: SET;
mask*: CHAR;
setterOpts*: SET;
w*, endW*, h*, dsc*: INTEGER;
attr*: TextModels.Attributes;
(** reading state **)
eot*: BOOLEAN;
pos*: INTEGER;
x*: INTEGER; (** to be advanced by client! **)
adjStart*: INTEGER;
spaces*: INTEGER;
tabIndex*: INTEGER; (** tabs being processed; initially -1 **)
tabType*: SET; (** type of tab being processed; initially {} **)
(** line props **)
vw*: INTEGER;
hideMarks*: BOOLEAN;
ruler*: TextRulers.Ruler;
rpos*: INTEGER
END;
Setter* = POINTER TO ABSTRACT RECORD (Stores.Store)
text-: TextModels.Model; (** connected iff text # NIL **)
defRuler-: TextRulers.Ruler;
vw-: INTEGER;
hideMarks-: BOOLEAN
END;
LineBox* = RECORD
len*: INTEGER;
ruler*: TextRulers.Ruler;
rpos*: INTEGER;
left*, right*, asc*, dsc*: INTEGER;
rbox*, bop*, adj*, eot*: BOOLEAN; (** adj => adjW > 0; adj & blocked => spaces > 0 **)
views*: BOOLEAN;
skipOff*: INTEGER; (** chars in [skipOff, len) take endW **)
adjOff*: INTEGER; (** offset of last block in box - adjust only this block **)
spaces*: INTEGER; (** valid, > 0 if adj & blocked **)
adjW*: INTEGER; (** valid if adj - to be distributed over spaces **)
tabW*: ARRAY TextRulers.maxTabs OF INTEGER (** delta width of tabs (<= 0) **)
END;
Directory* = POINTER TO ABSTRACT RECORD END;
Worder = RECORD
box: LineBox; next: INTEGER;
i: INTEGER
END;
StdReader = POINTER TO RECORD (Reader) END;
StdSetter = POINTER TO RECORD (Setter)
rd: Reader; (* subject to reduction? *)
r: TextModels.Reader; (* subject to reduction? *)
ruler: TextRulers.Ruler;
rpos: INTEGER;
key: INTEGER
END;
StdDirectory = POINTER TO RECORD (Directory) END;
VAR
dir-, stdDir-: Directory;
nextKey: INTEGER;
boxIndex, seqIndex: INTEGER;
boxCache: ARRAY boxCacheLen OF RECORD
key: INTEGER; (* valid iff key > 0 *)
start: INTEGER;
line: LineBox (* inv ruler = NIL *)
END;
seqCache: ARRAY seqCacheLen OF RECORD
key: INTEGER; (* valid iff key > 0 *)
start, pos: INTEGER (* sequence [start, end), end >= pos *)
END;
(** Reader **)
PROCEDURE (rd: Reader) Set* (
old: TextModels.Reader;
text: TextModels.Model; x, pos: INTEGER;
ruler: TextRulers.Ruler; rpos: INTEGER; vw: INTEGER; hideMarks: BOOLEAN
), NEW, EXTENSIBLE;
BEGIN
ASSERT(text # NIL, 20);
ASSERT(ruler # NIL, 22);
rd.r := text.NewReader(old); rd.r.SetPos(pos); rd.r.Read;
rd.string[0] := 0X; rd.view := NIL;
rd.textOpts := {};
rd.setterOpts := {}; rd.w := 0; rd.endW := 0; rd.h := 0; rd.dsc := 0;
rd.attr := NIL;
rd.eot := FALSE; rd.pos := pos; rd.x := x;
rd.tabIndex := -1; rd.tabType := {};
rd.adjStart := pos; rd.spaces := 0;
rd.ruler := ruler; rd.rpos := rpos; rd.vw := vw; rd.hideMarks := hideMarks
END Set;
PROCEDURE (rd: Reader) Read*, NEW, EXTENSIBLE;
(** pre: rd set **)
(** post: rd.pos = rd.pos' + Length(rd.string) **)
BEGIN
rd.string[0] := rd.r.char; rd.string[1] := 0X;
rd.view := rd.r.view;
rd.textOpts := {};
rd.setterOpts := {};
rd.w := rd.r.w; rd.endW := rd.w; rd.h := rd.r.h; rd.dsc := 0;
rd.attr := rd.r.attr;
rd.eot := rd.r.eot;
INC(rd.pos);
rd.r.Read
END Read;
PROCEDURE (rd: Reader) AdjustWidth* (start, pos: INTEGER; IN box: LineBox;
VAR w: INTEGER
), NEW, ABSTRACT;
PROCEDURE (rd: Reader) SplitWidth* (w: INTEGER): INTEGER, NEW, ABSTRACT;
(** Setter **)
PROCEDURE (s: Setter) CopyFrom- (source: Stores.Store), EXTENSIBLE;
BEGIN
WITH source: Setter DO
s.text := source.text; s.defRuler := source.defRuler;
s.vw := source.vw;s.hideMarks := source.hideMarks
END
END CopyFrom;
PROCEDURE (s: Setter) Internalize- (VAR rd: Stores.Reader), EXTENSIBLE;
VAR thisVersion: INTEGER;
BEGIN
s.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, maxVersion, thisVersion)
END Internalize;
PROCEDURE (s: Setter) Externalize- (VAR wr: Stores.Writer), EXTENSIBLE;
BEGIN
s.Externalize^(wr);
wr.WriteVersion(maxVersion)
END Externalize;
PROCEDURE (s: Setter) ConnectTo* (text: TextModels.Model;
defRuler: TextRulers.Ruler; vw: INTEGER; hideMarks: BOOLEAN
), NEW, EXTENSIBLE;
BEGIN
IF text # NIL THEN
s.text := text; s.defRuler := defRuler; s.vw := vw; s.hideMarks := hideMarks
ELSE
s.text := NIL; s.defRuler := NIL
END
END ConnectTo;
PROCEDURE (s: Setter) ThisPage* (pageH: INTEGER; pageNo: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, 0 <= pageNo **)
(** post: (result = -1) & (pageNo >= maxPageNo) OR (result = pageStart(pageNo)) **)
PROCEDURE (s: Setter) NextPage* (pageH: INTEGER; start: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, ThisPage(pageH, pageNo) = start [with pageNo = NumberOfPageAt(start)] **)
(** post: (result = start) & last-page(start) OR result = next-pageStart(start) **)
PROCEDURE (s: Setter) ThisSequence* (pos: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, 0 <= pos <= s.text.Length() **)
(** post: (result = 0) OR (char(result - 1) IN {line, para}) **)
PROCEDURE (s: Setter) NextSequence* (start: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, ThisSequence(start) = start **)
(** post: (result = start) & last-line(start) OR (ThisSequence(t, result - 1) = start) **)
PROCEDURE (s: Setter) PreviousSequence* (start: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, ThisSequence(t, start) = start **)
(** post: (result = 0) & (start = 0) OR (result = ThisSequence(t, start - 1)) **)
PROCEDURE (s: Setter) ThisLine* (pos: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, 0 <= pos <= s.text.Length() **)
(** post: result <= pos, (pos < NextLine(result)) OR last-line(result) **)
PROCEDURE (s: Setter) NextLine* (start: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, ThisLine(start) = start **)
(** post: (result = 0) & (start = 0) OR
(result = start) & last-line(start) OR
(ThisLine(result - 1) = start) **)
PROCEDURE (s: Setter) PreviousLine* (start: INTEGER): INTEGER, NEW, ABSTRACT;
(** pre: connected, ThisLine(start) = start **)
(** post: (result = 0) & (start = 0) OR (result = ThisLine(start - 1)) **)
PROCEDURE (s: Setter) GetWord* (pos: INTEGER; OUT beg, end: INTEGER), NEW, ABSTRACT;
(** pre: connected, 0 <= pos <= s.text.Length() **)
(** post: c set, beg <= pos <= end **)
PROCEDURE (s: Setter) GetLine* (start: INTEGER; OUT box: LineBox), NEW, ABSTRACT;
(** pre: connected, ThisLine(start) = start, 0 <= start <= s.text.Length() **)
(** post: (c, box) set (=> box.ruler # NIL), (box.len > 0) OR box.eot,
0 <= box.left <= box.right <= ruler.right **)
PROCEDURE (s: Setter) GetBox* (start, end, maxW, maxH: INTEGER;
OUT w, h: INTEGER
), NEW, ABSTRACT;
(** pre: connected, ThisLine(start) = start, 0 <= start <= end <= s.text.Length() **)
(** post: c set, maxW > undefined => w <= maxW, maxH > undefined => h <= maxH **)
PROCEDURE (s: Setter) NewReader* (old: Reader): Reader, NEW, ABSTRACT;
(** pre: connected **)
PROCEDURE (s: Setter) GridOffset* (dsc: INTEGER; IN box: LineBox): INTEGER, NEW, ABSTRACT;
(** pre: connected, dsc >= 0: dsc is descender of previous line; dsc = -1 for first line **)
(** post: dsc + GridOffset(dsc, box) + box.asc = k*ruler.grid (k >= 0) >= ruler.asc + ruler.grid **)
(** Directory **)
PROCEDURE (d: Directory) New* (): Setter, NEW, ABSTRACT;
(* line box cache *)
PROCEDURE InitCache;
VAR i: INTEGER;
BEGIN
nextKey := 1; boxIndex := 0; seqIndex := 0;
i := 0; WHILE i < boxCacheLen DO boxCache[i].key := -1; INC(i) END;
i := 0; WHILE i < seqCacheLen DO seqCache[i].key := -1; INC(i) END
END InitCache;
PROCEDURE ClearCache (key: INTEGER);
VAR i, j: INTEGER;
BEGIN
i := 0; j := boxIndex;
WHILE i < boxCacheLen DO
IF boxCache[i].key = key THEN boxCache[i].key := -1; j := i END;
INC(i)
END;
boxIndex := j;
i := 0; j := seqIndex;
WHILE i < seqCacheLen DO
IF seqCache[i].key = key THEN seqCache[i].key := -1; j := i END;
INC(i)
END;
seqIndex := j
END ClearCache;
PROCEDURE CacheIndex (key, start: INTEGER): INTEGER;
VAR i: INTEGER;
BEGIN
RETURN -1;
i := 0;
WHILE (i < boxCacheLen) & ~((boxCache[i].key = key) & (boxCache[i].start = start)) DO
INC(i)
END;
IF i = boxCacheLen THEN i := -1 END;
RETURN i
END CacheIndex;
PROCEDURE GetFromCache (s: StdSetter; i: INTEGER; VAR l: LineBox);
BEGIN
l := boxCache[i].line;
IF ~cachedRulers THEN
IF l.rpos >= 0 THEN
s.r := s.text.NewReader(s.r); s.r.SetPos(l.rpos); s.r.Read;
l.ruler := s.r.view(TextRulers.Ruler)
ELSE l.ruler := s.defRuler
END
END
END GetFromCache;
PROCEDURE AddToCache (key, start: INTEGER; VAR l: LineBox);
VAR i: INTEGER;
BEGIN
i := boxIndex; boxIndex := (i + 1) MOD boxCacheLen;
boxCache[i].key := key; boxCache[i].start := start; boxCache[i].line := l;
IF ~cachedRulers THEN
boxCache[i].line.ruler := NIL
END
END AddToCache;
PROCEDURE CachedSeqStart (key, pos: INTEGER): INTEGER;
VAR start: INTEGER; i: INTEGER;
BEGIN
i := 0;
WHILE (i < seqCacheLen)
& ~((seqCache[i].key = key) & (seqCache[i].start <= pos) & (pos <= seqCache[i].pos)) DO
INC(i)
END;
IF i < seqCacheLen THEN start := seqCache[i].start ELSE start := -1 END;
RETURN start
END CachedSeqStart;
PROCEDURE AddSeqStartToCache (key, pos, start: INTEGER);
VAR i: INTEGER;
BEGIN
i := 0;
WHILE (i < seqCacheLen) & ~((seqCache[i].key = key) & (seqCache[i].start = start)) DO
INC(i)
END;
IF i < seqCacheLen THEN
IF seqCache[i].pos < pos THEN seqCache[i].pos := pos END
ELSE
i := seqIndex; seqIndex := (i + 1) MOD seqCacheLen;
seqCache[i].key := key; seqCache[i].pos := pos; seqCache[i].start := start
END
END AddSeqStartToCache;
(* StdReader *)
(*
PROCEDURE WordPart (ch, ch1: CHAR): BOOLEAN;
(* needs more work ... put elsewhere? *)
BEGIN
CASE ORD(ch) OF
ORD("0") .. ORD("9"), ORD("A") .. ORD("Z"), ORD("a") .. ORD("z"),
ORD(digitspace), ORD(nbspace), ORD(nbhyphen), ORD("_"),
0C0H .. 0C6H, 0E0H .. 0E6H, (* ~ A *)
0C7H, 0E7H, (* ~ C *)
0C8H .. 0CBH, 0E8H .. 0EBH, (* ~ E *)
0CCH .. 0CFH, 0ECH .. 0EFH, (* ~ I *)
0D1H, 0F1H, (* ~ N *)
0D2H .. 0D6H, 0D8H, 0F2H .. 0F6H, 0F8H, (* ~ O *)
0D9H .. 0DCH, 0F9H .. 0FCH, (* ~ U *)
0DDH, 0FDH, 0FFH, (* ~ Y *)
0DFH: (* ~ ss *)
RETURN TRUE
| ORD("."), ORD(":"):
IF (ch = ".") & periodInWords OR (ch = ":") & colonInWords THEN
CASE ch1 OF
0X, TextModels.viewcode, tab, line, para, " ":
RETURN FALSE
ELSE RETURN TRUE
END
ELSE RETURN FALSE
END
ELSE RETURN FALSE
END
END WordPart;
*)
PROCEDURE WordPart (ch, ch1: CHAR): BOOLEAN;
(* Same as .net function System.Char.IsLetterOrDigit(ch)
+ digit space, nonbreaking space, nonbreaking hyphen, & underscore
ch1 unused *)
VAR low: INTEGER;
BEGIN
low := ORD(ch) MOD 256;
CASE ORD(ch) DIV 256 OF
| 001H, 015H, 034H..04CH, 04EH..09EH, 0A0H..0A3H, 0ACH..0D6H, 0F9H, 0FCH: RETURN TRUE
| 000H: CASE low OF
| 030H..039H, 041H..05AH, 061H..07AH, 0AAH, 0B5H, 0BAH, 0C0H..0D6H, 0D8H..0F6H, 0F8H..0FFH,
ORD(digitspace), ORD(nbspace), ORD(nbhyphen), ORD("_"): RETURN TRUE
ELSE
END
| 002H: CASE low OF
| 000H..041H, 050H..0C1H, 0C6H..0D1H, 0E0H..0E4H, 0EEH: RETURN TRUE
ELSE
END
| 003H: CASE low OF
| 07AH, 086H, 088H..08AH, 08CH, 08EH..0A1H, 0A3H..0CEH, 0D0H..0F5H, 0F7H..0FFH: RETURN TRUE
ELSE
END
| 004H: CASE low OF
| 000H..081H, 08AH..0CEH, 0D0H..0F9H: RETURN TRUE
ELSE
END
| 005H: CASE low OF
| 000H..00FH, 031H..056H, 059H, 061H..087H, 0D0H..0EAH, 0F0H..0F2H: RETURN TRUE
ELSE
END
| 006H: CASE low OF
| 021H..03AH, 040H..04AH, 060H..069H, 06EH..06FH, 071H..0D3H, 0D5H, 0E5H..0E6H, 0EEH..0FCH, 0FFH: RETURN TRUE
ELSE
END
| 007H: CASE low OF
| 010H, 012H..02FH, 04DH..06DH, 080H..0A5H, 0B1H: RETURN TRUE
ELSE
END
| 009H: CASE low OF
| 004H..039H, 03DH, 050H, 058H..061H, 066H..06FH, 07DH, 085H..08CH, 08FH..090H, 093H..0A8H, 0AAH..0B0H, 0B2H, 0B6H..0B9H, 0BDH, 0CEH, 0DCH..0DDH, 0DFH..0E1H, 0E6H..0F1H: RETURN TRUE
ELSE
END
| 00AH: CASE low OF
| 005H..00AH, 00FH..010H, 013H..028H, 02AH..030H, 032H..033H, 035H..036H, 038H..039H, 059H..05CH, 05EH, 066H..06FH, 072H..074H, 085H..08DH, 08FH..091H, 093H..0A8H, 0AAH..0B0H, 0B2H..0B3H, 0B5H..0B9H, 0BDH, 0D0H, 0E0H..0E1H, 0E6H..0EFH: RETURN TRUE
ELSE
END
| 00BH: CASE low OF
| 005H..00CH, 00FH..010H, 013H..028H, 02AH..030H, 032H..033H, 035H..039H, 03DH, 05CH..05DH, 05FH..061H, 066H..06FH, 071H, 083H, 085H..08AH, 08EH..090H, 092H..095H, 099H..09AH, 09CH, 09EH..09FH, 0A3H..0A4H, 0A8H..0AAH, 0AEH..0B9H, 0E6H..0EFH: RETURN TRUE
ELSE
END
| 00CH: CASE low OF
| 005H..00CH, 00EH..010H, 012H..028H, 02AH..033H, 035H..039H, 060H..061H, 066H..06FH, 085H..08CH, 08EH..090H, 092H..0A8H, 0AAH..0B3H, 0B5H..0B9H, 0BDH, 0DEH, 0E0H..0E1H, 0E6H..0EFH: RETURN TRUE
ELSE
END
| 00DH: CASE low OF
| 005H..00CH, 00EH..010H, 012H..028H, 02AH..039H, 060H..061H, 066H..06FH, 085H..096H, 09AH..0B1H, 0B3H..0BBH, 0BDH, 0C0H..0C6H: RETURN TRUE
ELSE
END
| 00EH: CASE low OF
| 001H..030H, 032H..033H, 040H..046H, 050H..059H, 081H..082H, 084H, 087H..088H, 08AH, 08DH, 094H..097H, 099H..09FH, 0A1H..0A3H, 0A5H, 0A7H, 0AAH..0ABH, 0ADH..0B0H, 0B2H..0B3H, 0BDH, 0C0H..0C4H, 0C6H, 0D0H..0D9H, 0DCH..0DDH: RETURN TRUE
ELSE
END
| 00FH: CASE low OF
| 000H, 020H..029H, 040H..047H, 049H..06AH, 088H..08BH: RETURN TRUE
ELSE
END
| 010H: CASE low OF
| 000H..021H, 023H..027H, 029H..02AH, 040H..049H, 050H..055H, 0A0H..0C5H, 0D0H..0FAH, 0FCH: RETURN TRUE
ELSE
END
| 011H: CASE low OF
| 000H..059H, 05FH..0A2H, 0A8H..0F9H: RETURN TRUE
ELSE
END
| 012H: CASE low OF
| 000H..048H, 04AH..04DH, 050H..056H, 058H, 05AH..05DH, 060H..088H, 08AH..08DH, 090H..0B0H, 0B2H..0B5H, 0B8H..0BEH, 0C0H, 0C2H..0C5H, 0C8H..0D6H, 0D8H..0FFH: RETURN TRUE
ELSE
END
| 013H: CASE low OF
| 000H..010H, 012H..015H, 018H..05AH, 080H..08FH, 0A0H..0F4H: RETURN TRUE
ELSE
END
| 014H: IF low >= 001H THEN RETURN TRUE END
| 016H: CASE low OF
| 000H..06CH, 06FH..076H, 081H..09AH, 0A0H..0EAH: RETURN TRUE
ELSE
END
| 017H: CASE low OF
| 000H..00CH, 00EH..011H, 020H..031H, 040H..051H, 060H..06CH, 06EH..070H, 080H..0B3H, 0D7H, 0DCH, 0E0H..0E9H: RETURN TRUE
ELSE
END
| 018H: CASE low OF
| 010H..019H, 020H..077H, 080H..0A8H: RETURN TRUE
ELSE
END
| 019H: CASE low OF
| 000H..01CH, 046H..06DH, 070H..074H, 080H..0A9H, 0C1H..0C7H, 0D0H..0D9H: RETURN TRUE
ELSE
END
| 01AH: IF low < 017H THEN RETURN TRUE END
| 01DH: IF low < 0C0H THEN RETURN TRUE END
| 01EH: CASE low OF
| 000H..09BH, 0A0H..0F9H: RETURN TRUE
ELSE
END
| 01FH: CASE low OF
| 000H..015H, 018H..01DH, 020H..045H, 048H..04DH, 050H..057H, 059H, 05BH, 05DH, 05FH..07DH, 080H..0B4H, 0B6H..0BCH, 0BEH, 0C2H..0C4H, 0C6H..0CCH, 0D0H..0D3H, 0D6H..0DBH, 0E0H..0ECH, 0F2H..0F4H, 0F6H..0FCH: RETURN TRUE
ELSE
END
| 020H: CASE low OF
| 071H, 07FH, 090H..094H: RETURN TRUE
ELSE
END
| 021H: CASE low OF
| 002H, 007H, 00AH..013H, 015H, 019H..01DH, 024H, 026H, 028H, 02AH..02DH, 02FH..031H, 033H..039H, 03CH..03FH, 045H..049H: RETURN TRUE
ELSE
END
| 02CH: CASE low OF
| 000H..02EH, 030H..05EH, 080H..0E4H: RETURN TRUE
ELSE
END
| 02DH: CASE low OF
| 000H..025H, 030H..065H, 06FH, 080H..096H, 0A0H..0A6H, 0A8H..0AEH, 0B0H..0B6H, 0B8H..0BEH, 0C0H..0C6H, 0C8H..0CEH, 0D0H..0D6H, 0D8H..0DEH: RETURN TRUE
ELSE
END
| 030H: CASE low OF
| 005H..006H, 031H..035H, 03BH..03CH, 041H..096H, 09DH..09FH, 0A1H..0FAH, 0FCH..0FFH: RETURN TRUE
ELSE
END
| 031H: CASE low OF
| 005H..02CH, 031H..08EH, 0A0H..0B7H, 0F0H..0FFH: RETURN TRUE
ELSE
END
| 04DH: IF low < 0B6H THEN RETURN TRUE END
| 09FH: IF low < 0BCH THEN RETURN TRUE END
| 0A4H: IF low < 08DH THEN RETURN TRUE END
| 0A8H: CASE low OF
| 000H..001H, 003H..005H, 007H..00AH, 00CH..022H: RETURN TRUE
ELSE
END
| 0D7H: IF low < 0A4H THEN RETURN TRUE END
| 0FAH: CASE low OF
| 000H..02DH, 030H..06AH, 070H..0D9H: RETURN TRUE
ELSE
END
| 0FBH: CASE low OF
| 000H..006H, 013H..017H, 01DH, 01FH..028H, 02AH..036H, 038H..03CH, 03EH, 040H..041H, 043H..044H, 046H..0B1H, 0D3H..0FFH: RETURN TRUE
ELSE
END
| 0FDH: CASE low OF
| 000H..03DH, 050H..08FH, 092H..0C7H, 0F0H..0FBH: RETURN TRUE
ELSE
END
| 0FEH: CASE low OF
| 070H..074H, 076H..0FCH: RETURN TRUE
ELSE
END
| 0FFH: CASE low OF
| 010H..019H, 021H..03AH, 041H..05AH, 066H..0BEH, 0C2H..0C7H, 0CAH..0CFH, 0D2H..0D7H, 0DAH..0DCH: RETURN TRUE
ELSE
END
ELSE
END;
RETURN FALSE
END WordPart;
(*
PROCEDURE ExtendToEOL (x, right: INTEGER): INTEGER;
BEGIN
IF right - x > 5 * mm THEN RETURN right - x ELSE RETURN 5 * mm END
END ExtendToEOL;
*)
PROCEDURE Right (ra: TextRulers.Attributes; vw: INTEGER): INTEGER;
BEGIN
IF TextRulers.rightFixed IN ra.opts THEN
RETURN ra.right
ELSE
RETURN vw
END
END Right;
PROCEDURE GetViewPref (rd: StdReader);
CONST maxH = 1600 * Ports.point;
VAR ra: TextRulers.Attributes; tp: TextModels.Pref; sp: Pref;
BEGIN
ra := rd.ruler.style.attr;
tp.opts := {}; Views.HandlePropMsg(rd.view, tp);
rd.textOpts := tp.opts; rd.mask := tp.mask;
sp.opts := {}; sp.dsc := ra.dsc; sp.endW := rd.w; Views.HandlePropMsg(rd.view, sp);
rd.setterOpts := sp.opts; rd.dsc := sp.dsc; rd.endW := sp.endW;
IF rd.w >= 10000 * mm THEN rd.w := 10000 * mm END;
IF (TextModels.hideable IN tp.opts) & rd.hideMarks THEN
rd.h := 0; sp.dsc := 0;
(*
rd.w := 0;
*)
IF ~( (rd.view IS TextRulers.Ruler)
OR (TextModels.maskChar IN rd.textOpts) & (rd.mask = para) ) THEN
rd.w := 0
END
(**)
ELSIF rd.h > maxH THEN rd.h := maxH
END;
IF TextModels.maskChar IN rd.textOpts THEN
rd.string[0] := rd.mask; rd.string[1] := 0X
ELSE rd.string[0] := TextModels.viewcode
END
END GetViewPref;
PROCEDURE GatherString (rd: StdReader);
VAR i, len: INTEGER; ch: CHAR;
BEGIN
i := 1; len := LEN(rd.string) - 1; ch := rd.r.char;
WHILE (i < len)
& (rd.r.view = NIL) & (rd.r.attr = rd.attr)
& ( (" " < ch) & (ch <= "~") & (ch # "-")
OR(ch = digitspace)
OR(ch >= nbspace) & (ch < 100X) & (ch # softhyphen)
)
DO (* rd.r.char > " " => ~rd.eot *)
rd.string[i] := ch; INC(i);
rd.eot := rd.r.eot;
rd.r.Read; ch := rd.r.char; INC(rd.pos)
END;
rd.string[i] := 0X; rd.setterOpts := {wordJoin};
IF i = 1 THEN
IF WordPart(rd.string[0], 0X) THEN INCL(rd.setterOpts, wordPart) END
END;
rd.w := rd.attr.font.StringWidth(rd.string); rd.endW := rd.w
END GatherString;
PROCEDURE SpecialChar (rd: StdReader);
VAR ra: TextRulers.Attributes; i, tabs, spaceW, dW: INTEGER; type: SET;
BEGIN
ra := rd.ruler.style.attr;
CASE ORD(rd.string[0]) OF
ORD(tab):
rd.textOpts := {TextModels.hideable};
rd.endW := minTabWidth;
rd.adjStart := rd.pos; rd.spaces := 0;
(*
i := 0; WHILE (i < ra.tabs.len) & (ra.tabs.tab[i].stop < rd.x + minTabWidth) DO INC(i) END;
*)
i := rd.tabIndex + 1;
IF i < ra.tabs.len THEN
type := ra.tabs.tab[i].type;
rd.w := MAX(minTabWidth, ra.tabs.tab[i].stop - rd.x);
IF TextRulers.barTab IN type THEN
IF TextRulers.rightTab IN type THEN
rd.w := MAX(minTabWidth, rd.w - leftLineGap)
ELSIF ~(TextRulers.centerTab IN type) THEN
INC(rd.w, rightLineGap)
END
END;
rd.tabIndex := i; rd.tabType := type
ELSE (* for "reasonable" fonts: round to closest multiple of spaces of this font *)
spaceW := rd.attr.font.SStringWidth(" ");
IF (1 <= spaceW) & (spaceW <= stdTabWidth) THEN
rd.w := (stdTabWidth + spaceW DIV 2) DIV spaceW * spaceW
ELSE
rd.w := stdTabWidth
END;
rd.tabIndex := TextRulers.maxTabs; rd.tabType := {}
END
| ORD(line):
rd.setterOpts := {lineBreak}; rd.w := 0; rd.endW := 0
| ORD(para):
(*
IF rd.hideMarks THEN
rd.w := 0; rd.h := 0; rd.dsc := 0
ELSE
rd.w := ExtendToEOL(rd.x, Right(ra, rd.vw)) + 1
END;
INC(rd.h, ra.lead);
rd.textOpts := {TextModels.hideable};
rd.endW := rd.w
*)
(*
rd.setterOpts := {lineBreak};
*)
IF rd.hideMarks THEN rd.h := 0; rd.dsc := 0 END;
INC(rd.h, ra.lead); rd.textOpts := {TextModels.hideable};
IF (rd.view = NIL) OR ~(rd.view IS TextRulers.Ruler) THEN
rd.w := 10000 * Ports.mm (* ExtendToEOL(rd.x, Right(ra, rd.vw)) + 1 *)
END;
rd.endW := rd.w
(**)
| ORD(" "):
rd.setterOpts := {flexWidth};
rd.w := rd.attr.font.StringWidth(rd.string); rd.endW := 0; INC(rd.spaces)
| ORD(zwspace):
rd.w := 0; rd.endW := 0
| ORD(digitspace):
rd.setterOpts := {wordPart};
rd.w := rd.attr.font.StringWidth("0"); rd.endW := rd.w
| ORD("-"):
rd.setterOpts := {};
rd.w := rd.attr.font.StringWidth("-"); rd.endW := rd.w
| ORD(hyphen):
rd.setterOpts := {};
rd.string[0] := "-" (*softhyphen*);
rd.w := rd.attr.font.StringWidth("-" (*softhyphen*)); rd.endW := rd.w
| ORD(nbhyphen):
rd.setterOpts := {wordJoin, wordPart};
rd.string[0] := "-" (*softhyphen*);
rd.w := rd.attr.font.StringWidth("-" (*softhyphen*)); rd.endW := rd.w
| ORD(softhyphen):
rd.setterOpts := {wordPart}; rd.textOpts := {TextModels.hideable};
rd.string[0] := "-";
rd.endW := rd.attr.font.StringWidth("-" (*softhyphen*));
IF rd.hideMarks THEN rd.w := 0 ELSE rd.w := rd.endW END
ELSE
rd.setterOpts := {wordJoin};
IF WordPart(rd.string[0], rd.r.char) THEN INCL(rd.setterOpts, wordPart) END;
rd.w := rd.attr.font.StringWidth(rd.string); rd.endW := rd.w
END
END SpecialChar;
(*
PROCEDURE LongChar (rd: StdReader);
VAR ra: TextRulers.Attributes;
BEGIN
ra := rd.ruler.style.attr;
rd.setterOpts := {wordJoin, wordPart};
rd.w := rd.attr.font.StringWidth(rd.string); rd.endW := rd.w
END LongChar;
*)
PROCEDURE (rd: StdReader) Read;
(* pre: connected *)
VAR ra: TextRulers.Attributes; asc, dsc, w: INTEGER; ch: CHAR;
BEGIN
rd.Read^;
IF ~rd.eot THEN
IF rd.view = NIL THEN
rd.attr.font.GetBounds(asc, dsc, w);
rd.h := asc + dsc; rd.dsc := dsc
ELSE
GetViewPref(rd)
END;
IF (rd.view = NIL) OR (TextModels.maskChar IN rd.textOpts) THEN
ch := rd.string[0];
IF (rd.view = NIL)
& ( (" " < ch) & (ch < "~") & (ch # "-")
OR (ch = digitspace)
OR (ch >= nbspace) & (ch # softhyphen)
)
THEN
GatherString(rd)
ELSE
SpecialChar(rd)
END
END
ELSE
ra := rd.ruler.style.attr;
rd.w := 0; rd.endW := 0; rd.h := ra.asc + ra.dsc; rd.dsc := ra.dsc
END
END Read;
PROCEDURE (rd: StdReader) AdjustWidth (start, pos: INTEGER; IN box: LineBox; VAR w: INTEGER);
VAR i: INTEGER; form: SET;
BEGIN
IF box.adj & (pos >= start + box.adjOff) THEN
form := box.ruler.style.attr.opts * adjustMask;
IF (form = blocked) & (rd.string[0] = " ") THEN
INC(w, box.adjW DIV box.spaces)
ELSIF (form # blocked) & (rd.string[0] = tab) THEN
INC(w, box.adjW) (* is this correct ??? *)
END
END;
i := rd.tabIndex; (* rd.string[0] = tab=>i >= 0 *)
IF (rd.string[0] = tab) & (i < box.ruler.style.attr.tabs.len) THEN
w := box.tabW[i]
END
END AdjustWidth;
PROCEDURE (rd: StdReader) SplitWidth (w: INTEGER): INTEGER;
BEGIN
IF (rd.string[1] = 0X) & (rd.view = NIL) THEN
RETURN (w + 1) DIV 2
ELSE RETURN w
END
END SplitWidth;
(* Worder *)
PROCEDURE SetWorder (VAR w: Worder; s: StdSetter; pos: INTEGER; OUT start: INTEGER);
CONST wordCutoff = LEN(s.rd.string);
BEGIN
start := s.ThisSequence(pos);
IF pos - start >= wordCutoff THEN
start := pos; WHILE pos - start < wordCutoff DO start := s.PreviousLine(start) END
END;
s.GetLine(start, w.box); w.next := start + w.box.len;
s.rd.Set(s.r, s.text, w.box.left, start, w.box.ruler, w.box.rpos, s.vw, s.hideMarks);
w.i := 0; s.rd.string[0] := 0X
END SetWorder;
PROCEDURE StepWorder (VAR w: Worder; s: StdSetter; VAR part: BOOLEAN);
VAR rd: Reader;
BEGIN
rd := s.rd;
IF rd.string[w.i] = 0X THEN
IF rd.pos < w.next THEN
rd.Read; w.i := 0
ELSE
IF ~w.box.eot THEN
s.GetLine(w.next, w.box);
s.rd.Set(s.r, s.text, w.box.left, w.next, w.box.ruler, w.box.rpos, s.vw, s.hideMarks);
rd.Read; w.i := 0;
INC(w.next, w.box.len)
ELSE
rd.string[0] := 0X
END
END
END;
IF rd.string[0] = 0X THEN (* end of text *)
part := TRUE
ELSIF rd.string[1] = 0X THEN (* special character *)
part := wordPart IN rd.setterOpts; INC(w.i)
ELSE (* gathered sString *)
part := WordPart(rd.string[w.i], rd.string[w.i + 1]); INC(w.i)
END
END StepWorder;
(* StdSetter *)
PROCEDURE (s: StdSetter) CopyFrom (source: Stores.Store);
BEGIN
s.CopyFrom^(source);
WITH source: StdSetter DO
s.ruler := source.ruler; s.rpos := source.rpos; s.key := source.key;
s.rd := NIL; s.r := NIL
END
END CopyFrom;
PROCEDURE (s: StdSetter) Externalize (VAR wr: Stores.Writer);
BEGIN
s.Externalize^(wr);
wr.WriteVersion(maxStdVersion)
END Externalize;
PROCEDURE (s: StdSetter) Internalize (VAR rd: Stores.Reader);
VAR thisVersion: INTEGER;
BEGIN
s.Internalize^(rd);
IF rd.cancelled THEN RETURN END;
rd.ReadVersion(minVersion, maxStdVersion, thisVersion);
IF rd.cancelled THEN RETURN END;
s.text := NIL; s.defRuler := NIL; s.ruler := NIL; s.rd := NIL; s.r := NIL
END Internalize;
PROCEDURE (s: StdSetter) ConnectTo (text: TextModels.Model;
defRuler: TextRulers.Ruler; vw: INTEGER; hideMarks: BOOLEAN
);
BEGIN
s.ConnectTo^(text, defRuler, vw, hideMarks);
ClearCache(s.key);
IF text # NIL THEN
s.ruler := defRuler; s.rpos := -1; s.key := nextKey; INC(nextKey)
ELSE
s.ruler := NIL
END
END ConnectTo;
PROCEDURE (s: StdSetter) ThisPage (pageH: INTEGER; pageNo: INTEGER): INTEGER;
(* pre: connected, 0 <= pageNo *)
(* post: (result = -1) & (pageNo >= maxPageNo) OR (result = pageStart(pageNo)) *)
VAR start, prev: INTEGER;
BEGIN
ASSERT(s.text # NIL, 20); ASSERT(pageNo >= 0, 21);
start := 0;
WHILE pageNo > 0 DO
prev := start; DEC(pageNo); start := s.NextPage(pageH, start);
IF start = prev THEN start := -1; pageNo := 0 END
END;
RETURN start
END ThisPage;
PROCEDURE (s: StdSetter) NextPage (pageH: INTEGER; start: INTEGER): INTEGER;
(* pre: connected, ThisPage(pageH, x) = start *)
(* post: (result = s.text.Length()) OR result = next-pageStart(start) *)
CONST
noBreakInside = TextRulers.noBreakInside;
pageBreak = TextRulers.pageBreak;
parJoin = TextRulers.parJoin;
regular = 0; protectInside = 1; joinFirst = 2; joinNext = 3; confirmSpace = 4; (* state *)
VAR
box: LineBox; ra: TextRulers.Attributes;
h, asc, dsc, backup, pos, state: INTEGER; isRuler: BOOLEAN;
PROCEDURE FetchNextLine;
BEGIN
s.GetLine(pos, box);
IF box.len > 0 THEN
ra := box.ruler.style.attr; isRuler := box.rpos = pos;
asc := box.asc + s.GridOffset(dsc, box); dsc := box.dsc; h := asc + dsc
END
END FetchNextLine;
PROCEDURE HandleRuler;
CONST norm = 0; nbi = 1; pj = 2;
VAR strength: INTEGER;
BEGIN
IF isRuler & (pos > start) & ~(pageBreak IN ra.opts) THEN
IF parJoin IN ra.opts THEN strength := pj
ELSIF noBreakInside IN ra.opts THEN strength := nbi
ELSE strength := norm
END;
CASE state OF
| regular:
CASE strength OF
| norm:
| nbi: state := protectInside; backup := pos
| pj: state := joinFirst; backup := pos
END
| protectInside:
CASE strength OF
| norm: state := regular
| nbi: backup := pos
| pj: state := joinFirst; backup := pos
END
| joinFirst:
CASE strength OF
| norm: state := confirmSpace
| nbi: state := protectInside
| pj: state := joinNext
END
| joinNext:
CASE strength OF
| norm: state := confirmSpace
| nbi: state := protectInside
| pj:
END
| confirmSpace:
CASE strength OF
| norm: state := regular
| nbi: state := protectInside; backup := pos
| pj: state := joinFirst; backup := pos
END
END
END
END HandleRuler;
PROCEDURE IsEmptyLine (): BOOLEAN;
BEGIN
RETURN (box.right = box.left)ORs.hideMarks & isRuler & ~(pageBreak IN ra.opts)
END IsEmptyLine;
BEGIN
ASSERT(s.text # NIL, 20);
ASSERT(0 <= start, 21); ASSERT(start <= s.text.Length(), 22);
pos := start; dsc := -1;
FetchNextLine;
IF box.len > 0 THEN
state := regular;
REPEAT (* at least one line per page *)
HandleRuler; DEC(pageH, h); INC(pos, box.len);
IF (state = confirmSpace) & ~IsEmptyLine() THEN state := regular END;
FetchNextLine
UNTIL (box.len = 0)OR(pageH - h < 0)ORisRuler & (pageBreak IN ra.opts);
IF ~isRuler OR ~(pageBreak IN ra.opts) THEN
WHILE (box.len > 0) & IsEmptyLine() DO (* skip empty lines at top of page *)
HandleRuler; INC(pos, box.len); FetchNextLine
END
END;
HandleRuler;
IF (state # regular) & ~(isRuler & (pageBreak IN ra.opts) OR (box.len = 0)) THEN pos := backup END
END;
RETURN pos
END NextPage;
PROCEDURE (s: StdSetter) NextSequence (start: INTEGER): INTEGER;
(* pre: connected, ThisSequence(start) = start *)
(* post: (result = start) & last-line(start) OR (ThisSequence(t, result - 1) = start) *)
VAR rd: TextModels.Reader; ch: CHAR;
BEGIN
ASSERT(s.text # NIL, 20);
s.r := s.text.NewReader(s.r); rd := s.r; rd.SetPos(start);
REPEAT rd.ReadChar(ch) UNTIL rd.eot OR (ch = line) OR (ch = para);
IF rd.eot THEN RETURN start ELSE RETURN rd.Pos() END
END NextSequence;
PROCEDURE (s: StdSetter) ThisSequence (pos: INTEGER): INTEGER;
(* pre: connected, 0 <= pos <= t.Length() *)
(* post: (result = 0) OR (char(result - 1) IN {line, para}) *)
VAR rd: TextModels.Reader; start, limit: INTEGER; ch: CHAR;
BEGIN
ASSERT(s.text # NIL, 20); ASSERT(0 <= pos, 21); ASSERT(pos <= s.text.Length(), 22);
IF pos = 0 THEN
RETURN 0
ELSE
start := CachedSeqStart(s.key, pos);
IF start < 0 THEN
s.r := s.text.NewReader(s.r); rd := s.r; rd.SetPos(pos);
limit := paraShutoff;
REPEAT rd.ReadPrevChar(ch); DEC(limit)
UNTIL rd.eot OR (ch = line) OR (ch = para) OR (limit = 0);
IF rd.eot THEN start := 0 ELSE start := rd.Pos() + 1 END;
AddSeqStartToCache(s.key, pos, start)
END;
RETURN start
END
END ThisSequence;
PROCEDURE (s: StdSetter) PreviousSequence (start: INTEGER): INTEGER;
(* pre: connected, ThisSequence(t, start) = start *)
(* post: (result = 0) & (start = 0) OR (result = ThisSequence(t, start - 1)) *)
BEGIN
IF start <= 1 THEN RETURN 0 ELSE RETURN s.ThisSequence(start - 1) END
END PreviousSequence;
PROCEDURE (s: StdSetter) ThisLine (pos: INTEGER): INTEGER;
(* pre: connected *)
VAR start, next: INTEGER;
BEGIN
next := s.ThisSequence(pos);
REPEAT start := next; next := s.NextLine(start) UNTIL (next > pos) OR (next = start);
RETURN start
END ThisLine;
PROCEDURE (s: StdSetter) NextLine (start: INTEGER): INTEGER;
(* pre: connected, ThisLine(start) = start *)
(* post: (result = 0) & (start = 0) OR
(result = start) & last-line(start) OR
(ThisLine(result - 1) = start) *)
VAR box: LineBox; len: INTEGER; i: INTEGER; eot: BOOLEAN;
BEGIN
i := CacheIndex(s.key, start);
IF i >= 0 THEN
len := boxCache[i].line.len; eot := boxCache[i].line.eot
ELSE
s.GetLine(start, box); len := box.len; eot := box.eot
END;
IF ~eot THEN RETURN start + len ELSE RETURN start END
END NextLine;
PROCEDURE (s: StdSetter) PreviousLine (start: INTEGER): INTEGER;
(* pre: connected, ThisLine(start) = start *)
(* post: (result = 0) & (start = 0) OR (result = ThisLine(start - 1)) *)
BEGIN
IF start <= 1 THEN start := 0 ELSE start := s.ThisLine(start - 1) END;
RETURN start
END PreviousLine;
PROCEDURE (s: StdSetter) GetWord (pos: INTEGER; OUT beg, end: INTEGER);
(* pre: connected, 0 <= pos <= s.text.Length() *)
(* post: beg <= pos <= end *)
CONST wordCutoff = LEN(s.rd.string);
VAR w: Worder; part: BOOLEAN;
BEGIN
ASSERT(s.text # NIL, 20); ASSERT(0 <= pos, 21); ASSERT(pos <= s.text.Length(), 22);
SetWorder(w, s, pos, beg); end := beg;
REPEAT
StepWorder(w, s, part); INC(end);
IF ~part THEN beg := end END
UNTIL end >= pos;
DEC(end);
REPEAT
StepWorder(w, s, part); INC(end)
UNTIL ~part OR (s.rd.string[0] = 0X) OR (end - beg > wordCutoff)
END GetWord;
PROCEDURE (s: StdSetter) GetLine (start: INTEGER; OUT box: LineBox);
VAR rd: Reader; ra: TextRulers.Attributes; brk: LineBox;
d, off, right, w: INTEGER; i, tabsN: INTEGER; form: SET; adj: BOOLEAN; ch: CHAR;
PROCEDURE TrueW (VAR b: LineBox; w: INTEGER): INTEGER;
VAR i: INTEGER; type: SET;
BEGIN
i := rd.tabIndex;
IF (0 <= i ) & (i < TextRulers.maxTabs) & (rd.string[0] # tab) THEN
type := rd.tabType * {TextRulers.centerTab, TextRulers.rightTab};
IF type = {TextRulers.centerTab} THEN
DEC(w, b.tabW[i] - MAX(minTabWidth, b.tabW[i] - w DIV 2))
ELSIF type = {TextRulers.rightTab} THEN
DEC(w, b.tabW[i] - MAX(minTabWidth, b.tabW[i] - w))
END
END;
RETURN w
END TrueW;
PROCEDURE Enclose (VAR b: LineBox; w: INTEGER);
VAR off, i, d: INTEGER; type: SET;
BEGIN
b.len := rd.pos - start; INC(b.right, w);
off := rd.attr.offset; i := rd.tabIndex;
IF rd.h - rd.dsc + off > b.asc THEN b.asc := rd.h - rd.dsc + off END;
IF rd.dsc - off > b.dsc THEN b.dsc := rd.dsc - off END;
IF rd.view # NIL THEN b.views := TRUE END;
IF (0 <= i ) & (i < TextRulers.maxTabs) THEN
IF rd.string[0] = tab THEN
b.tabW[i] := w
ELSE
type := rd.tabType * {TextRulers.centerTab, TextRulers.rightTab};
IF type = {TextRulers.centerTab} THEN
d := b.tabW[i] - MAX(minTabWidth, b.tabW[i] - w DIV 2);
DEC(b.tabW[i], d); DEC(b.right, d)
ELSIF type = {TextRulers.rightTab} THEN
d := b.tabW[i] - MAX(minTabWidth, b.tabW[i] - w);
DEC(b.tabW[i], d); DEC(b.right, d)
END
END
END
END Enclose;
BEGIN
ASSERT(s.text # NIL, 20); ASSERT(0 <= start, 21); ASSERT(start <= s.text.Length(), 22);
i := CacheIndex(s.key, start);
IF i >= 0 THEN
GetFromCache(s, i, box)
ELSE
TextRulers.GetValidRuler(s.text, start, s.rpos, s.ruler, s.rpos);
IF s.rpos > start THEN s.ruler := s.defRuler; s.rpos := -1 END;
box.ruler := s.ruler; box.rpos := s.rpos;
ra := s.ruler.style.attr; tabsN := ra.tabs.len; right := Right(ra, s.vw);
s.r := s.text.NewReader(s.r);
IF start = 0 THEN s.r.SetPos(start); ch := para
ELSE s.r.SetPos(start - 1); s.r.ReadChar(ch)
END;
s.r.Read;
(*
IF s.r.char = para THEN box.rbox := ~s.hideMarks; box.bop := s.hideMarks; box.left := 0
ELSIF ch = para THEN box.rbox := FALSE; box.bop := TRUE; box.left := ra.first
ELSE box.rbox := FALSE; box.bop := FALSE; box.left := ra.left
END;
*)
IF s.r.char = para THEN box.rbox := TRUE; box.bop := FALSE; box.left := 0
ELSIF ch = para THEN box.rbox := FALSE; box.bop := TRUE; box.left := ra.first
ELSE box.rbox := FALSE; box.bop := FALSE; box.left := ra.left
END;
(**)
box.views := FALSE;
box.asc := 0; box.dsc := 0; box.right := box.left;
box.len := 0; box.adjOff := 0; box.spaces := 0;
brk.right := 0;
s.rd := s.NewReader(s.rd); rd := s.rd;
rd.Set(s.r, s.text, box.left, start, box.ruler, box.rpos, s.vw, s.hideMarks);
rd.Read;
WHILE ~rd.eot & (box.right + (*rd.w*) TrueW(box, rd.w) <= right)
& ~(lineBreak IN rd.setterOpts) DO
IF ~(wordJoin IN rd.setterOpts) & (box.right + rd.endW <= right) THEN
(*brk := box;*)
brk.len := box.len; brk.ruler := box.ruler; brk.rpos := box.rpos;
brk.left := box.left; brk.right := box.right; brk.asc := box.asc; brk.dsc := box.dsc;
brk.rbox := box.rbox; brk.bop := box.bop; brk.adj := box.adj; brk.eot := box.eot;
brk.views := box.views; brk.skipOff := box.skipOff; brk.adjOff := box.adjOff;
brk.spaces := box.spaces; brk.adjW := box.adjW;
i := 0; WHILE i < tabsN DO brk.tabW[i] := box.tabW[i]; INC(i) END;
(*---*)
Enclose(brk, rd.endW);
brk.eot := rd.r.eot (* rd.r.eot one ahead of rd.eot *)
END;
box.adjOff := rd.adjStart - start; box.spaces := rd.spaces;
Enclose(box, rd.w);
rd.x := box.right; rd.Read
END;
IF (lineBreak IN rd.setterOpts) (* & ~box.rbox *) THEN Enclose(box, 0) END;
box.eot := rd.eot; adj := FALSE; box.skipOff := box.len;
IF box.right + rd.w > right THEN (* rd.w > 0 => ~rd.eot & ~(lineBreak IN setterOpts) *)
IF ~(wordJoin IN rd.setterOpts) & (box.right + rd.endW <= right) THEN
IF rd.string[0] = " " THEN DEC(box.spaces) END;
Enclose(box, rd.endW);
adj := TRUE
ELSIF brk.right > 0 THEN
(*box := brk;*)
box.len := brk.len; box.ruler := brk.ruler; box.rpos := brk.rpos;
box.left := brk.left; box.right := brk.right; box.asc := brk.asc; box.dsc := brk.dsc;
box.rbox := brk.rbox; box.bop := brk.bop; box.adj := brk.adj; box.eot := brk.eot;
box.views := brk.views; box.skipOff := brk.skipOff; box.adjOff := brk.adjOff;
box.spaces := brk.spaces; box.adjW := brk.adjW;
i := 0; WHILE i < tabsN DO box.tabW[i] := brk.tabW[i]; INC(i) END;
(*---*)
box.skipOff := box.len - 1; adj := TRUE
ELSIF box.right = box.left THEN
Enclose(box, rd.w) (* force at least one per line *)
END
ELSIF (box.right = box.left) & box.eot THEN
box.asc := ra.asc; box.dsc := ra.dsc (* force empty line to ruler's default height *)
END;
box.adj := FALSE;
d := right - box.right;
IF d > 0 THEN
form := ra.opts * adjustMask;
IF form = blocked THEN
IF adj & (box.spaces > 0) THEN
box.right := right; box.adj := TRUE; box.adjW := d
END
ELSIF form = rightFlush THEN
IF box.adjOff > 0 THEN
box.adjW := d; box.adj := TRUE
ELSE
INC(box.left, d)
END;
box.right := right
ELSIF form = centered THEN
IF box.adjOff > 0 THEN
box.adjW := d DIV 2; box.adj := TRUE
ELSE
INC(box.left, d DIV 2)
END;
INC(box.right, d DIV 2)
END
END;
AddToCache(s.key, start, box)
END;
ASSERT(box.eot OR (box.len > 0), 100)
END GetLine;
PROCEDURE (s: StdSetter) GetBox (start, end, maxW, maxH: INTEGER; OUT w, h: INTEGER);
VAR box: LineBox; asc, dsc: INTEGER;
BEGIN
ASSERT(s.text # NIL, 20);
ASSERT(0 <= start, 21);
ASSERT(start <= end, 22);
ASSERT(end <= s.text.Length(), 23);
w := 0; h := 0; dsc := -1;
IF maxW <= Views.undefined THEN maxW := MAX(INTEGER) END;
IF maxH <= Views.undefined THEN maxH := MAX(INTEGER) END;
WHILE (start < end) & (h < maxH) DO
s.GetLine(start, box);
IF box.rbox THEN w := MAX(w, Right(box.ruler.style.attr, s.vw))
ELSE w := MAX(w, box.right)
END;
asc := box.asc + s.GridOffset(dsc, box); dsc := box.dsc;
INC(start, box.len); INC(h, asc + dsc)
END;
w := MIN(w, maxW); h := MIN(h, maxH)
END GetBox;
PROCEDURE (s: StdSetter) NewReader (old: Reader): Reader;
(* pre: connected *)
VAR rd: StdReader;
BEGIN
ASSERT(s.text # NIL, 20);
IF (old # NIL) & (old IS StdReader) THEN RETURN old
ELSE NEW(rd); RETURN rd
END
END NewReader;
PROCEDURE (s: StdSetter) GridOffset (dsc: INTEGER; IN box: LineBox): INTEGER;
VAR ra: TextRulers.Attributes; h, h0: INTEGER;
(* minimal possible line spacing h0, minimal legal line spacing h *)
BEGIN
IF ~box.rbox THEN
ra := box.ruler.style.attr;
IF dsc < 0 THEN
RETURN 0 (* no longer try to correct first line's grid position -- should be done when printing... *)
(*
h0 := box.asc; h := ra.asc;
IF h < h0 THEN (* override legal spacing if to small *)
h := h - (h - h0) DIV ra.grid * ra.grid (* adjust to next larger grid line *)
END;
RETURN h - h0
*)
ELSE
h0 := box.asc + dsc; h := ra.asc + ra.dsc;
IF h < h0 THEN h := h0 END; (* override legal spacing if to small *)
RETURN - (-h) DIV ra.grid * ra.grid - h0 (* adjust to next larger grid line *)
END
ELSE
RETURN 0
END
END GridOffset;
(* StdDirectory *)
PROCEDURE (d: StdDirectory) New (): Setter;
VAR s: StdSetter;
BEGIN
NEW(s); s.text := NIL; RETURN s
END New;
(** miscellaneous **)
PROCEDURE Init;
VAR d: StdDirectory;
BEGIN
InitCache;
NEW(d); dir := d; stdDir := d
END Init;
PROCEDURE SetDir* (d: Directory);
BEGIN
ASSERT(d # NIL, 20); dir := d
END SetDir;
BEGIN
Init
END TextSetters.