<<>>
    <<MenusImpl.mesa>>
        <<Copyright Ó 1985, 1986, 1987, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Russ Atkinson (RRA) June 11, 1985 4:15:15 pm PDT>>
        <<Doug Wyatt, January 20, 1987 0:09:42 am PST>>
        <<Bier, February 2, 1989 12:06:47 pm PST>>
        <<Willie-s, October 8, 1991 1:10 pm PDT>>
        <<>>
    DIRECTORY
        CedarProcess USING [SetPriority],
        Imager USING [black, Color, Context, MaskRectangleI, SetColor, SetFont, SetXRelI, SetXYI, ShowRope, white],
        ImagerFont USING [Extents, FontBoundingBox],
        ImagerBackdoor USING [MakeStipple],
        Menus USING [armedTime, armingTime, ClickProc, Menu, MenuEntry, MenuEntryRec, MenuRec, MenuLine, MouseButton],
        MessageWindow USING [Append],
        Process USING [Detach, Milliseconds, MsecToTicks, SetTimeout],
        Real USING [Round],
        Rope USING [Equal, FromRefText, ROPE],
        TIPUser USING [TIPScreenCoords],
        VFonts USING [defaultFont, Font, StringWidth],
        ViewerClasses USING [Viewer],
        ViewerOps USING [PaintViewer],
        ViewerPrivate USING [DrawCaptionMenu, InvertForMenus, menuHLeading, menuHSpace, windowMenu],
        ViewerSpecs USING [menuHeight],
        WindowManager USING [RestoreCursor];

    MenusImpl: CEDAR MONITOR LOCKS entry USING entry: MenuEntry
        IMPORTS CedarProcess, Imager, ImagerBackdoor, ImagerFont, MessageWindow, Process, Real, Rope, VFonts, ViewerOps, ViewerPrivate, 
        ViewerSpecs, WindowManager
        EXPORTS Menus, ViewerPrivate
        SHARES ViewerClasses, ViewerOps
        = BEGIN OPEN Menus;

    Viewer: TYPE ~ ViewerClasses.Viewer;

    menuFont: VFonts.Font Ź VFonts.defaultFont;
    fontHeight: INTEGER Ź 0;
    baselineOffset: INTEGER Ź 0;
    margin: INTEGER = 3;

    CreateMenu: PUBLIC PROC [lines: MenuLine Ź 1] RETURNS [menu: Menu] ~ {
        RETURN[NEW[MenuRec Ź [linesUsed: lines]]]
        };

    CopyMenu: PUBLIC PROC [old: Menu] RETURNS [new: Menu] = {
        new Ź CreateMenu[old.linesUsed];
        FOR l: MenuLine IN MenuLine UNTIL old.lines[l]=NIL DO
            new.lines[l] Ź old.lines[l];
            CopyLine[new, l];
            ENDLOOP;
        };

    <<CopyLine: PROC [menu: Menu, line: INTEGER] = {>>
        <<oldEntry: MenuEntry _ menu.lines[line];>>
        <<newEntry: MenuEntry;>>
        <<menu.lines[line] _ NIL;>>
        <<FOR t: MenuEntry _ oldEntry, t.link UNTIL t=NIL DO>>
            <<newEntry _ CopyEntry[t];>>
            <<newEntry.greyed _ FALSE;>>
            <<newEntry.guardState _ IF newEntry.guarded THEN guarded ELSE armed;>>
            <<IF menu.lines[line]=NIL>>
                <<THEN menu.lines[line] _ newEntry>>
                <<ELSE newEntry.link _ newEntry;>>
            <<ENDLOOP;>>
        <<};>>
        <<>>
    CopyLine: PROC [menu: Menu, line: INTEGER] = {
        oldEntry: MenuEntry Ź menu.lines[line];
        newEntry: MenuEntry;
        menu.lines[line] Ź NIL;
        FOR t: MenuEntry Ź oldEntry, t.link UNTIL t=NIL DO
            IF menu.lines[line]=NIL THEN newEntry Ź menu.lines[line] Ź CopyEntry[t]
            ELSE newEntry Ź newEntry.link Ź CopyEntry[t];
            newEntry.greyed Ź FALSE;
            newEntry.guardState Ź IF newEntry.guarded THEN guarded ELSE armed;
            ENDLOOP;
        };

    CopyEntry: PUBLIC PROC [oldEntry: MenuEntry] RETURNS [newEntry: MenuEntry] = {
        newEntry Ź NEW[MenuEntryRec];
        newEntry.link Ź oldEntry.link;
        newEntry.name Ź oldEntry.name;
        newEntry.proc Ź oldEntry.proc;
        newEntry.width Ź oldEntry.width;
        newEntry.xPos Ź oldEntry.xPos;
        newEntry.clientData Ź oldEntry.clientData;
        newEntry.documentation Ź oldEntry.documentation;
        newEntry.fork Ź oldEntry.fork;
        newEntry.greyed Ź oldEntry.greyed;
        newEntry.guarded Ź oldEntry.guarded;
        newEntry.guardState Ź oldEntry.guardState;
        };

    CreateEntry: PUBLIC PROC [name: Rope.ROPE, proc: ClickProc, clientData: REF ANY Ź NIL, documentation: REF ANY Ź NIL, fork: BOOL Ź 
    TRUE, guarded: BOOL Ź FALSE] RETURNS [entry: MenuEntry] = {
        entry Ź NEW[MenuEntryRec Ź [
            name: name,
            proc: proc,
            clientData: clientData,
            documentation: documentation,
            fork: fork,
            guarded: guarded,
            guardState: IF guarded THEN guarded ELSE armed,
            width: VFonts.StringWidth[name, menuFont]
            ]];
        };

    SetGuarded: PUBLIC PROC [entry: MenuEntry, guard: BOOL] = {
        entry.guarded Ź guard;
        entry.guardState Ź IF guard THEN guarded ELSE armed;
        };

    SetClientData: PUBLIC PROC [entry: MenuEntry, newData: REF ANY] RETURNS [oldData: REF ANY] = {
        oldData Ź entry.clientData;
        entry.clientData Ź newData;
        };

    SetDocumentation: PUBLIC PROC [entry: MenuEntry, newDoc: REF ANY] RETURNS [oldDoc: REF ANY] = {
        oldDoc Ź entry.documentation;
        entry.documentation Ź newDoc;
        };

    FindEntry: PUBLIC PROC [menu: Menu, entryName: Rope.ROPE] 
    RETURNS [entry: MenuEntry] = {
        IF menu=NIL THEN RETURN[NIL];
        FOR l: MenuLine IN MenuLine UNTIL menu.lines[l]=NIL DO
            FOR e: MenuEntry Ź menu.lines[l], e.link UNTIL e=NIL DO
                IF Rope.Equal[e.name, entryName] THEN RETURN[e];
                ENDLOOP;
            ENDLOOP;
        };

    InsertMenuEntry: PUBLIC PROC [menu: Menu, entry: MenuEntry, line: MenuLine Ź 0] = {
        entry.link Ź menu.lines[line];
        menu.lines[line] Ź entry;
        entry.xPos Ź ViewerPrivate.menuHLeading;
        FOR e: MenuEntry Ź menu.lines[line].link, e.link UNTIL e=NIL DO
            e.xPos Ź e.xPos + entry.width + ViewerPrivate.menuHSpace;
            ENDLOOP;
        };

    AppendMenuEntry: PUBLIC PROC [menu: Menu, entry: MenuEntry, line: MenuLine Ź 0] = {
        entry.link Ź NIL;
        IF menu.lines[line]=NIL
            THEN {entry.xPos Ź ViewerPrivate.menuHLeading; menu.lines[line] Ź entry}
            ELSE FOR e: MenuEntry Ź menu.lines[line], e.link UNTIL e.link=NIL DO
                REPEAT FINISHED => {
                    entry.xPos Ź e.xPos+e.width+ViewerPrivate.menuHSpace;
                    e.link Ź entry};
                ENDLOOP;
        };

    MenuFromMenuEntry: PUBLIC PROC[entryList: MenuEntry] RETURNS [Menu] ~ {
        menu: Menu ~ CreateMenu[lines: 1];

        SetLine[menu: menu, line: 0, entryList: entryList];
        RETURN [menu];
        };

    MenuEntryFind: PUBLIC PROC[entryName: Rope.ROPE, entryList: MenuEntry]
    RETURNS [MenuEntry] ~ {
        <<Search for an entry given the name.  Will return NIL if target name not found.>>
        menu: Menu ~ MenuFromMenuEntry[entryList: entryList];

        RETURN [FindEntry[menu: menu, entryName: entryName]];
        };
        <<>>
    MenuEntryAppend: PUBLIC PROC[entry: MenuEntry, entryList: MenuEntry]
    RETURNS [MenuEntry] ~ {
        <<Add the entry to the end of the list.>>
        menu: Menu ~ MenuFromMenuEntry[entryList: entryList];

        AppendMenuEntry[menu: menu, entry: entry, line: 0];
        RETURN [GetLine[menu: menu, line: 0]];
        };

    MenuEntryInsert: PUBLIC PROC[entry: MenuEntry, entryList: MenuEntry]
    RETURNS [MenuEntry] ~ {
        <<Add the entry to the beginning of the list.>>
        menu: Menu ~ MenuFromMenuEntry[entryList: entryList];

        InsertMenuEntry[menu: menu, entry: entry, line: 0];
        RETURN [GetLine[menu: menu, line: 0]];
        };
        <<>>
    MenuEntryReplace: PUBLIC PROC[entryList: MenuEntry, old: MenuEntry, new: MenuEntry]
    RETURNS [MenuEntry] ~ {
        <<Change an existing entry in a menu.  If new is NIL then old will be deleted.>>
        <<Will raise targetNotFound if target entry not found.>>
        menu: Menu ~ MenuFromMenuEntry[entryList: entryList];

        ReplaceMenuEntry[menu: menu, oldEntry: old, newEntry: new];
            <<! targetNotFound => RAISE targetNotFound>>
        RETURN [GetLine[menu: menu, line: 0]];
        };

    targetNotFound: PUBLIC SIGNAL = CODE;

    ReplaceMenuEntry: PUBLIC PROC [menu: Menu, oldEntry: MenuEntry, newEntry: MenuEntry Ź NIL] = {
        l: MenuLine;
        x: INTEGER Ź ViewerPrivate.menuHLeading;
        exit: BOOL Ź FALSE;
        FOR l IN MenuLine UNTIL menu.lines[l]=NIL DO
            IF oldEntry=menu.lines[l] THEN {
                IF newEntry=NIL
                    THEN menu.lines[l] Ź menu.lines[l].link
                    ELSE {
                        newEntry.link Ź oldEntry.link;
                        menu.lines[l] Ź newEntry;
                        };
                EXIT;
                }
            ELSE FOR e: MenuEntry Ź menu.lines[l], e.link UNTIL e.link=NIL DO
                IF e.link=oldEntry THEN {
                    IF newEntry=NIL
                        THEN e.link Ź e.link.link
                        ELSE {
                            newEntry.link Ź oldEntry.link;
                            e.link Ź newEntry;
                            };
                    exit Ź TRUE;
                    EXIT;
                    };
                ENDLOOP;
            IF exit THEN EXIT;
            REPEAT FINISHED => SIGNAL targetNotFound;
            ENDLOOP;
        IF menu.lines[l]#NIL THEN menu.lines[l].xPos Ź ViewerPrivate.menuHLeading;
        FOR e: MenuEntry Ź menu.lines[l], e.link UNTIL e=NIL DO
            e.xPos Ź x;
            x Ź x+e.width+ViewerPrivate.menuHSpace;
            ENDLOOP;
        };

    ChangeNumberOfLines: PUBLIC PROC [menu: Menu, newLines: MenuLine] = {
        menu.linesUsed Ź newLines;
        };

    GetNumberOfLines: PUBLIC PROC [menu: Menu] RETURNS [lines: MenuLine] = {
        RETURN[menu.linesUsed];
        };

    SetLine: PUBLIC PROC [menu: Menu, line: MenuLine, entryList: MenuEntry] = {
        menu.lines[line] Ź entryList; menu.linesUsed Ź MAX[menu.linesUsed, line+1];
        };

    GetLine: PUBLIC PROC [menu: Menu, line: MenuLine] RETURNS [entryList: MenuEntry] = {
        RETURN[menu.lines[line]];
        };

    MarkMenu: PUBLIC PROC [menu: Menu, parent: ViewerClasses.Viewer, mousePos: TIPUser.TIPScreenCoords] = {
        delta: INTEGER ~ (menu.y-mousePos.mouseY);
        IF delta >= 0 THEN {
            row: NAT ~ NAT[delta]/ViewerSpecs.menuHeight;
            newEntry: MenuEntry Ź ResolveEntry[menu, row, mousePos.mouseX];
            SELECT TRUE FROM
                newEntry=NIL => {
                    IF menu.inverted#NIL THEN InvertEntry[menu, parent];
                    menu.inverted Ź NIL;
                    };
                newEntry#menu.inverted => {
                    IF menu.inverted#NIL THEN InvertEntry[menu, parent];
                    menu.inverted Ź newEntry;
                    menu.lineInverted Ź row;
                    InvertEntry[menu, parent];
                    };
                ENDCASE;
            };
        };

    HitMenu: PUBLIC PROC [menu: Menu, parent: ViewerClasses.Viewer, mousePos: TIPUser.TIPScreenCoords, button: MouseButton, shift, 
    control: BOOL Ź FALSE] = {
        delta: INTEGER ~ (menu.y-mousePos.mouseY);
        IF delta >= 0 THEN {
            row: NAT ~ NAT[delta]/ViewerSpecs.menuHeight;
            entry: MenuEntry Ź ResolveEntry[menu, row, mousePos.mouseX];
            hit: BOOL Ź menu.inverted#NIL AND entry=menu.inverted;
            IF menu.inverted#NIL THEN InvertEntry[menu, parent]; -- take down
            menu.inverted Ź NIL;
            IF hit THEN ProcessMenuHit[entry, menu, parent, button, shift, control];
            };
        };

    ProcessMenuHit: ENTRY PROC [entry: MenuEntry, menu: Menu, parent: ViewerClasses.Viewer, button: MouseButton, shift, control: BOOL] 
    = TRUSTED {
        SELECT entry.guardState FROM
            guarded => {
                entry.guardState Ź arming;
                Process.Detach[FORK ArmMenuProc[entry, menu, parent]];
                IF entry.documentation#NIL THEN Process.Detach[
                    FORK Document[entry.documentation, parent, entry.clientData, button, shift, control]];
                };
            arming=> NULL; -- no action
            armed => {
                IF entry.guarded THEN entry.guardState Ź guarded;
                IF entry.fork THEN
                    Process.Detach[FORK MenuPusher[entry, menu, parent, button, shift, control]]
                ELSE MenuPusher[entry, menu, parent, button, shift, control, FALSE];
                };
            ENDCASE;
        };

    ArmMenuProc: ENTRY PROC [entry: MenuEntry, menu: Menu, parent: ViewerClasses.Viewer] = {
        menuWaitCondition: CONDITION;
        <<assert: state=arming>>
        TRUSTED {Process.SetTimeout[@menuWaitCondition, Process.MsecToTicks[armingTime]]};
        WAIT menuWaitCondition;
        IF entry.guardState = arming THEN {
            entry.guardState Ź armed;
            RedrawMenu[parent, menu, entry];
            TRUSTED {Process.SetTimeout[@menuWaitCondition, Process.MsecToTicks[armedTime]]};
            WAIT menuWaitCondition;
            };
        IF entry.guardState#guarded THEN {
            entry.guardState Ź guarded;
            RedrawMenu[parent, menu, entry];
            };
        };

    MenuPusher: PROC [entry: MenuEntry, menu: Menu, parent: ViewerClasses.Viewer, button: MouseButton, shift, control: BOOL Ź FALSE, 
    normalPriority: BOOL Ź TRUE] = {
        entry.greyed Ź TRUE;
        RedrawMenu[parent, menu, entry];
        IF normalPriority THEN CedarProcess.SetPriority[normal];
        entry.proc[parent, entry.clientData, button, shift, control ! ABORTED => CONTINUE];
        entry.greyed Ź FALSE;
        RedrawMenu[parent, menu, entry];
        WindowManager.RestoreCursor[];
        };

    RedrawMenu: PROC [viewer: Viewer, menu: Menu, entry: MenuEntry] = {
        IF menu=ViewerPrivate.windowMenu
            THEN ViewerPrivate.DrawCaptionMenu[viewer, FALSE]
            ELSE ViewerOps.PaintViewer[viewer, menu, entry=NIL, entry];
        };

    Document: PUBLIC PROC [info: REF ANY, parent: Viewer, clientData: REF ANY Ź NIL, mouseButton: MouseButton Ź red, shift, control: 
    BOOL Ź FALSE] = {
        WITH info SELECT FROM
            doc: REF TEXT => MessageWindow.Append[Rope.FromRefText[doc], TRUE];
            doc: REF ClickProc => doc­[parent, clientData, mouseButton, shift, control];
            doc: Rope.ROPE => MessageWindow.Append[doc, TRUE];
            ENDCASE => ERROR; -- not valid documentation
        };

    ClearMenu: PUBLIC PROC [menu: Menu, parent: ViewerClasses.Viewer, paint: BOOL Ź TRUE] = {
        IF menu#NIL AND menu.inverted#NIL THEN {
            IF paint THEN InvertEntry[menu, parent];
            menu.inverted Ź NIL;
            };
        };

    greyGuard: PUBLIC BOOL Ź FALSE; -- grey text of guarded items else strikeout

    myGrey: Imager.Color ~ ImagerBackdoor.MakeStipple[001010B];

    DrawMenu: PUBLIC PROC [menu: Menu, context: Imager.Context, x, y: INTEGER, 
    whatChanged: REF ANY Ź NIL] = {
        quitEarly: BOOL Ź FALSE;
        ey: INTEGER Ź y;
        menu.x Ź x;
        menu.y Ź y;
        Imager.SetFont[context, menuFont];
        FOR row: NAT IN [0..menu.linesUsed) DO
            ey Ź ey-ViewerSpecs.menuHeight;
            Imager.SetXYI[context, x+ViewerPrivate.menuHLeading, ey+baselineOffset];
            FOR e: MenuEntry Ź menu.lines[row], e.link UNTIL e=NIL DO
                ex: INTEGER ~ x+e.xPos;
                IF whatChanged#NIL THEN {
                    IF e=whatChanged THEN {
                        Imager.SetColor[context, Imager.white];
                        Imager.MaskRectangleI[context, ex-margin, ey, e.width+margin*2, fontHeight];
                        quitEarly Ź TRUE;
                        }
                    ELSE { Imager.SetXRelI[context, e.width+ViewerPrivate.menuHSpace]; LOOP };
                    };
                IF e.greyed THEN {
                    Imager.SetColor[context, myGrey];
                    Imager.MaskRectangleI[context, ex-margin, ey, e.width+margin*2, fontHeight];
                    };
                Imager.SetColor[context, Imager.black];
                Imager.ShowRope[context, e.name];
                IF e.guarded AND e.guardState#armed THEN {
                    Imager.MaskRectangleI[context, ex-1, ey+baselineOffset+3, e.width+2, 1];
                    };
                IF quitEarly THEN RETURN;
                Imager.SetXRelI[context, ViewerPrivate.menuHSpace];
                ENDLOOP;
            ENDLOOP;
        menu.inverted Ź NIL;
        };

    ResolveEntry: PROC [menu: Menu, line, x: INTEGER] RETURNS [entry: MenuEntry] = {
        IF line NOT IN [0..menu.linesUsed) THEN RETURN[NIL];
        FOR e: MenuEntry Ź menu.lines[line], e.link UNTIL e=NIL OR e.xPos>x DO
            IF x IN [e.xPos..e.xPos+e.width) THEN RETURN[e];
            ENDLOOP;
        RETURN[NIL];
        };

    InvertEntry: PROC [menu: Menu, parent: Viewer] = {
        IF ~parent.destroyed AND ~parent.iconic THEN {
            menuHeight: INTEGER ~ ViewerSpecs.menuHeight;
            x: INTEGER ~ menu.inverted.xPos-margin;
            w: INTEGER ~ menu.inverted.width+(2*margin);
            y: INTEGER ~ menu.y-menu.lineInverted*menuHeight;
            ViewerPrivate.InvertForMenus[parent, x, y, w, -menuHeight];
            };
        };

    ComputeFontInfo: PROC = {
        extents: ImagerFont.Extents ~ ImagerFont.FontBoundingBox[menuFont];
        fontHeight Ź Real.Round[extents.descent+extents.ascent];
        baselineOffset Ź Real.Round[extents.descent];
        };

    <<Initialization>>
    <<>>
    ComputeFontInfo[];

    END.