<<>>
    <<UnselectedFlushedBufferedTiogaDisplays.Mesa>>
        <<Copyright Ó 1986, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Mike Spreitzer January 22, 1987 10:35:30 pm PST>>
        <<Pavel, December 27, 1985 5:28:04 pm PST>>
        <<Last tweaked by Mike Spreitzer on November 14, 1989 4:52:01 pm PST>>
        <<Willie-s, June 12, 1992 2:11 pm PDT>>
        <<Bier, March 11, 1993 5:38 pm PST>>

    DIRECTORY Ascii, Atom, Basics, Beeps, CharDisplays, FS, IO, IOClasses, Menus, MessageWindow, NodeProps, NodeStyle, NodeStyleOps, 
    Process, Real, RefText, Rope, TextLooks, TextNode, TiogaMenuOps, TiogaOpers, TiogaOps, TIPLinking, TIPTableAccess, TIPTypes, 
    TIPUser, ViewerClasses, ViewerOps, ViewerTools;

    UnselectedFlushedBufferedTiogaDisplays: CEDAR MONITOR
        LOCKS td USING td: TiogaDisplay
        <<Locking Order: TiogaDisplay, then Viewers & Tioga>>
        IMPORTS Ascii, Atom, Basics, Beeps, CharDisplays, FS, IO, IOClasses, Menus, MessageWindow, NodeProps, NodeStyleOps, Process, Real, 
        RefText, Rope, TextLooks, TiogaMenuOps, TiogaOpers, TiogaOps, TIPLinking, TIPTableAccess, TIPUser, ViewerOps, ViewerTools
        = {OPEN CharDisplays;

        REFTEXT: TYPE = REF TEXT;
        Viewer: TYPE = ViewerClasses.Viewer;
        ViewerClass: TYPE = ViewerClasses.ViewerClass;
        TIPTable: TYPE ~ TIPTypes.TIPTable;

        baseLooksRope: ROPE = "";
        baseLooks: TextLooks.Looks = TextLooks.RopeToLooks[baseLooksRope];

        TiogaDisplay: TYPE = REF TiogaDisplayRep;
        TiogaDisplayRep: TYPE = MONITORED RECORD [
            destroyed: BOOL Ź FALSE,
            root, logNode, arrayNode: TiogaOps.Ref,
            insertLine: INT Ź 0,
            firstInsertCol, afterLastInsertCol: INT Ź 0,
            deleteCount: NAT Ź 0,
            insertLooks: ROPE Ź baseLooksRope,
            insertBuffer: REFTEXT Ź NIL --actually RefText.New[cd.det.columns]--,
            caretWrong: BOOL Ź FALSE,
            eatChars, spitChars: IO.STREAM Ź NIL,
            looks: ROPE Ź baseLooksRope,
            spaces: ROPE Ź NIL,
            lineS: SEQUENCE length: NAT OF Line
            ];

        Line: TYPE = RECORD [
            tiogaCount: NAT,
            key: ATOM];

        tiogaClass, tiogaDisplayViewerClass: ViewerClass Ź NIL;
        tiogaDisplayViewerClassFlavor: ATOM Ź $UnselectedFlushedBufferedTiogaCharDisplay;
        cdProp: ATOM Ź $CharDisplayFromViewer;

        tiogaCharDisplayClass: CharDisplayClass Ź NEW [CharDisplayClassRep Ź [
            name: "UnselectedFlushedBufferedTioga",
            Init: Init,
            ChangeDetails: SimplyChange,
            DeleteChar: DeleteChar,
            TakeChar: TakeChar,
            CursorMove: CursorMove,
            Line: TLine,
            ClearTo: ClearTo,
            ClearAll: ClearAll,
            SetEmph: SetEmph,
            Emphasize: Emphasize,
            SetFont: SetFont,
            Beep: Beep,
            Flush: Flush,
            Destroyed: Destroyed]];

        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.destroy Ź NoteTiogaDestruction;
            tiogaDisplayViewerClass.icon Ź typescript;
            <<tdTIP.mouseTicks Ź MIN[tdTIP.mouseTicks, tiogaClass.tipTable.mouseTicks];>>
            TIPTableAccess.SetMouseTicks[tdTIP,
                MIN[TIPTableAccess.GetMouseTicks[tdTIP],
                    TIPTableAccess.GetMouseTicks[tiogaClass.tipTable]] ];
            <<tdTIP.opaque Ź FALSE;>>
            TIPTableAccess.SetOpaque[tdTIP, FALSE];
            [] Ź TIPLinking.Append[early: tdTIP, late: tiogaClass.tipTable];
            tiogaDisplayViewerClass.tipTable Ź tdTIP;
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Find", Find]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Word", Word]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Def", Def]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Position", Position]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Normalize", Normalize]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["PrevPlace", PrevPlace]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Reselect", Reselect]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["Grab", Grab]];
            Menus.AppendMenuEntry[menu, Menus.CreateEntry["FixCarat", FixCarat]];
            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]};

        Grab: Menus.MenuProc = {
            v: Viewer = NARROW[parent];
            v.class.notify[v, LIST[ViewerTools.GetSelectionContents[]]];
            };

        FixCarat: Menus.MenuProc = {
            v: Viewer = NARROW[parent];
            cd: CharDisplay = GetDisplay[v];
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            EnterAndSetCarat[cd, td];
            };

        EnterAndSetCarat: ENTRY PROC [cd: CharDisplay, td: TiogaDisplay] = {
            ENABLE UNWIND => NULL;
            td.caretWrong Ź TRUE;
            MaybeSetCarat[cd, td];
            };

        NoteTiogaDestruction: PROC [self: Viewer] --ViewerClasses.DestroyProc-- = {
            cd: CharDisplay = GetDisplay[self];
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            IF cd.viewer.destroyed AND NOT td.destroyed THEN {
                td.destroyed Ź TRUE;
                td.eatChars.Close[TRUE !IO.Error => CONTINUE];
                td.spitChars.Close[TRUE !IO.Error => CONTINUE];
                };
            tiogaClass.destroy[self];
            };

        NotifyTiogaDisplay: ViewerClasses.NotifyProc --ViewerClasses.NotifyProc-- = {
            cd: CharDisplay = GetDisplay[self];
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            WITH input.first SELECT FROM
                a: ATOM => SELECT a FROM
                    $TDInput => {
                        r: ROPE;
                        ctl, shift, meta: BOOL Ź FALSE;
                        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;
                    };
                r: REFTEXT => {
                    td.eatChars.PutText[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 [cd: CharDisplay] = INLINE
            {cd Ź NARROW[ViewerOps.FetchProp[viewer: self, prop: cdProp]]};

        Init: PROC [cd: CharDisplay, initData: REF ANY Ź NIL] = {
            td: TiogaDisplay Ź NEW [TiogaDisplayRep[cd.det.lines]];
            tipTable: TIPUser.TIPTable Ź tiogaDisplayViewerClass.tipTable;
            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\" {9 pt backgroundAscent 3 pt backgroundDescent 0 backgroundBrightness 1 0 1 textColor} 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[baseLooksRope, caret];
                TiogaOps.InsertChar['\n];
                FOR i: NAT IN [0 .. cd.det.columns) DO
                    TiogaOps.InsertChar['0 + (i / 10)];
                    ENDLOOP;
                TiogaOps.InsertChar['\n];
                TiogaOps.SetLooks[baseLooksRope.Concat["z"], caret];
                FOR i: NAT IN [0 .. cd.det.columns) DO
                    TiogaOps.InsertChar['0 + (i MOD 10)];
                    ENDLOOP;
                TiogaOps.SetLooks[baseLooksRope, 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.PutFR1["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]];
            IF cd.tipTableName#NIL THEN {
                first: TIPUser.TIPTable Ź NIL;
                first Ź TIPUser.InstantiateNewTIPTable[cd.tipTableName !FS.Error, TIPUser.InvalidTable => CONTINUE];
                IF first#NIL THEN {
                    <<first.mouseTicks Ź MIN[first.mouseTicks, tipTable.mouseTicks];>>
                    TIPTableAccess.SetMouseTicks[first,
                        MIN[TIPTableAccess.GetMouseTicks[first],
                            TIPTableAccess.GetMouseTicks[tipTable]] ];
                    <<first.opaque Ź FALSE;>>
                    TIPTableAccess.SetOpaque[first, FALSE];
                    [] Ź TIPLinking.Append[early: first, late: tipTable];
                    tipTable Ź first}};
            cd.viewer.tipTable Ź tipTable;
            cd.viewer.menu Ź Menus.CopyMenu[tiogaDisplayViewerClass.menu];
            ViewerOps.AddProp[viewer: cd.viewer, prop: cdProp, val: cd];
            td.root Ź TiogaOps.ViewerDoc[cd.viewer];
            td.logNode Ź TiogaOps.FirstChild[td.root];
            td.arrayNode Ź TiogaOps.LastChild[td.root];
            td.insertLine Ź td.firstInsertCol Ź td.deleteCount Ź 0;
            td.insertLooks Ź baseLooksRope;
            td.insertBuffer Ź RefText.New[cd.det.columns];
            td.caretWrong Ź FALSE;
            [push: td.eatChars, pull: td.spitChars] Ź IOClasses.CreatePipe[];
            cd.fromDisplay Ź td.spitChars;
            td.looks Ź baseLooksRope;
            td.spaces Ź " ";
            FOR i: INT IN [0 .. cd.det.columns) DO
                td.spaces Ź td.spaces.Concat[" "];
                ENDLOOP;
            TiogaOps.CallWithLocks[InitDoc, td.root];
            ReallySetFont[td, "Gacha"];
            {style: NodeStyle.Ref ~ NodeStyleOps.Alloc[];
            NodeStyleOps.ApplyAll[style, td.arrayNode];
            ViewerOps.SetOpenHeight[cd.viewer, Real.Round[(cd.det.lines+3.5)*style.real[leading]] ];
            NodeStyleOps.Free[style]};
            SetLines[cd, td];
            TRUSTED {Process.Detach[FORK ViewerOps.OpenIcon[cd.viewer]]};
            };

        Destruction: INTERNAL PROC [cd: CharDisplay, td: TiogaDisplay] RETURNS [destroyed: BOOL] = {
            IF destroyed Ź cd.viewer.destroyed THEN {
                IF NOT td.destroyed THEN {
                    td.destroyed Ź TRUE;
                    td.eatChars.Close[TRUE !IO.Error => CONTINUE];
                    td.spitChars.Close[TRUE !IO.Error => CONTINUE];
                    };
                };
            };

        InnerFlush: INTERNAL PROC [cd: CharDisplay, td: TiogaDisplay, flushCarat: BOOL] = {
            FlushWithLocks: INTERNAL PROC [root: TextNode.Ref] = {
                IF root # td.root THEN ERROR;
                IF Destruction[cd, td] THEN RETURN;
                IF td.afterLastInsertCol > td.firstInsertCol 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.firstInsertCol, td.lineS[td.insertLine].tiogaCount];
                    end: INT = base+MIN[td.firstInsertCol+td.deleteCount, td.lineS[td.insertLine].tiogaCount];
                    goners: INT = end - start;
                    colDelta: INT = td.firstInsertCol - td.lineS[td.insertLine].tiogaCount;
                    IF end > start THEN TiogaOpers.Delete[root, [start: [td.arrayNode, start], end: [td.arrayNode, end-1 --because it's a char address, 
                    not a point address--]]];
                    IF colDelta > 0 THEN {
                        TiogaOpers.InsertRope[root, td.arrayNode, td.spaces.Substr[0, colDelta], start, FALSE, baseLooks];
                        td.lineS[td.insertLine].tiogaCount Ź td.lineS[td.insertLine].tiogaCount + colDelta;
                        };
                    TiogaOpers.InsertRope[root, td.arrayNode, FromSubText[td.insertBuffer, td.firstInsertCol, td.afterLastInsertCol], 
                    base+td.firstInsertCol, FALSE, TextLooks.RopeToLooks[td.insertLooks]];
                    td.lineS[td.insertLine].tiogaCount Ź td.lineS[td.insertLine].tiogaCount + (td.afterLastInsertCol - td.firstInsertCol) - goners;
                    IF wasEmpty OR td.firstInsertCol = 0 THEN TiogaOps.PutTextKey[node: td.arrayNode, where: base, key: td.lineS[td.insertLine].key];
                    td.afterLastInsertCol Ź td.firstInsertCol Ź 0;
                    td.deleteCount Ź 0;
                    };
                };
            IF td.afterLastInsertCol > td.firstInsertCol THEN TiogaOpers.CallWithLock[FlushWithLocks, td.root];
            IF flushCarat THEN MaybeSetCarat[cd, td];
            };

        MaybeSetCarat: INTERNAL PROC [cd: CharDisplay, td: TiogaDisplay] = {
            CaratWithLocks: INTERNAL PROC [root: TiogaOps.Ref] = {
                wasIn: BOOL = TiogaOps.SelectionRoot[] = td.root;
                IF root # td.root THEN ERROR;
                IF Destruction[cd, td] THEN RETURN;
                IF wasIn AND td.caretWrong THEN SetCarat[cd, td];
                };
            IF td.caretWrong THEN TiogaOps.CallWithLocks[CaratWithLocks, td.root];
            td.caretWrong Ź FALSE;
            };

        SetLines: PROC [cd: CharDisplay, td: TiogaDisplay, recursed: BOOL Ź FALSE] = {
            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;
                    FOR i: INT IN [0 .. lineNum] DO TiogaOpers.InsertRope[td.root, td.arrayNode, "\n", i, FALSE, baseLooks] 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: PROC [cd: CharDisplay] = {
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            EnterAndDeleteChar: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                WithLock: INTERNAL PROC [root: TextNode.Ref] = {
                    base: INT = TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.line].key].where;
                    IF root # td.root THEN ERROR;
                    IF Destruction[cd, td] THEN RETURN;
                    TiogaOpers.Delete[root, [[td.arrayNode, base+cd.col], [td.arrayNode, base+cd.col]]];
                    td.lineS[cd.line].tiogaCount Ź td.lineS[cd.line].tiogaCount - 1;
                    };
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                IF cd.col >= td.lineS[cd.line].tiogaCount AND NOT (td.insertLine = cd.line AND td.afterLastInsertCol > td.firstInsertCol) THEN 
                RETURN;
                InnerFlush[cd, td, FALSE];
                TiogaOpers.CallWithLock[WithLock, td.root];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                };
            EnterAndDeleteChar[td]};

        TakeChar: PROC [cd: CharDisplay, char: CHAR, insert: BOOL Ź FALSE] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndTakeChar: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                IF char = '\n THEN char Ź char + 0200B;
                IF
                    (
                        (td.afterLastInsertCol > td.firstInsertCol) AND
                        (cd.line # td.insertLine OR
                            (NOT td.insertLooks.Equal[td.looks]) OR
                            (NOT (cd.col = td.afterLastInsertCol OR
                                (
                                    (NOT insert) AND
                                    cd.col IN [td.firstInsertCol-1 .. td.afterLastInsertCol])))))
                    THEN {
                        InnerFlush[cd, td, FALSE];
                        IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                        };
                IF td.afterLastInsertCol = td.firstInsertCol THEN {
                    td.insertLine Ź cd.line;
                    td.afterLastInsertCol Ź td.firstInsertCol Ź cd.col;
                    td.insertLooks Ź td.looks};
                IF cd.col = td.afterLastInsertCol THEN {
                    IF NOT insert THEN td.deleteCount Ź td.deleteCount + 1;
                    td.insertBuffer[td.afterLastInsertCol] Ź char;
                    td.afterLastInsertCol Ź td.afterLastInsertCol + 1;
                    }
                ELSE {
                    td.insertBuffer[cd.col] Ź char;
                    IF cd.col < td.firstInsertCol THEN {
                        td.firstInsertCol Ź cd.col;
                        td.deleteCount Ź td.deleteCount + 1;
                        };
                    };
                InternalCursorMove[cd, 0, 1, TRUE];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                };
            EnterAndTakeChar[td]};

        FitCursor: INTERNAL PROC [cd: CharDisplay, td: TiogaDisplay, line, col: INT] = {
            IF line >= cd.det.lines THEN {
                delta: INT = MIN[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 Ź cd.det.lines-1;
                FOR i: INT IN [0 .. delta) DO TiogaOpers.InsertRope[td.root, td.arrayNode, "\n", arrayEnd+i] 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;
                {logEnd: INT = TiogaOps.GetRope[td.logNode].Length[];
                TiogaOpers.Move[td.root, td.root, [td.logNode, logEnd], [[td.arrayNode, topStart], [td.arrayNode, topEnd]], before];
                }};
            cd.line Ź line;
            cd.col Ź col;
            };

        SetCarat: INTERNAL PROC [cd: CharDisplay, td: TiogaDisplay] = {
            colDelta: INT = cd.col - td.lineS[cd.line].tiogaCount;
            IF colDelta > 0 THEN {
                wasEmpty: BOOL = td.lineS[cd.line].tiogaCount = 0;
                TiogaOpers.InsertRope[td.root, td.arrayNode, td.spaces.Substr[0, colDelta], TiogaOps.GetTextKey[node: td.arrayNode, key: 
                td.lineS[cd.line].key].where + td.lineS[cd.line].tiogaCount, FALSE, baseLooks];
                td.lineS[cd.line].tiogaCount Ź td.lineS[cd.line].tiogaCount + colDelta;
                IF wasEmpty THEN SetLines[cd, td];
                };
            TiogaOps.SelectPoint[
                viewer: cd.viewer,
                caret: [td.arrayNode, TiogaOps.GetTextKey[node: td.arrayNode, key: td.lineS[cd.line].key].where + cd.col]
                ];
            };

        CursorMove: PROC [cd: CharDisplay, line, col: INT, relative: BOOL Ź FALSE, doLine, doCol: BOOL Ź TRUE] = {
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            EnterAndCursorMove: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                InternalCursorMove[cd: cd, line: line, col: col, relative: relative, doLine: doLine, doCol: doCol];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                };
            EnterAndCursorMove[td]};

        InternalCursorMove: INTERNAL PROC [cd: CharDisplay, line, col: INT, relative: BOOL Ź FALSE, doLine, doCol: BOOL Ź TRUE] = {
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            FitWithLock: INTERNAL PROC [root: TextNode.Ref] = {
                IF root # td.root THEN ERROR;
                IF Destruction[cd, td] THEN RETURN;
                FitCursor[cd, td, line, col];
                };
            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 {
                    InnerFlush[cd, td, FALSE];
                    TiogaOpers.CallWithLock[FitWithLock, td.root];
                    td.caretWrong Ź TRUE;
                    }
                ELSE {
                    cd.line Ź line;
                    cd.col Ź col;
                    td.caretWrong Ź TRUE;
                    };
            };
        <<>>
        CallWithAllLocks: PROC [proc: PROC [root: TiogaOps.Ref], root: TiogaOps.Ref] = {
            TiogaOps.LockSel[primary];
            {ENABLE UNWIND => TiogaOps.UnlockSel[primary];
            TiogaOps.LockSel[secondary];
            {ENABLE UNWIND => TiogaOps.UnlockSel[secondary];
            TiogaOps.CallWithLocks[proc, root];
            };
            TiogaOps.UnlockSel[secondary];
            };
            TiogaOps.UnlockSel[primary];
            };

        logLineDeletes: BOOL Ź TRUE;

        TLine: PROC [cd: CharDisplay, insert: BOOL] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndTLine: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                endBase, endEnd, base: INT;
                WithLocks: INTERNAL PROC [root: TiogaOps.Ref] = {
                    wasIn: BOOL Ź TiogaOps.SelectionRoot[] = td.root;
                    IF root # td.root THEN ERROR;
                    IF Destruction[cd, td] THEN RETURN;
                    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[];
                    };
                InnerFlush[cd, td, FALSE];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                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];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                SetLines[cd, td];
                };
            EnterAndTLine[td]};

        logClears: BOOL Ź FALSE;

        ClearTo: PROC [cd: CharDisplay, where: Where] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndClearTo: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                col: INT Ź cd.col;
                need: BOOL Ź FALSE;
                WithLocks: INTERNAL PROC [root: TiogaOps.Ref] = {
                    wasIn: BOOL Ź TiogaOps.SelectionRoot[] = td.root;
                    col: INT Ź cd.col;
                    lastLine: INT Ź SELECT where FROM
                        EndOfLine => cd.line,
                        EndOfScreen => cd.det.lines-1,
                        ENDCASE => ERROR;
                    IF root # td.root THEN ERROR;
                    IF Destruction[cd, td] THEN RETURN;
                    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[];
                    };
                InnerFlush[cd, td, FALSE];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                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;
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                };
            EnterAndClearTo[td]};

        ClearAll: PROC [cd: CharDisplay] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndClearAll: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                WithLocks: INTERNAL 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 Destruction[cd, td] THEN RETURN;
                    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[];
                    };
                InnerFlush[cd, td, FALSE];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                TiogaOps.CallWithLocks[WithLocks, td.root];
                td.caretWrong Ź TRUE;
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                SetLines[cd, td];
                };
            EnterAndClearAll[td]};

        SetEmph: PROC [cd: CharDisplay, emph: Emph, on: BOOL] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndSetEmph: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                cd.emphs[emph] Ź on;
                td.looks Ź baseLooksRope;
                IF cd.emphs[underline] THEN td.looks Ź td.looks.Concat["z"];
                IF cd.emphs[bold] THEN td.looks Ź td.looks.Concat["b"];
                IF cd.emphs[italic] THEN td.looks Ź td.looks.Concat["i"];
                IF cd.emphs[inverse] THEN td.looks Ź td.looks.Concat["v"];
                };
            EnterAndSetEmph[td]};

        Emphasize: PROC [cd: CharDisplay, emph: Emph, on: BOOL] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndEmphasize: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                WithLocks: INTERNAL 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: ROPE Ź SELECT emph FROM
                        underline => "z",
                        bold => "b",
                        italic => "i",
                        inverse => "v",
                        ENDCASE => ERROR;
                    IF root # td.root THEN ERROR;
                    IF Destruction[cd, td] THEN RETURN;
                    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[];
                    };
                InnerFlush[cd, td, FALSE];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                IF cd.col > td.lineS[cd.line].tiogaCount THEN RETURN;
                TiogaOps.CallWithLocks[WithLocks, td.root];
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                };
            EnterAndEmphasize[td]};

        SetFont: PROC [cd: CharDisplay, font: ROPE] = {
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            EnterAndSetFont: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                ReallySetFont[td, font];
                };
            EnterAndSetFont[td]};

        ReallySetFont: PROC [td: TiogaDisplay, font: ROPE] = {
            TiogaOps.PutProp[
                n: td.logNode,
                name: $Postfix,
                value: IO.PutFR1["\"%g\" family", IO.rope[font]]
                ];
            TiogaOps.PutProp[
                n: td.arrayNode,
                name: $Postfix,
                value: IO.PutFR1["\"%g\" family", IO.rope[font]]
                ];
            };

        Beep: PROC [cd: CharDisplay] = {
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            EnterAndBeep: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                IF td.destroyed THEN RETURN WITH ERROR DisplayDestroyed[cd];
                IF Beeps.can THEN Beeps.Beep[500,300]
                ELSE {
                    MessageWindow.Append["Beep", TRUE];
                    MessageWindow.Blink[];
                    MessageWindow.Clear[];
                    };
                };
            EnterAndBeep[td]};

        Flush: PROC [cd: CharDisplay] = {
            td: TiogaDisplay Ź NARROW[cd.otherInstanceData];
            EnterAndFlush: ENTRY PROC [td: TiogaDisplay] ~ {
                ENABLE UNWIND => {};
                InnerFlush[cd, td, TRUE];
                };
            EnterAndFlush[td]};

        Destroyed: PROC [cd: CharDisplay] RETURNS [BOOL] = {
            td: TiogaDisplay = NARROW[cd.otherInstanceData];
            EnterAndDestroyed: ENTRY PROC [td: TiogaDisplay] RETURNS [BOOL] ~ {
                ENABLE UNWIND => {};
                RETURN [td.destroyed];
                };
            RETURN EnterAndDestroyed[td]};

        FromSubText: PROC [text: REF TEXT, start, afterLast: INT] RETURNS [rope: ROPE] = {
            text.length Ź afterLast;
            rope Ź Rope.FromRefText[text, start, afterLast-start];
            RETURN};

        InitTiogaDisplayClass[];

        }.