BufferedTiogaDisplays.Mesa
Last Edited by: Spreitzer, November 7, 1985 4:09:58 pm PST
DIRECTORY Ascii, Atom, Basics, CharDisplays, IO, IOClasses, Menus, MessageWindow, NodeProps, Process, RefText, Rope, TiogaMenuOps, TiogaOps, TIPUser, ViewerClasses, ViewerOps;
BufferedTiogaDisplays: CEDAR MONITOR
LOCKS NARROW[cd.otherInstanceData, TiogaDisplay] USING cd: CharDisplay
IMPORTS Ascii, Atom, Basics, CharDisplays, IO, IOClasses, Menus, MessageWindow, NodeProps, Process, RefText, Rope, TiogaMenuOps, TiogaOps, TIPUser, ViewerOps
= {OPEN CharDisplays;
REFTEXT: TYPE = REF TEXT;
Viewer: TYPE = ViewerClasses.Viewer;
ViewerClass: TYPE = ViewerClasses.ViewerClass;
TiogaDisplay: TYPE = REF TiogaDisplayRep;
TiogaDisplayRep: TYPE = MONITORED RECORD [
root, logNode, arrayNode: TiogaOps.Ref,
req, ack: CONDITION,
proc: PROCESSNIL,
activity: BOOLFALSE,
flush: BOOLFALSE,
insertLine: INT ← 0,
insertCol: INT ← 0,
deleteCount: NAT ← 0,
insertLooks: ROPE ← baseLooks,
insertBuffer: REFTEXTNIL --actually RefText.New[cd.det.columns]--,
caretWrong: BOOLFALSE,
eatChars, spitChars: IO.STREAMNIL,
looks: ROPE ← baseLooks,
spaces: ROPENIL,
lineS: SEQUENCE length: NAT OF Line
];
baseLooks: ROPE = "";
Line: TYPE = RECORD [
tiogaCount: NAT,
key: ATOM];
tiogaClass, tiogaDisplayViewerClass: ViewerClass ← NIL;
tiogaDisplayViewerClassFlavor: ATOM ← $BufferedTiogaCharDisplay;
tdProp: ATOM ← $TiogaDisplayData;
minPause: Process.Milliseconds ← 250;
maxFactor: NAT ← 16;
tiogaCharDisplayClass: CharDisplayClass ← NEW [CharDisplayClassRep ← [
name: "BufferedTioga",
Init: Init,
ChangeDetails: SimplyChange,
DeleteChar: DeleteChar,
TakeChar: TakeChar,
CursorMove: CursorMove,
Line: TLine,
ClearTo: ClearTo,
ClearAll: ClearAll,
SetEmph: SetEmph,
Emphasize: Emphasize,
SetFont: SetFont,
Flash: Flash]];
InitTiogaDisplayClass: PROC = {
tdTIP: TIPUser.TIPTable ← TIPUser.InstantiateNewTIPTable["TiogaDisplay.TIP"];
menu: Menus.Menu ← Menus.CreateMenu[];
tiogaClass ← ViewerOps.FetchViewerClass[$Text];
tiogaDisplayViewerClass ← NEW [ViewerClasses.ViewerClassRec ← tiogaClass^];
tiogaDisplayViewerClass.notify ← NotifyTiogaDisplay;
tiogaDisplayViewerClass.icon ← typescript;
tdTIP.mouseTicks ← MIN[tdTIP.mouseTicks, tiogaClass.tipTable.mouseTicks];
tdTIP.opaque ← FALSE;
tdTIP.link ← tiogaClass.tipTable;
tiogaDisplayViewerClass.tipTable ← tdTIP;
menu.AppendMenuEntry[Menus.CreateEntry["Find", Find]];
menu.AppendMenuEntry[Menus.CreateEntry["Word", Word]];
menu.AppendMenuEntry[Menus.CreateEntry["Def", Def]];
menu.AppendMenuEntry[Menus.CreateEntry["Position", Position]];
menu.AppendMenuEntry[Menus.CreateEntry["Normalize", Normalize]];
menu.AppendMenuEntry[Menus.CreateEntry["PrevPlace", PrevPlace]];
menu.AppendMenuEntry[Menus.CreateEntry["Reselect", Reselect]];
tiogaDisplayViewerClass.menu ← menu;
ViewerOps.RegisterViewerClass[tiogaDisplayViewerClassFlavor, tiogaDisplayViewerClass];
RegClass[tiogaCharDisplayClass];
};
Find: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
[] ← TiogaOps.FindText[viewer: v, whichDir: SearchDir[mouseButton], case: NOT shift];
};
Word: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
[] ← TiogaOps.FindWord[viewer: v, whichDir: SearchDir[mouseButton], case: NOT shift];
};
Def: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
[] ← TiogaOps.FindDef[viewer: v, whichDir: SearchDir[mouseButton], case: NOT shift];
};
SearchDir: PROC [mb: Menus.MouseButton] RETURNS [sd: TiogaOps.SearchDir] =
{sd ← SELECT mb FROM red => forwards, yellow => anywhere, blue => backwards, ENDCASE => ERROR};
Position: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
TiogaMenuOps.Position[v]};
Normalize: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
TiogaMenuOps.Normalize[v]};
PrevPlace: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
TiogaMenuOps.PrevPlace[v]};
Reselect: Menus.MenuProc = {
v: Viewer ← NARROW[parent];
TiogaMenuOps.Reselect[v]};
NotifyTiogaDisplay: PROC [self: Viewer, input: LIST OF REF ANY] --ViewerClasses.NotifyProc-- = {
td: TiogaDisplay ← GetDisplay[self];
WITH input.first SELECT FROM
a: ATOM => SELECT a FROM
$TDInput => {
r: ROPE;
ctl, shift, meta: BOOLFALSE;
FOR input ← input.rest, input.rest WHILE input # NIL DO
WITH input.first SELECT FROM
R: ROPE => r ← R;
t: REFTEXT => r ← Rope.FromRefText[t];
b: ATOM => SELECT b FROM
$Ctl => ctl ← TRUE;
$Shift => shift ← TRUE;
$Meta => meta ← TRUE;
ENDCASE => ERROR;
ENDCASE => ERROR;
ENDLOOP;
FOR i: INT IN [0 .. r.Length[]) DO
c: CHAR ← r.Fetch[i];
IF NOT shift THEN c ← Ascii.Lower[c];
IF ctl THEN c ← Control[c];
IF meta THEN c ← c + 128;
td.eatChars.PutChar[c !
IO.Error => {
MessageWindow.Append[Rope.Cat["Stream from terminal ", self.name, " broken"], TRUE];
MessageWindow.Blink[];
MessageWindow.Clear[];
EXIT}
];
ENDLOOP;
RETURN;
};
ENDCASE;
r: ROPE => {
td.eatChars.PutRope[r];
RETURN;
};
ENDCASE;
tiogaClass.notify[self, input];
};
Control: PROC [c: CHAR] RETURNS [cc: CHAR] = {
d: NAT ← c - 0C;
cd: NAT ← Basics.BITAND[d, 31];
cc ← 0C + cd;
};
GetDisplay: PROC [self: Viewer] RETURNS [td: TiogaDisplay] = INLINE
{td ← NARROW[ViewerOps.FetchProp[viewer: self, prop: tdProp]]};
Init: PROC [cd: CharDisplay, initData: REF ANYNIL] = {
td: TiogaDisplay ← NEW [TiogaDisplayRep[cd.det.lines]];
InitDoc: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
TiogaOps.PutProp[
n: td.root,
name: $StyleDef,
value: NodeProps.DoSpecs[$StyleDef, "
BeginStyle
(Cedar) AttachStyle
(look.v) \"video reverse\" {\"ReverseGacha\" family} StyleRule
EndStyle
"]
];
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, 0]];
TiogaOps.Break[];
td.logNode ← TiogaOps.FirstChild[td.root];
td.arrayNode ← TiogaOps.LastChild[td.root];
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, 0]];
TiogaOps.SetLooks[baseLooks, caret];
TiogaOps.InsertChar['\n];
FOR i: NAT IN [0 .. cd.det.columns) DO
TiogaOps.InsertChar['0 + (i / 10)];
ENDLOOP;
TiogaOps.InsertChar['\n];
TiogaOps.SetLooks[baseLooks.Cat["z"], caret];
FOR i: NAT IN [0 .. cd.det.columns) DO
TiogaOps.InsertChar['0 + (i MOD 10)];
ENDLOOP;
TiogaOps.SetLooks[baseLooks, caret];
TiogaOps.InsertChar['\n];
FOR l: NAT IN [0 .. cd.det.lines) DO
TiogaOps.InsertChar['\n];
td.lineS[l] ← [
tiogaCount: 0,
key: Atom.MakeAtom[IO.PutFR["Before%g", IO.int[l]]]
];
ENDLOOP;
IF NOT wasIn THEN TiogaOps.RestoreSelA[];
};
cd.otherInstanceData ← td;
cd.viewer ← ViewerOps.CreateViewer[flavor: tiogaDisplayViewerClassFlavor, info: [name: cd.name]];
cd.viewer.tipTable ← tiogaDisplayViewerClass.tipTable;
cd.viewer.menu ← tiogaDisplayViewerClass.menu.CopyMenu[];
ViewerOps.AddProp[viewer: cd.viewer, prop: tdProp, val: td];
td.root ← TiogaOps.ViewerDoc[cd.viewer];
td.logNode ← TiogaOps.FirstChild[td.root];
td.arrayNode ← TiogaOps.LastChild[td.root];
TRUSTED {
Process.InitializeCondition[@td.req, Process.MsecToTicks[minPause]];
Process.EnableAborts[@td.req];
Process.InitializeCondition[@td.ack, Process.SecondsToTicks[1]];
Process.EnableAborts[@td.ack];
};
td.activity ← td.flush ← FALSE;
td.insertLine ← td.insertCol ← td.deleteCount ← 0;
td.insertLooks ← baseLooks;
td.insertBuffer ← RefText.New[cd.det.columns];
td.caretWrong ← FALSE;
[push: td.eatChars, pull: td.spitChars] ← IOClasses.CreatePipe[];
cd.fromDisplay ← td.spitChars;
td.looks ← baseLooks;
td.spaces ← " ";
FOR i: INT IN [0 .. cd.det.columns) DO
td.spaces ← td.spaces.Cat[" "];
ENDLOOP;
TiogaOps.CallWithLocks[InitDoc, td.root];
ReallySetFont[td, "Gacha"];
SetLines[cd, td];
TRUSTED {Process.Detach[td.proc ← FORK Refresh[cd]]};
};
Flush: INTERNAL PROC [cd: CharDisplay, td: TiogaDisplay] = {
WHILE td.insertBuffer.length > 0 OR td.caretWrong DO
td.flush ← TRUE;
BROADCAST td.req;
WAIT td.ack;
ENDLOOP;
td.activity ← TRUE;
};
Refresh: ENTRY PROC [cd: CharDisplay] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
WHILE NOT cd.viewer.destroyed DO
td.activity ← FALSE;
WAIT td.req;
IF (td.flush OR NOT td.activity) AND (td.insertBuffer.length > 0 OR td.caretWrong) THEN {
WithLocks: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
IF td.insertBuffer.length > 0 THEN {
base: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[td.insertLine].key].where;
wasEmpty: BOOL ← td.lineS[td.insertLine].tiogaCount = 0;
start: INT ← base+MIN[td.insertCol, td.lineS[td.insertLine].tiogaCount];
end: INT ← base+MIN[td.insertCol+td.deleteCount, td.lineS[td.insertLine].tiogaCount];
goners: INT ← end - start;
colDelta: INT ← td.insertCol - td.lineS[td.insertLine].tiogaCount;
IF end > start
THEN TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, start],
end: [td.arrayNode, end-1 --because it's a char address, not a point address--],
pendingDelete: TRUE]
ELSE TiogaOps.SelectPoint[
viewer: cd.viewer,
caret: [td.arrayNode, start]];
IF colDelta > 0 THEN {
TiogaOps.SetLooks[looks: baseLooks, which: caret];
TiogaOps.InsertRope[td.spaces.Substr[0, colDelta]];
td.lineS[td.insertLine].tiogaCount ← td.lineS[td.insertLine].tiogaCount + colDelta;
};
TiogaOps.SetLooks[looks: td.insertLooks, which: caret];
TiogaOps.InsertRope[Rope.FromRefText[td.insertBuffer]];
td.lineS[td.insertLine].tiogaCount ← td.lineS[td.insertLine].tiogaCount + td.insertBuffer.length - goners;
IF wasEmpty OR td.insertCol = 0 THEN TiogaOps.PutTextKey[node: td.arrayNode, where: base, key: td.lineS[td.insertLine].key];
IF cd.line = td.insertLine AND cd.col = td.insertCol + td.insertBuffer.length THEN td.caretWrong ← FALSE;
td.insertBuffer.length ← 0;
td.deleteCount ← 0;
};
IF NOT wasIn THEN {
TiogaOps.RestoreSelA[];
td.caretWrong ← FALSE;
}
ELSE IF td.caretWrong THEN {
ReallyMoveCursor[cd, td, cd.line, cd.col];
td.caretWrong ← FALSE;
};
};
TiogaOps.CallWithLocks[WithLocks, td.root];
};
IF td.flush THEN {
td.flush ← FALSE;
BROADCAST td.ack};
ENDLOOP;
};
SetLines: PROC [cd: CharDisplay, td: TiogaDisplay, recursed: BOOLFALSE] = {
IsBegin: PROC [ci: INT] RETURNS [is: BOOL] =
INLINE {is ← ci = 0 OR nr.Fetch[ci-1] = '\n};
nr: ROPE;
lineNum, prevCI: INT;
td.arrayNode ← TiogaOps.LastChild[td.root];
nr ← TiogaOps.GetRope[td.arrayNode];
lineNum ← cd.det.lines;
prevCI ← nr.Length[];
FOR ci: INT ← nr.Length[]-1, ci-1 WHILE lineNum > 0 DO
IF ci < 0 THEN {
IF recursed THEN ERROR;
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, 0]];
FOR i: INT IN [0 .. lineNum] DO TiogaOps.InsertChar['\n] ENDLOOP;
SetLines[cd, td, TRUE];
EXIT;
};
IF IsBegin[ci] THEN {
lineNum ← lineNum - 1;
TiogaOps.PutTextKey[node: td.arrayNode, where: ci, key: td.lineS[lineNum].key];
td.lineS[lineNum].tiogaCount ← prevCI - ci - 1;
prevCI ← ci;
};
ENDLOOP;
};
DeleteChar: ENTRY PROC [cd: CharDisplay] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
WithLocks: PROC [root: TiogaOps.Ref] = {
base: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.line].key].where;
IF root # td.root THEN ERROR;
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, base+cd.col]];
TiogaOps.DeleteNextCharacter[];
td.lineS[cd.line].tiogaCount ← td.lineS[cd.line].tiogaCount - 1;
};
IF cd.col >= td.lineS[cd.line].tiogaCount AND NOT (td.insertLine = cd.line AND td.insertBuffer.length > 0) THEN RETURN;
Flush[cd, td];
TiogaOps.CallWithLocks[WithLocks, td.root];
};
TakeChar: ENTRY PROC [cd: CharDisplay, char: CHAR, insert: BOOLFALSE] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
IF char = '\n THEN char ← char + 0200B;
IF
(td.insertBuffer.length >= td.insertBuffer.maxLength) OR
(
(td.insertBuffer.length > 0) AND
(cd.line # td.insertLine OR cd.col # td.insertCol + td.insertBuffer.length OR NOT td.insertLooks.Equal[td.looks]))
THEN Flush[cd, td];
IF td.insertBuffer.length = 0 THEN {td.insertLine ← cd.line; td.insertCol ← cd.col; td.insertLooks ← td.looks};
IF NOT insert THEN td.deleteCount ← td.deleteCount + 1;
td.insertBuffer[td.insertBuffer.length] ← char;
td.insertBuffer.length ← td.insertBuffer.length + 1;
td.activity ← TRUE;
InternalCursorMove[cd, 0, 1, TRUE];
};
ReallyMoveCursor: PROC [cd: CharDisplay, td: TiogaDisplay, line, col: INT] = {
colDelta: INT;
IF line >= cd.det.lines THEN {
delta: INTMIN[line - (cd.det.lines-1), cd.det.lines];
arrayEnd: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.det.lines-1].key].where + td.lineS[cd.det.lines-1].tiogaCount + 1;
topStart: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[0].key].where;
topEnd: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[delta-1].key].where + td.lineS[delta-1].tiogaCount;
line ← line - delta;
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, arrayEnd]];
FOR i: INT IN [0 .. delta) DO TiogaOps.InsertChar['\n] ENDLOOP;
FOR i: INT IN [delta .. cd.det.lines) DO
td.lineS[i-delta].tiogaCount ← td.lineS[i].tiogaCount;
TiogaOps.PutTextKey[
node: td.arrayNode,
where: TiogaOps.GetTextKey[td.arrayNode, td.lineS[i].key].where,
key: td.lineS[i-delta].key];
ENDLOOP;
FOR i: INT IN [cd.det.lines - delta .. cd.det.lines) DO
td.lineS[i].tiogaCount ← 0;
TiogaOps.PutTextKey[
node: td.arrayNode,
where: arrayEnd + i - (cd.det.lines - delta),
key: td.lineS[i].key];
ENDLOOP;
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.logNode, TiogaOps.GetRope[td.logNode].Length[]]];
TiogaOps.SetSelection[viewer: cd.viewer, start: [td.arrayNode, topStart], end: [td.arrayNode, topEnd], pendingDelete: TRUE, which: secondary];
TiogaOps.ToPrimary[];
};
cd.line ← line;
cd.col ← col;
colDelta ← cd.col - td.lineS[cd.line].tiogaCount;
TiogaOps.SelectPoint[
viewer: cd.viewer,
caret: [
td.arrayNode,
TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.line].key].where + MIN[cd.col, td.lineS[cd.line].tiogaCount]]
];
IF colDelta > 0 THEN {
wasEmpty: BOOL ← td.lineS[cd.line].tiogaCount = 0;
TiogaOps.SetLooks[baseLooks, caret];
TiogaOps.InsertRope[td.spaces.Substr[0, colDelta]];
td.lineS[cd.line].tiogaCount ← td.lineS[cd.line].tiogaCount + colDelta;
IF wasEmpty THEN SetLines[cd, td];
};
};
CursorMove: ENTRY PROC [cd: CharDisplay, line, col: INT, relative: BOOLFALSE, doLine, doCol: BOOLTRUE] = {
ENABLE UNWIND => {};
InternalCursorMove[cd: cd, line: line, col: col, relative: relative, doLine: doLine, doCol: doCol];
};
InternalCursorMove: INTERNAL PROC [cd: CharDisplay, line, col: INT, relative: BOOLFALSE, doLine, doCol: BOOLTRUE] = {
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
WithLocks: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
ReallyMoveCursor[cd, td, line, col];
IF NOT wasIn THEN TiogaOps.RestoreSelA[];
};
IF relative THEN {line ← line + cd.line; col ← col + cd.col};
IF NOT doLine THEN line ← cd.line;
IF NOT doCol THEN col ← cd.col;
IF cd.det.autoMargins THEN {
dl: INT ← col / cd.det.columns;
line ← line + dl;
col ← col - dl * cd.det.columns;
WHILE col < 0 DO col ← col + cd.det.columns; line ← line - 1 ENDLOOP;
}
ELSE col ← MAX[MIN[col, cd.det.columns-1], 0];
IF line < 0 THEN line ← 0;
IF line < cd.det.lines THEN NULL
ELSE IF NOT cd.det.scrolls THEN line ← line MOD cd.det.lines;
IF line = cd.line AND col = cd.col THEN RETURN;
IF line >= cd.det.lines
THEN {
Flush[cd, td];
CallWithAllLocks[WithLocks, td.root];
}
ELSE {
cd.line ← line;
cd.col ← col;
td.caretWrong ← TRUE;
td.activity ← TRUE;
};
};
CallWithAllLocks: PROC [proc: PROC [root: TiogaOps.Ref], root: TiogaOps.Ref] = {
TiogaOps.LockSel[primary];
TiogaOps.LockSel[secondary];
{ENABLE UNWIND =>
{TiogaOps.UnlockSel[secondary]; TiogaOps.UnlockSel[primary]};
TiogaOps.CallWithLocks[proc, root];
};
TiogaOps.UnlockSel[secondary];
TiogaOps.UnlockSel[primary];
};
logLineDeletes: BOOLTRUE;
TLine: ENTRY PROC [cd: CharDisplay, insert: BOOL] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
endBase, endEnd, base: INT;
WithLocks: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
IF insert THEN {
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, endBase],
end: [td.arrayNode, endEnd]];
TiogaOps.Delete[];
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, base]];
TiogaOps.InsertChar['\n];
}
ELSE {
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, endEnd+1]];
TiogaOps.InsertChar['\n];
IF logLineDeletes THEN {
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.logNode, TiogaOps.GetRope[td.logNode].Length[]]];
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, base],
end: [td.arrayNode, base + td.lineS[cd.line].tiogaCount],
pendingDelete: TRUE,
which: secondary
];
TiogaOps.ToPrimary[];
IF wasIn THEN {
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.arrayNode, base + MIN[cd.col, td.lineS[cd.line].tiogaCount]]];
td.caretWrong ← cd.col > td.lineS[cd.line].tiogaCount;
};
}
ELSE {
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, base],
end: [td.arrayNode, base + td.lineS[cd.line].tiogaCount]
];
TiogaOps.Delete[];
};
};
IF NOT wasIn THEN TiogaOps.RestoreSelA[];
};
Flush[cd, td];
endBase ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.det.lines-1].key].where;
endEnd ← endBase + td.lineS[cd.det.lines-1].tiogaCount;
base ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.line].key].where;
td.caretWrong ← TRUE;
(IF insert OR NOT logLineDeletes THEN TiogaOps.CallWithLocks ELSE CallWithAllLocks)[WithLocks, td.root];
SetLines[cd, td];
};
logClears: BOOLFALSE;
ClearTo: ENTRY PROC [cd: CharDisplay, where: Where] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
col: INT ← cd.col;
need: BOOLFALSE;
WithLocks: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
col: INT ← cd.col;
lastLine: INTSELECT where FROM
EndOfLine => cd.line,
EndOfScreen => cd.det.lines-1,
ENDCASE => ERROR;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
FOR line: INT IN [cd.line .. lastLine] DO
base: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[line].key].where;
begin: INT ← base + MIN[col, td.lineS[line].tiogaCount];
end: INT ← base + td.lineS[line].tiogaCount;
IF end > begin THEN {
IF logClears AND col = 0 THEN {
TiogaOps.SelectPoint[viewer: cd.viewer, caret: [td.logNode, TiogaOps.GetRope[td.logNode].Length[]]];
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, begin],
end: [td.arrayNode, end-1],
pendingDelete: TRUE,
which: secondary
];
TiogaOps.ToPrimary[];
TiogaOps.InsertChar['\n];
}
ELSE {
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, begin],
end: [td.arrayNode, end-1]
];
TiogaOps.Delete[];
};
td.lineS[line].tiogaCount ← begin - base;
IF td.lineS[line].tiogaCount = 0 THEN TiogaOps.PutTextKey[node: td.arrayNode, where: base, key: td.lineS[line].key];
};
col ← 0;
ENDLOOP;
IF NOT wasIn THEN TiogaOps.RestoreSelA[];
};
Flush[cd, td];
FOR line: INT IN [cd.line .. SELECT where FROM EndOfLine => cd.line, EndOfScreen => cd.det.lines-1, ENDCASE => ERROR] WHILE NOT need DO
IF td.lineS[line].tiogaCount > col THEN need ← TRUE;
col ← 0;
ENDLOOP;
IF NOT need THEN RETURN;
CallWithAllLocks[WithLocks, td.root];
td.caretWrong ← TRUE;
};
ClearAll: ENTRY PROC [cd: CharDisplay] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
WithLocks: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
begin: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[0].key].where;
end: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.det.lines-1].key].where + td.lineS[cd.det.lines-1].tiogaCount;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, begin],
end: [td.arrayNode, end],
pendingDelete: TRUE];
FOR l: INT IN [0 .. cd.det.lines) DO
TiogaOps.InsertChar['\n];
ENDLOOP;
IF NOT wasIn THEN TiogaOps.RestoreSelA[];
};
Flush[cd, td];
TiogaOps.CallWithLocks[WithLocks, td.root];
td.caretWrong ← TRUE;
SetLines[cd, td];
};
SetEmph: ENTRY PROC [cd: CharDisplay, emph: Emph, on: BOOL] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
cd.emphs[emph] ← on;
td.looks ← baseLooks;
IF cd.emphs[underline] THEN td.looks ← td.looks.Cat["z"];
IF cd.emphs[bold] THEN td.looks ← td.looks.Cat["b"];
IF cd.emphs[italic] THEN td.looks ← td.looks.Cat["i"];
IF cd.emphs[inverse] THEN td.looks ← td.looks.Cat["v"];
};
Emphasize: ENTRY PROC [cd: CharDisplay, emph: Emph, on: BOOL] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
WithLocks: PROC [root: TiogaOps.Ref] = {
wasIn: BOOL ← TiogaOps.SelectionRoot[] = td.root;
loc: INT ← TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.line].key].where + cd.col;
looks: ROPESELECT emph FROM
underline => "z",
bold => "b",
italic => "i",
inverse => "v",
ENDCASE => ERROR;
IF root # td.root THEN ERROR;
IF NOT wasIn THEN TiogaOps.SaveSelA[];
TiogaOps.SetSelection[
viewer: cd.viewer,
start: [td.arrayNode, loc],
end: [td.arrayNode, loc]];
(IF on THEN TiogaOps.AddLooks ELSE TiogaOps.SubtractLooks)[looks];
IF NOT wasIn THEN TiogaOps.RestoreSelA[];
};
Flush[cd, td];
IF cd.col > td.lineS[cd.line].tiogaCount THEN RETURN;
TiogaOps.CallWithLocks[WithLocks, td.root];
};
SetFont: ENTRY PROC [cd: CharDisplay, font: ROPE] = {
ENABLE UNWIND => {};
td: TiogaDisplay ← NARROW[cd.otherInstanceData];
ReallySetFont[td, font];
};
ReallySetFont: PROC [td: TiogaDisplay, font: ROPE] = {
TiogaOps.PutProp[
n: td.logNode,
name: $Postfix,
value: IO.PutFR["\"%g\" family", IO.rope[font]]
];
TiogaOps.PutProp[
n: td.arrayNode,
name: $Postfix,
value: IO.PutFR["\"%g\" family", IO.rope[font]]
];
};
Flash: PROC [cd: CharDisplay] = {
MessageWindow.Append["Beep", TRUE];
MessageWindow.Blink[];
MessageWindow.Clear[];
};
InitTiogaDisplayClass[];
}.