<<>>
    <<KeyboardScan.Mesa>>
        <<Copyright Ó 1992 by Xerox Corporation.  All rights reserved.>>
        <<Last Edited by: Spreitzer, November 27, 1985 5:29:49 pm PST>>
        <<Last tweaked by Mike Spreitzer on January 28, 1988 5:50:16 pm PST>>
        <<Willie-s, March 23, 1992 2:46 pm PST>>

    DIRECTORY MessageWindow, Rope, TEditDocument, TEditInput, TEditInputExtras, TEditInputOps, TEditOps, TEditRefresh, TEditSelection, 
    TextEdit, TextNode, Tioga, TiogaFind, ViewerClasses, ViewerOps;

    KeyboardScan: CEDAR PROGRAM
        IMPORTS MessageWindow, Rope, TEditInput, TEditInputExtras, TEditOps, TEditRefresh, TEditSelection, TextEdit, TextNode, TiogaFind, 
        ViewerOps

        ={

        ROPE: TYPE = Rope.ROPE;
        Viewer: TYPE = ViewerClasses.Viewer;
        Location: TYPE = TextNode.Location;
        Selection: TYPE = TEditDocument.Selection;
        SelectionId: TYPE ~ TEditDocument.SelectionId;

        record: BOOL Ź TRUE;

        ScanNull: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- =
            {RETURN};

        ScanStart: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- = {
            NoteStart: PROC [tdd: TEditDocument.TEditDocumentData, tSel: Selection] = {
                TEditSelection.Copy[source: tSel, dest: startSel];
                RETURN};
            TEditSelection.CallWithSelAndDocAndTddLocks[viewer, primary, NoteStart];
            target Ź NIL;
            failTailLen Ź 0;
            findWhere Ź forwards;
            caseMatters Ź FALSE;
            RETURN};

        ScanUpper: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- =
            {case Ź Upper};

        ScanLower: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- =
            {case Ź Lower};

        ScanForward: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- =
            {findWhere Ź forwards};

        ScanBackward: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- =
            {findWhere Ź backwards};

        ScanReverse: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- =
            {SELECT findWhere FROM
                forwards => {findWhere Ź backwards; MessageWindow.Append["Leaping backwards", TRUE]};
                backwards => {findWhere Ź forwards; MessageWindow.Append["Leaping forwards", TRUE]};
                ENDCASE => ERROR};

        ScanToggleCase: PROC [viewer: Viewer Ź NIL] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] --TEditInput.CommandProc-- = {
            caseMatters Ź NOT caseMatters;
            MessageWindow.Append[IF caseMatters THEN "Case matters" ELSE "Case doesn't matter", TRUE]};

        Case: TYPE = {Upper, Lower};
        case: Case;
        startSel: TEditDocument.Selection ~ TEditSelection.Create[];
        findWhere: TEditSelection.FindWhere;
        caseMatters: BOOL;
        target, lastTarget: ROPE Ź NIL;
        failTailLen: NAT Ź 0;

        ScanTo: PROC [data: REF ANY, viewer: Viewer, param: REF ANY] RETURNS [recordAtom: BOOL, quit: BOOL] 
        --TEditInputExtras.CommandClosureProc-- ~ {
            parmRope: ROPE ~ NARROW[param];
            raw: CHAR ~ IF parmRope.Length = 1 THEN parmRope.Fetch[0] ELSE ERROR;
            goal: CHAR ~ IF raw NOT IN ['A .. 'Z] THEN raw ELSE SELECT case FROM
                Upper => raw,
                Lower => raw - 'A + 'a,
                ENDCASE => ERROR;
            newTarget: ROPE ~ target.Concat[Rope.FromChar[goal]];
            target Ź lastTarget Ź newTarget;
            IF failTailLen>0 THEN {failTailLen Ź failTailLen+1; Bitch[target]}
            ELSE IF NOT FindRope[viewer, newTarget, FALSE, findWhere, FALSE, FALSE, primary, caseMatters] THEN failTailLen Ź 1;
            RETURN [TRUE, TRUE]};

        ScanRepeat: PROC [viewer: Viewer] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] = {
            target Ź lastTarget;
            IF failTailLen>0 THEN Bitch[target]
            ELSE IF NOT FindRope[viewer, target, TRUE, findWhere, FALSE, FALSE, primary, caseMatters] THEN failTailLen Ź 1;
            RETURN};

        ScanShorten: PROC [viewer: Viewer] RETURNS [recordAtom: BOOL Ź record, quit: BOOL Ź TRUE] = {
            oldLen: INT ~ target.Length;
            IF oldLen>0 THEN target Ź lastTarget Ź target.Substr[len: oldLen-1];
            IF oldLen<=1 THEN {
                MessageWindow.Append["Empty search.", TRUE];
                ViewerOps.BlinkDisplay[];
                RETURN};
            IF failTailLen>0 THEN failTailLen Ź failTailLen-1;
            IF failTailLen>0 THEN Bitch[target]
            ELSE IF NOT FindRope[viewer, target, FALSE, findWhere, FALSE, FALSE, primary, caseMatters] THEN failTailLen Ź 1;
            RETURN};

        FindRope: PUBLIC PROC [viewer: Viewer, rope: ROPE, moveOn: BOOL, findWhere: TEditSelection.FindWhere Ź anywhere, def, word: BOOL Ź 
        FALSE, id: SelectionId Ź primary, case: BOOL Ź TRUE -- case => case of characters is significant --] RETURNS [found: BOOL] 
        = {
            IF (found Ź DoFind[viewer, rope, moveOn, findWhere, def, word, id, case]) THEN MessageWindow.Clear[] ELSE Bitch[rope];
            RETURN};

        Bitch: PROC [target: ROPE] ~ {
            IF Rope.Size[target]>50 THEN target Ź Rope.Concat[Rope.Substr[target, 0, 47], "..."];
            MessageWindow.Append[Rope.Concat[target, " not found."], TRUE];
            ViewerOps.BlinkDisplay[];
            RETURN};

        NormalizeLoc: PROC [loc: Location, dw: INT] RETURNS [Location] ~ {
            IF loc.where=TextNode.NodeItself THEN loc.where Ź 0;
            loc.where Ź MIN[loc.node.rope.Length, MAX[INT[0], loc.where + dw]];
            RETURN [loc]};

        DoFind: PUBLIC PROC [viewer: Viewer, rope: ROPE, moveOn: BOOL, findWhere: TEditSelection.FindWhere Ź anywhere, def, word: BOOL Ź 
        FALSE, id: SelectionId Ź primary, case: BOOL Ź TRUE -- case => case of characters is significant --] RETURNS [found: BOOL] 
        = {
            where: TextNode.RefTextNode Ź NIL;
            first, last: Location;
            at, atEnd: TextNode.Offset Ź 0;
            mv: INT ~ IF moveOn THEN 1 ELSE 0;
            targLen: INT ~ rope.Length;
            inViewer: BOOL Ź FALSE;
            targetNode: Tioga.Node;
            DoFindIt: PROC [tdd: TEditDocument.TEditDocumentData, tSel: Selection] = {
                interrupt: REF BOOL ~ TEditInput.interrupt;
                FirstLoc: PROC [root: Tioga.Node] RETURNS [Location] ~ {
                    RETURN[[TextNode.FirstChild[root], 0]]
                    };
                LastLoc: PROC [root: Tioga.Node] RETURNS [Location] ~ {
                    RETURN[TextNode.LastLocWithin[root]]
                    };
                Forward: PROC = {
                    first Ź NormalizeLoc[tSel.start.pos, mv];
                    [where, at, atEnd] Ź TiogaFind.LiteralSearch[direction: forward, target: targetNode, case: FALSE, loc1: first, loc2: 
                    LastLoc[tdd.text], interrupt: interrupt];
                    };
                Backward: PROC = {
                    first Ź NormalizeLoc[tSel.start.pos, targLen-mv];
                    [where, at, atEnd] Ź TiogaFind.LiteralSearch[direction: backward, target: targetNode, case: FALSE, loc1: FirstLoc[tdd.text], loc2: 
                    first, interrupt: interrupt] 
                    };
                FromStart: PROC = {
                    last Ź NormalizeLoc[tSel.start.pos, targLen+mv];
                    [where, at, atEnd] Ź TiogaFind.LiteralSearch[direction: forward, target: targetNode, case: FALSE, loc1: FirstLoc[tdd.text], loc2: 
                    LastLoc[tdd.text], interrupt: interrupt] 
                    };
                FromEnd: PROC = {
                    first Ź [TextNode.LastWithin[tdd.text], 0];
                    first.where Ź first.node.rope.Length;
                    last Ź NormalizeLoc[tSel.start.pos, -mv];
                    [where, at, atEnd] Ź TiogaFind.LiteralSearch[direction: backward, target: targetNode, case: FALSE, loc1: FirstLoc[tdd.text], loc2: 
                    LastLoc[tdd.text], interrupt: interrupt] 
                    };
                interrupt­ Ź FALSE;
                IF NOT (inViewer Ź tSel.viewer=viewer) THEN RETURN;
                SELECT findWhere FROM
                    backwards => { Backward[]; IF where = NIL THEN FromEnd[] };
                    forwards => { Forward[]; IF where = NIL THEN FromStart[] };
                    ENDCASE => ERROR;
                IF where#NIL THEN {
                    IF def THEN atEnd Ź atEnd-1; -- skip the trailing :
                    tSel.start.pos Ź [where,at];
                    tSel.end.pos Ź [where,MAX[0,atEnd-1]];
                    tSel.granularity Ź IF word THEN word ELSE char;
                    tSel.insertion Ź before;
                    tSel.pendingDelete Ź FALSE;
                    tSel.viewer Ź viewer;
                    tSel.data Ź tdd;
                    }
                ELSE {
                    TEditSelection.Copy[source: startSel, dest: tSel];
                    };
                TEditOps.RememberCurrentPosition[viewer];
                TEditSelection.SetSelLooks[tSel];
                TEditSelection.MakeSelection[new: tSel, selection: id];
                IF closeOnLeap THEN TEditInput.CloseEvent[];
                TEditRefresh.ScrollToEndOfSel[viewer, FALSE, id];
                };
            found Ź FALSE;
            IF Rope.Size[rope] = 0 THEN RETURN;
            IF def THEN rope Ź Rope.Concat[rope,":"];
            targetNode Ź TextEdit.FromRope[rope];
            TEditSelection.CallWithSelAndDocAndTddLocks[viewer, id, DoFindIt];
            found Ź where#NIL;
            IF NOT inViewer THEN {
                MessageWindow.Append["This can't happen!", TRUE];
                MessageWindow.Blink[];
                };
            };

        closeOnLeap: BOOL Ź FALSE;

        Start: PROC = {
            TEditInput.Register[$ScanNull, ScanNull];
            TEditInput.Register[$ScanStart, ScanStart];
            TEditInput.Register[$ScanRepeat, ScanRepeat];
            TEditInput.Register[$ScanShorten, ScanShorten];
            TEditInput.Register[$ScanUpper, ScanUpper];
            TEditInput.Register[$ScanLower, ScanLower];
            TEditInput.Register[$ScanForward, ScanForward];
            TEditInput.Register[$ScanBackward, ScanBackward];
            TEditInput.Register[$ScanReverse, ScanReverse];
            TEditInput.Register[$ScanToggleCase, ScanToggleCase];
            TEditInputExtras.RegisterClosure[[$ScanTo, ScanTo, NIL]];
            };

        Start[];

        }.