<<>>
    <<EditToolSearchImpl.mesa>>
        <<Copyright Ó 1985, 1986, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Michael Plass, March 28, 1985 9:01:55 am PST>>
        <<Doug Wyatt, March 16, 1992 3:34 pm PST>>
        <<Russ Atkinson (RRA) January 23, 1986 0:57:33 am PST>>
        <<Alison Lee September 8, 1986 10:03:40 pm PDT>>
        <<>>
    DIRECTORY
        Atom USING [GetProp],
        Buttons USING [Button, ButtonProc, SetDisplayStyle, ReLabel],
        EditToolBuilder USING [BuildButton, BuildDataFieldPair, BuildLabel, BuildPair, BuildTriple, DataFieldButton, GetDataNode, HGap, 
        ToMiddle, ToNext],
        EditToolPrivate USING [ChangeState, CycleTriple, DoButton, FixPSel, Info, Pattern, PatternRep, mainToolInfo, editTool, Register, 
        SavePSel, SearchDir, SearchWhere],
        IO USING [PutFR, rope, int],
        Labels USING [Set],
        Menus USING [Menu, MenuProc, MenuEntry, FindEntry, CopyEntry, SetClientData],
        MessageWindow USING [Append, Clear],
        NodeProps USING [DoSpecs],
        NodeStyleOps USING [StyleNameForNode],
        Rope USING [Concat, ROPE],
        TEditDocument USING [Selection],
        TEditInput USING [CloseEvent, CommandProc],
        TEditInputOps USING [CallWithLocks],
        TEditOps USING [GetSelData, RememberCurrentPosition, SetTextContents],
        TEditProfile USING [selectionCaret],
        TEditRefresh USING [ScrollToEndOfSel],
        TEditSelection USING [LockSel, UnlockSel, MakeSelection, SetSelLooks],
        TextEdit,
        TextFind,
        TextNode USING [Root, FirstChild],
        Tioga USING [Node, Location, Looks, noLooks],
        TiogaFind USING [TargetFromNode, Search, Match],
        ViewerClasses USING [Viewer],
        ViewerOps USING [AddProp, BlinkDisplay, CreateViewer],
        ViewerSpecs USING [openRightWidth],
        ViewerTools USING [InhibitUserEdits];

    EditToolSearchImpl: CEDAR PROGRAM
        IMPORTS Atom, Buttons, EditToolBuilder, EditToolPrivate, IO, Labels, MessageWindow, Menus, NodeProps, NodeStyleOps, Rope, TEditOps, 
        TextEdit, TextFind, TextNode, TEditInput, TEditInputOps, TEditProfile, TEditRefresh, TEditSelection, TiogaFind, ViewerOps, 
        ViewerSpecs, ViewerTools 
        EXPORTS EditToolPrivate
        = BEGIN OPEN EditToolPrivate, EditToolBuilder;

    ROPE: TYPE ~ Rope.ROPE;
    Node: TYPE ~ Tioga.Node;
    Location: TYPE ~ Tioga.Location;

    Report: PROC [msg: Rope.ROPE, blink: BOOL _ TRUE] ~ {
        IF msg=NIL THEN MessageWindow.Clear[]
        ELSE {
            MessageWindow.Append[msg, TRUE];
            IF blink THEN ViewerOps.BlinkDisplay[];
            };
        };


    searchForwardAtom: LIST OF REF = Register[$SearchForward,SearchForwardOp];
    SearchForwardOp: TEditInput.CommandProc = { Search[forwards,mainToolInfo] };

    searchAnywhereAtom: LIST OF REF = Register[$SearchAnywhere,SearchAnywhereOp];
    SearchAnywhereOp: TEditInput.CommandProc = { Search[anywhere,mainToolInfo] };

    searchBackwardsAtom: LIST OF REF = Register[$SearchBackwards,SearchBackwardsOp];
    SearchBackwardsOp: TEditInput.CommandProc = { Search[backwards,mainToolInfo] };

    DoSearchMenuButton: PUBLIC Menus.MenuProc = {
        SELECT mouseButton FROM
            red => DoButton[searchForwardAtom];
            yellow => DoButton[searchAnywhereAtom];
            blue => DoButton[searchBackwardsAtom];
            ENDCASE => ERROR;
        };

    CheckPSel: PUBLIC PROC [pSel: TEditDocument.Selection, typescriptOK: BOOL Ź TRUE] RETURNS [ok: BOOL] = {
        IF pSel#NIL AND pSel.viewer#NIL AND
            (pSel.viewer.class.flavor=$Text OR
                (typescriptOK AND pSel.viewer.class.flavor=$Typescript))
            THEN RETURN [TRUE];
        Report["Please make a text selection."];
        RETURN [FALSE];
        };

    Search: PUBLIC PROC [whichDir: SearchDir, info: Info] = {
        found: BOOL ~ TrySearch[whichDir, info];
        Report[IF found THEN NIL ELSE "Not found.", TRUE];
        };

    TrySearch: PUBLIC PROC [whichDir: SearchDir, info: Info] RETURNS [found: BOOL Ź FALSE] = {
        IF info.ignoreText AND info.ignoreLooks AND info.ignoreFormat AND 
        info.ignoreStyle AND info.ignoreComment THEN {
            Report["Pick one or more of text/looks/format/style/comment to match."];
            RETURN;
            };
        TEditSelection.LockSel[primary, "TrySearch"];
        {
            ENABLE UNWIND => TEditSelection.UnlockSel[primary];
            pSel: TEditDocument.Selection Ź NIL;
            pattern: Pattern Ź NIL;
            FixPSel[];
            pSel Ź TEditOps.GetSelData[];
            IF ~CheckPSel[pSel] OR (pattern Ź GetPattern[info])=NIL THEN GOTO Quit;

            [found, info.subs] Ź DoSearch[whichDir: whichDir, 
            pattern: pattern, interrupt: info.interrupt];
            <<>>
            IF found THEN {
                <<Attempt to register in EditTool Cafeteria tray if the registry operation is available.  This is deferred to this late because, 
                only properly specified commands will be recorded. >>
                cmdPtr: REF ANY Ź Atom.GetProp[$CafeteriaTrayRegistryAtom, $EditToolAddToTray];
                IF cmdPtr # NIL
                    THEN {
                        EditToolAddInterfaceProc: TYPE = PROC [operation: ATOM, opList: Rope.ROPE Ź NIL]; -- same as 
                        EditToolCafeteria.EditToolAddInterfaceProc
                        addProcPtr: REF EditToolAddInterfaceProc Ź NARROW[cmdPtr, REF EditToolAddInterfaceProc];
                        addProcPtr[$DoSearch];
                        };
                };
            EXITS Quit => {};
            };
        TEditSelection.UnlockSel[primary];
        };

    matchFromWhere: ARRAY SearchWhere OF TiogaFind.Match 
    ~ [anywhere: any, words: word, nodes: all];

    GetPattern: PUBLIC PROC [info: EditToolPrivate.Info] RETURNS [Pattern] ~ {
        node: Node ~ GetDataNode[info.targetArg];
        nodeSize: INT ~ TextEdit.Size[node];
        checkText: BOOL ~ NOT info.ignoreText;
        checkLooks: BOOL ~ NOT info.ignoreLooks;
        checkComment: BOOL ~ NOT info.ignoreComment;
        checkFormat: BOOL ~ NOT info.ignoreFormat;
        checkStyle: BOOL ~ NOT info.ignoreStyle;
        target: TextFind.Target Ź NIL;
        comment: BOOL Ź FALSE;
        format: ATOM Ź NIL;
        style: ATOM Ź NIL;
        IF nodeSize=0 AND (checkText OR checkLooks) THEN {
            Report["Please enter a search pattern in the \"Target:\" field."];
            RETURN[NIL];
            };
        IF checkText THEN {
            error: ROPE Ź NIL;
            target Ź TiogaFind.TargetFromNode[node: node, pattern: NOT info.literal ! TextFind.Error => {
                error Ź IO.PutFR["Error: %g, at position %g.", IO.rope[reason], IO.int[index]]; CONTINUE }];
            IF error#NIL THEN { Report[error]; RETURN[NIL] };
            }
        ELSE IF checkLooks THEN {
            patternNode: Node ~ TextEdit.FromRope["**#**"];
            patternLooks: Tioga.Looks Ź Tioga.noLooks;
            FOR i: INT IN [0..nodeSize) DO
                looks: Tioga.Looks ~ TextEdit.FetchLooks[node, i];
                IF i=0 THEN patternLooks Ź looks
                ELSE IF looks#patternLooks THEN {
                    Report["Search pattern has nonuniform looks; using looks from first char."];
                    EXIT;
                    };
                ENDLOOP;
            TextEdit.ChangeLooks[root: NIL, text: patternNode, add: patternLooks];
            target Ź TiogaFind.TargetFromNode[node: patternNode, pattern: TRUE];
            };
        IF node#NIL THEN {
            IF checkComment THEN comment Ź TextEdit.GetComment[node];
            IF checkFormat THEN format Ź TextEdit.GetFormat[node];
            IF checkStyle THEN style Ź NodeStyleOps.StyleNameForNode[node];
            };
        RETURN[NEW[PatternRep Ź [target: target, 
        case: NOT info.ignoreCase, match: matchFromWhere[info.searchWhere], 
        checkLooks: checkLooks, looksExact: info.looksExact, 
        checkComment: checkComment, comment: comment, 
        checkFormat: checkFormat, format: format, 
        checkStyle: checkStyle, style: style]]];
        };

    DoSearch: PROC [whichDir: SearchDir, pattern: Pattern, interrupt: REF BOOL] 
    RETURNS [found: BOOL Ź FALSE, subs: TextFind.Subs Ź NIL] ~ {
        DoSearchLocked: PROC [root: Node, tSel: TEditDocument.Selection] = {
            where: Node Ź NIL;
            at, atEnd: INT Ź 0;
            Try: PROC [dir: TextFind.Direction, loc1, loc2: Location] ~ {
                pat: Pattern ~ pattern;
                [node: where, matchStart: at, matchEnd: atEnd, subs: subs] Ź TiogaFind.Search[
                direction: dir, loc1: loc1, loc2: loc2, 
                target: pat.target, case: pat.case, match: pat.match, 
                checkLooks: pat.checkLooks, looksExact: pat.looksExact, 
                checkComment: pat.checkComment, comment: pat.comment, 
                checkFormat: pat.checkFormat, format: pat.format,
                checkStyle: pat.checkStyle, style: pat.style, 
                styleProc: NodeStyleOps.StyleNameForNode, 
                interrupt: interrupt];
                };
            first: Location ~ [TextNode.FirstChild[root], 0];
            loc1: Location Ź tSel.start.pos;
            loc2: Location Ź tSel.end.pos;
            loc1.where Ź MIN[MAX[0, loc1.where], TextEdit.Size[loc1.node]];
            loc2.where Ź MIN[MAX[0, loc2.where+1], TextEdit.Size[loc2.node]];
            IF interrupt#NIL THEN interrupt­ Ź FALSE;
            IF whichDir=backwards
                THEN Try[backward, first, loc1]
                ELSE Try[forward, loc2, [NIL, 0]];
            IF where=NIL AND whichDir=anywhere AND NOT(interrupt#NIL AND interrupt­)
                THEN Try[forward, first, [NIL, 0]];
            IF where=NIL THEN RETURN ELSE found Ź TRUE;
            tSel.start.pos Ź [where, at];
            tSel.end.pos Ź [where, MAX[0,atEnd-1]];
            tSel.granularity Ź IF pattern.target=NIL OR pattern.match=all THEN node 
            ELSE IF pattern.match=word THEN word ELSE char;
            tSel.insertion Ź IF TEditProfile.selectionCaret=before THEN before ELSE after;
            TEditOps.RememberCurrentPosition[tSel.viewer];
            TEditSelection.SetSelLooks[tSel];
            TEditSelection.MakeSelection[new: tSel];
            TEditInput.CloseEvent[];
            TEditRefresh.ScrollToEndOfSel[tSel.viewer, FALSE];
            };
        TEditInputOps.CallWithLocks[DoSearchLocked, read] 
        };
        <<>>
    SetUpRealText: PROC [info: EditToolPrivate.Info] = {
        BuildRealSearchChoiceEntries[info]; ToNext[info.layout];
        ignoringCase Ź "IgnoreCase";
        matchingCase Ź "MatchCase";
        matchingWords Ź "MatchWords";
        matchingAnywhere Ź "MatchAnywhere";
        matchingNodes Ź "MatchNodes";
        matchingLiterally Ź "MatchLiterally";
        matchingAsPattern Ź "MatchPattern";
        equalLooks Ź "EqualLooksTest";
        subsetLooks Ź "SubsetLooksTest";
        };

    SetUpText: PROC [info: EditToolPrivate.Info] = {
        BuildSearchChoiceEntries[info]; ToNext[info.layout];
        ignoringCase Ź "Ignore Case";
        matchingCase Ź "Match Case";
        matchingWords Ź "Match Words Only";
        matchingAnywhere Ź "Match Anywhere";
        matchingNodes Ź "Match Entire Nodes Only";
        matchingLiterally Ź "Match Literally";
        matchingAsPattern Ź "Match as Pattern";
        equalLooks Ź "Equal as Looks Test";
        subsetLooks Ź "Subset as Looks Test";
        };

    BuildSearchButtons: PUBLIC PROC [info: EditToolPrivate.Info, realNames: BOOL Ź FALSE] = {
        IF realNames THEN SetUpRealText[info] ELSE SetUpText[info];
        BuildCaseEntry[info]; ToMiddle[info.layout];
        BuildWhereEntry[info]; ToNext[info.layout];
        BuildLitOrPatternEntry[info]; ToMiddle[info.layout];
        BuildLooksMatchEntry[info];
        };

    equalLooks: Rope.ROPE;
    subsetLooks: Rope.ROPE;

    equalLooksAtom: LIST OF REF = Register[$EqualLooksTest,EqualLooksTestOp];
    subsetLooksAtom: LIST OF REF = Register[$SubsetLooksTest,SubsetLooksTestOp];

    LooksMatchButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.looksExact, equalLooksAtom,subsetLooksAtom];
        };

    EqualLooksTestOp: TEditInput.CommandProc = {
        EqualLooksTest[mainToolInfo];
        };

    EqualLooksTest: PROC [info: Info] = {
        OPEN info;
        looksExact Ź TRUE;
        Labels.Set[looksMatchLabel,equalLooks];
        };

    SubsetLooksTestOp: TEditInput.CommandProc = {
        SubsetLooksTest[mainToolInfo];
        };

    SubsetLooksTest: PROC [info: Info] = {
        OPEN info;
        looksExact Ź FALSE;
        Labels.Set[looksMatchLabel,subsetLooks];
        };

    BuildRealLooksMatchEntry: PROC [info: Info] = {
        OPEN info;
        looksExact Ź FALSE;
        [looksMatchLabel,] Ź BuildPair[layout,LooksMatchButton,looksExact,"EqualLooksTest","SubsetLooksTest",info];
        };

    BuildLooksMatchEntry: PROC [info: Info] = {
        OPEN info;
        looksExact Ź FALSE;
        [looksMatchLabel,] Ź BuildPair[layout,LooksMatchButton,looksExact,equalLooks,subsetLooks,info];
        };

    <<-------------------------->>

    BuildEntry: PROC [name: Rope.ROPE, info:Info, proc: Buttons.ButtonProc, state: BOOL] RETURNS [new: Buttons.Button] = {
        new Ź BuildButton[info.layout, name, proc, info, FALSE, FALSE];
        ViewerOps.AddProp[new, $DisableMBFeedback, $DisableMBFeedback];
        SetButton[new, state, FALSE];
        };

    BuildRealSearchChoiceEntries: PROC [info: Info] = {
        [] Ź BuildLabel[info.layout, "Pick one or more: "];
        HGap[info.layout];
        info.textButton Ź BuildEntry["MatchText", info, MatchTextButton, info.ignoreText Ź FALSE];
        info.looksButton Ź BuildEntry["IgnoreLooks", info, MatchLooksButton, info.ignoreLooks Ź TRUE];
        info.formatButton Ź BuildEntry["IgnoreFormat", info, MatchFormatButton, info.ignoreFormat Ź TRUE];
        EditToolBuilder.ToNext[info.layout];
        EditToolBuilder.ToMiddle[info.layout];
        info.styleButton Ź BuildEntry["IgnoreStyle", info, MatchStyleButton, info.ignoreStyle Ź TRUE];
        info.commentButton Ź BuildEntry["IgnoreComment", info, MatchCommentButton, info.ignoreComment Ź TRUE];
        };

    BuildSearchChoiceEntries: PROC [info: Info] = {
        [] Ź BuildLabel[info.layout, "Pick one or more: "];
        HGap[info.layout];
        info.textButton Ź BuildEntry["Text", info, MatchTextButton, info.ignoreText Ź FALSE];
        info.looksButton Ź BuildEntry["Looks", info, MatchLooksButton, info.ignoreLooks Ź TRUE];
        info.formatButton Ź BuildEntry["Format", info, MatchFormatButton, info.ignoreFormat Ź TRUE];
        info.styleButton Ź BuildEntry["Style", info, MatchStyleButton, info.ignoreStyle Ź TRUE];
        info.commentButton Ź BuildEntry["Comment", info, MatchCommentButton, info.ignoreComment Ź TRUE];
        };

    SetButton: PROC [viewer: Buttons.Button, ignore: BOOL, paint: BOOL Ź TRUE] = {
        Buttons.SetDisplayStyle[viewer,
            IF ignore THEN $BlackOnWhite ELSE $WhiteOnBlack, paint];
        }; 

    <<-------------------------->>
    matchTextAtom: LIST OF REF = Register[$MatchText,MatchTextOp];
    ignoreTextAtom: LIST OF REF = Register[$IgnoreText,IgnoreTextOp];

    MatchTextButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.ignoreText, ignoreTextAtom, matchTextAtom];
        };

    MatchTextOp: TEditInput.CommandProc = { MatchText[mainToolInfo] };

    MatchText: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.textButton, "MatchText", FALSE ];
        SetButton[info.textButton, info.ignoreText Ź FALSE];
        };

    IgnoreTextOp: TEditInput.CommandProc = { IgnoreText[mainToolInfo] };

    IgnoreText: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.textButton, "IgnoreText", FALSE ];
        SetButton[info.textButton, info.ignoreText Ź TRUE];
        };

    <<-------------------------->>
    matchLooksAtom: LIST OF REF = Register[$MatchLooks,MatchLooksOp];
    ignoreLooksAtom: LIST OF REF = Register[$IgnoreLooks,IgnoreLooksOp];

    MatchLooksButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.ignoreLooks, ignoreLooksAtom, matchLooksAtom];
        };

    MatchLooksOp: TEditInput.CommandProc = {
        MatchLooks[mainToolInfo];
        };

    MatchLooks: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.looksButton, "MatchLooks", FALSE ];
        SetButton[info.looksButton, info.ignoreLooks Ź FALSE];
        };

    IgnoreLooksOp: TEditInput.CommandProc = {
        IgnoreLooks[mainToolInfo];
        };


    IgnoreLooks: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.looksButton, "IgnoreLooks", FALSE ];
        SetButton[info.looksButton, info.ignoreLooks Ź TRUE];
        };

    <<-------------------------->>
    matchFormatAtom: LIST OF REF = Register[$MatchFormat,MatchFormatOp];
    ignoreFormatAtom: LIST OF REF = Register[$IgnoreFormat,IgnoreFormatOp];

    MatchFormatButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.ignoreFormat, ignoreFormatAtom,matchFormatAtom]
        };

    MatchFormatOp: TEditInput.CommandProc = {
        MatchFormat[mainToolInfo];
        };

    MatchFormat: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.formatButton, "MatchFormat", FALSE ];
        SetButton[info.formatButton, info.ignoreFormat Ź FALSE];
        };

    IgnoreFormatOp: TEditInput.CommandProc = {
        IgnoreFormat[mainToolInfo];
        };

    IgnoreFormat: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.formatButton, "IgnoreFormat", FALSE ];
        SetButton[info.formatButton, info.ignoreFormat Ź TRUE];
        };

    matchStyleAtom: LIST OF REF = Register[$MatchStyle,MatchStyleOp];
    ignoreStyleAtom: LIST OF REF = Register[$IgnoreStyle,IgnoreStyleOp];

    MatchStyleButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.ignoreStyle, ignoreStyleAtom,matchStyleAtom]
        };

    MatchStyleOp: TEditInput.CommandProc = {
        MatchStyle[mainToolInfo] };

    MatchStyle: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.styleButton, "MatchStyle", FALSE ];
        SetButton[info.styleButton, info.ignoreStyle Ź FALSE] };

    IgnoreStyleOp: TEditInput.CommandProc = {
        IgnoreStyle[mainToolInfo] };

    IgnoreStyle: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ mainToolInfo.styleButton, "IgnoreStyle", FALSE ];
        SetButton[info.styleButton, info.ignoreStyle Ź TRUE] };

    matchCommentAtom: LIST OF REF = Register[$MatchComment,MatchCommentOp];
    ignoreCommentAtom: LIST OF REF = Register[$IgnoreComment,IgnoreCommentOp];

    MatchCommentButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.ignoreComment, ignoreCommentAtom,matchCommentAtom]
        };

    MatchCommentOp: TEditInput.CommandProc = {
        MatchComment[mainToolInfo] };

    MatchComment: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.commentButton, "MatchComment", FALSE ];
        SetButton[info.commentButton, info.ignoreComment Ź FALSE] };

    IgnoreCommentOp: TEditInput.CommandProc = {
        IgnoreComment[mainToolInfo] };

    IgnoreComment: PROC [info: Info] = {
        viewer: ViewerClasses.Viewer Ź editTool;
        menu: Menus.Menu Ź viewer.menu;
        menuEntry:Menus.MenuEntry Ź Menus.CopyEntry[ Menus.FindEntry[ menu, "RealOps"] ];
        menuClientData: REF ANYŹ Menus.SetClientData[ menuEntry, NIL ];  -- only way to query the clientData without affecting it.
        data: REF BOOL Ź NARROW[menuClientData];
        usingRealNames: BOOL Ź data­;
        <<If using real names, must change the text in the button also, if not using real names then leave the text of the button the same.>>
        IF usingRealNames THEN Buttons.ReLabel[ info.commentButton, "IgnoreComment", FALSE ];
        SetButton[info.commentButton, info.ignoreComment Ź TRUE] };

    matchingLiterally: Rope.ROPE;
    matchingAsPattern: Rope.ROPE;

    matchLitAtom: LIST OF REF = Register[$MatchLiterally,MatchLitOp];
    matchPatternAtom: LIST OF REF = Register[$MatchPattern,MatchPatternOp];

    LiteralButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.literal, matchLitAtom,matchPatternAtom];
        };

    MatchLitOp: TEditInput.CommandProc = {
        MatchLit[mainToolInfo];
        };

    MatchLit: PROC [info: Info] = {
        OPEN info;
        literal Ź TRUE;
        Labels.Set[literalLabel,matchingLiterally];
        };

    MatchPatternOp: TEditInput.CommandProc = {
        MatchPattern[mainToolInfo];
        };

    MatchPattern: PROC [info: Info] = {
        OPEN info;
        literal Ź FALSE;
        Labels.Set[literalLabel,matchingAsPattern];
        };

    BuildLitOrPatternEntry: PROC [info: Info] = {
        OPEN info;
        literal Ź TRUE;
        [literalLabel,] Ź BuildPair[layout,LiteralButton,literal,matchingLiterally,matchingAsPattern,info];
        };

    numDocRopes: NAT = 18;
    docRopes: REF ARRAY [0..numDocRopes) OF Rope.ROPE Ź 
        NEW[ARRAY [0..numDocRopes) OF Rope.ROPE];

    BuildPatternDocEntry: PUBLIC PROC [info: Info] = {
        OPEN info.layout;
        lines: CARDINAL = 25;
        rope: Rope.ROPE;
        arg: ViewerClasses.Viewer Ź ViewerOps.CreateViewer[flavor: $Text, info: [parent: container,
            border: FALSE, scrollable: TRUE,
            wx: entryLeft, wy: heightSoFar,
            ww: ViewerSpecs.openRightWidth-entryLeft-5,
            wh: entryHeight*lines], paint: FALSE];
        heightSoFar Ź heightSoFar + entryHeight*lines;
        FOR i:NAT IN [0..numDocRopes) DO
            rope Ź Rope.Concat[rope, docRopes[i]];
            ENDLOOP;
        TEditOps.SetTextContents[arg, rope];
        };

    numMiniDocRopes: NAT = 4;
    miniDocRopes: REF ARRAY [0..numMiniDocRopes) OF Rope.ROPE Ź 
        NEW[ARRAY [0..numMiniDocRopes) OF Rope.ROPE];

    miniDocStyle: Rope.ROPE ~ "
    BeginStyle 
    (mini) \"for small comment\" {
        \"TimesRoman\" family
        8 pt size
        9 pt leading
        10 pt topIndent
        0 pt bottomIndent
        0 leftIndent
        5 pt rightIndent
        } StyleRule 
    EndStyle
    ";

    BuildMiniPatternDocEntry: PUBLIC PROC [info: Info] = {
        OPEN info.layout;
        rope: Rope.ROPE;
        where: Node;
        height: CARDINAL = numMiniDocRopes*10+3;
        arg: ViewerClasses.Viewer Ź ViewerOps.CreateViewer[flavor: $Text, info: [parent: container,
            wx: entryLeft, wy: heightSoFar,
            ww: ViewerSpecs.openRightWidth-entryLeft-5,
            wh: height, border: FALSE, scrollable: FALSE], paint: FALSE];
        heightSoFar Ź heightSoFar + height;
        FOR i:NAT IN [0..numMiniDocRopes) DO
            rope Ź Rope.Concat[rope, miniDocRopes[i]];
            ENDLOOP;
        TEditOps.SetTextContents[arg, rope];
        where Ź GetDataNode[arg];
        TextEdit.PutProp[node: TextNode.Root[where], name: $StyleDef, 
        value: NodeProps.DoSpecs[$StyleDef, miniDocStyle]];
        TextEdit.PutFormat[where, $mini];
        ViewerTools.InhibitUserEdits[arg];
        };

    <<-------------------------->>
    ignoringCase: Rope.ROPE;
    matchingCase: Rope.ROPE;

    ignoreCaseAtom: LIST OF REF = Register[$IgnoreCase,IgnoreCaseOp];
    matchCaseAtom: LIST OF REF = Register[$MatchCase,MatchCaseOp];

    CaseButton: Buttons.ButtonProc = {
        ChangeState[mainToolInfo.ignoreCase, ignoreCaseAtom,matchCaseAtom];
        };

    IgnoreCaseOp: TEditInput.CommandProc = {
        IgnoreCase[mainToolInfo];
        };

    IgnoreCase: PROC [info: Info] = {
        OPEN info;
        ignoreCase Ź TRUE;
        Labels.Set[caseLabel,ignoringCase];
        };

    MatchCaseOp: TEditInput.CommandProc = {
        MatchCase[mainToolInfo];
        };

    MatchCase: PROC [info: Info] = {
        OPEN info;
        ignoreCase Ź FALSE;
        Labels.Set[caseLabel,matchingCase];
        };

    BuildCaseEntry: PROC [info: Info] = {
        OPEN info;
        ignoreCase Ź FALSE;
        [caseLabel,] Ź BuildPair[layout,CaseButton,ignoreCase,ignoringCase,matchingCase,info];
        };

    matchingWords: Rope.ROPE;
    matchingAnywhere: Rope.ROPE;
    matchingNodes: Rope.ROPE;

    matchWordsAtom: LIST OF REF = Register[$MatchWords,MatchWordsOp];
    matchAnywhereAtom: LIST OF REF = Register[$MatchAnywhere,MatchAnywhereOp];
    matchNodesAtom: LIST OF REF = Register[$MatchNodes,MatchNodesOp];

    WhereButton: Buttons.ButtonProc = {
        CycleTriple[ORD[mainToolInfo.searchWhere],
            matchAnywhereAtom,matchWordsAtom,matchNodesAtom] };

    MatchWordsOp: TEditInput.CommandProc = { MatchWords[mainToolInfo] };

    MatchWords: PROC [info: Info] = {
        OPEN info;
        searchWhere Ź words;
        Labels.Set[wordLabel,matchingWords];
        };

    MatchNodesOp: TEditInput.CommandProc = { MatchNodes[mainToolInfo] };

    MatchNodes: PROC [info: Info] = {
        OPEN info;
        searchWhere Ź nodes;
        Labels.Set[wordLabel,matchingNodes];
        };

    MatchAnywhereOp: TEditInput.CommandProc = {
        MatchAnywhere[mainToolInfo];
        };

    MatchAnywhere: PROC [info: Info] = {
        OPEN info;
        searchWhere Ź anywhere;
        Labels.Set[wordLabel,matchingAnywhere];
        };

    BuildWhereEntry: PROC [info: Info] = {
        OPEN info;
        searchWhere Ź anywhere;
        [wordLabel,] Ź BuildTriple[layout, WhereButton, ORD[searchWhere], matchingAnywhere, matchingWords, matchingNodes, info];
        };

    <<-------------------------->>
    targetArgAtom: LIST OF REF = Register[$SearchFor,TargetArgOp];
    clearTargetArgAtom: LIST OF REF = Register[$ClearSearchFor,ClearTargetArgOp];

    TargetButton: Buttons.ButtonProc = {
        DoButton[targetArgAtom, clearTargetArgAtom, mouseButton=red];
        };

    TargetArgOp: TEditInput.CommandProc = {
        TargetArg[mainToolInfo];
        };

    TargetArg: PROC [info: Info] = {
        SavePSel; DataFieldButton[info.targetArg,FALSE];
        };

    ClearTargetArgOp: TEditInput.CommandProc = {
        ClearTargetArg[mainToolInfo];
        };

    ClearTargetArg: PROC [info: Info] = {
        SavePSel; DataFieldButton[info.targetArg,TRUE];
        };

    BuildTargetEntry: PUBLIC PROC [info: Info] = {
        OPEN info;
        [,targetArg] Ź BuildDataFieldPair[layout, "Target:", TargetButton, info, 2];
        };

    <<-------------------------->>
    docRopes[0] Ź "The following special symbols may be used in search patterns:

    ";
    docRopes[1] Ź " ' Match the next character in the pattern exactly.
    ";
    docRopes[2] Ź " ~ Match any character except the next one in the pattern.
    ";
    docRopes[3] Ź " # Match any single character.
    ";
    docRopes[4] Ź " * Match any sequence of characters.
    ";
    docRopes[5] Ź " @ Match any single alphanumeric character (letter or digit).
    ";
    docRopes[6] Ź " & Match any sequence of alphanumeric characters.
    ";
    docRopes[7] Ź " ~@ Match any single non-alphanumeric character.
    ";
    docRopes[8] Ź " ~& Match any sequence of non-alphanumeric characters.
    ";
    docRopes[9] Ź " % Match any single blank character.
    ";
    docRopes[10] Ź " $ Match any sequence of blank characters.
    ";
    docRopes[11] Ź " ~% Match any single non-blank character.
    ";
    docRopes[12] Ź " ~$ Match any sequence of non-blank characters.
    ";
    docRopes[13] Ź " | Match start or end of node.
    ";
    docRopes[14] Ź " { Mark start of resulting selection.
    ";
    docRopes[15] Ź " } Mark end of resulting selection.
    ";
    docRopes[16] Ź " < Mark start of named subpattern.
    ";
    docRopes[17] Ź " > Mark end of named subpattern.
    ";

    miniDocRopes[0] Ź "single character: # any; @ alpha; ~@ nonalpha; % blank; ~% nonblank;
    ";
    miniDocRopes[1] Ź "min sequence: * any; & alpha; ~& nonalpha; $ blank; ~$ nonblank;
    ";
    miniDocRopes[2] Ź "max sequence: ** any; && alpha; ~&~& nonalpha; $$ blank; ~$~$ nonblank;
    ";
    miniDocRopes[3] Ź "other: 'x = x; ~x = not x; | node boundary; { } selection; < > named subpattern
    ";


    END.