<<>>
    <<ButtonOpenImpl.mesa>>
        <<Copyright Ó 1988, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Last edited by Bier on January 3, 1989 11:36:46 pm PST>>
        <<Bier, June 16, 1991 4:02 pm PDT>>
        <<Doug Wyatt, April 14, 1992 12:39 pm PDT>>

    <<Contents:  Implements a tool which displays a list of items, such as file names, as TiogaButtons and allows a procedure to be 
    registered with each item, that is performed when that button is pressed.>>
        <<>>
    DIRECTORY
        Args, Commander, Containers, DFUtilities, FileNames, FS, IO, MessageWindow, PFS, Rope, TiogaButtons, TiogaMenuOps, ViewerClasses, 
        ViewerOps;

    ButtonOpenImpl: CEDAR PROGRAM
        IMPORTS Args, Commander, Containers, DFUtilities, FileNames, FS, IO, MessageWindow, PFS, Rope, TiogaButtons, TiogaMenuOps, ViewerOps
        EXPORTS  = BEGIN

    ROPE: TYPE = Rope.ROPE;
    Viewer: TYPE = ViewerClasses.Viewer;

    MacroToolRef: TYPE = REF MacroToolObj;
    MacroToolObj: TYPE = RECORD [
        container: Viewer,
        buttons: Viewer,
        workingDirectory: Rope.ROPE,
        headerButton: TiogaButtons.TiogaButton,
        prevButton: TiogaButtons.TiogaButton
        ];

    CreateMacroTool: PROC [name: Rope.ROPE, workingDirectory: Rope.ROPE] RETURNS [macroTool: MacroToolRef] = {
        macroTool Ź NEW[MacroToolObj];
        macroTool.workingDirectory Ź workingDirectory;
        macroTool.container Ź
        Containers.Create[
            info: [
            name: name,
            iconic: TRUE,
            column: left,
            scrollable: FALSE]];        -- inhibit user from scrolling contents
        MakeTiogaButtons[macroTool];
        };

    MakeTiogaButtons: PROC [macroTool: MacroToolRef] = {
        lineHeight: INTEGER Ź 15;
        macroTool.buttons Ź TiogaButtons.CreateViewer[
            info: [
                wx: 0, wy: 0, ww: macroTool.container.ww, wh: macroTool.container.wh,
                parent: macroTool.container,
                border: FALSE]
            ];
        macroTool.container.class.set[self: macroTool.container, data: macroTool.buttons, op: $XBound];
        macroTool.container.class.set[self: macroTool.container, data: macroTool.buttons, op: $YBound];
        macroTool.headerButton Ź macroTool.prevButton Ź NewHeaderButton[macroTool.buttons, NIL];
        };

    NewHeaderButton: PROC [v: Viewer, name: Rope.ROPE] RETURNS [button: TiogaButtons.TiogaButton] = {
        button Ź TiogaButtons.CreateButton[
        viewer: v,
        rope: name,
        format: "",
        looks: "",
        proc: NIL,
        clientData: NIL];
        };

    ButtonData: TYPE = REF ButtonDataObj;
    ButtonDataObj: TYPE = RECORD [
        localName: Rope.ROPE,
        inDFName: Rope.ROPE,
        macroTool: MacroToolRef
        ];

    FileExists: PROC [name: ROPE] RETURNS [BOOL] = {
        path: PFS.PATH Ź PFS.PathFromRope[name];
        fullName: PFS.PATH;
        fullName Ź PFS.FileInfo[name: path ! PFS.Error=> CONTINUE].fullFName;
        RETURN[fullName#NIL];
        };

    OpenFile: TiogaButtons.TiogaButtonProc = {
        TryRemote: PROC [] = {
            IF buttonData.inDFName # NIL THEN {
                IF FileExists[buttonData.inDFName]
                    THEN {
                        MessageWindow.Append[Rope.Concat["Opening ", buttonData.inDFName], TRUE];
                        [] Ź TiogaMenuOps.Open[fileName: buttonData.inDFName, column: left];
                        }
                    ELSE {
                        MessageWindow.Append[IO.PutFR1["ButtonOpen: Couldn't find %g ... giving up", [rope[buttonData.inDFName]]], TRUE];
                        MessageWindow.Blink[];
                        };
                };
            };
        buttonData: ButtonData Ź NARROW[clientData];
        macroTool: MacroToolRef Ź buttonData.macroTool;
        IF mouseButton = red OR mouseButton = yellow THEN {
            IF buttonData.localName # NIL
                THEN {
                    IF FileExists[buttonData.localName]
                        THEN {
                            MessageWindow.Append[Rope.Concat["Opening ", buttonData.localName], TRUE];
                            [] Ź TiogaMenuOps.Open[fileName: buttonData.localName, column: left];
                            }
                        ELSE {
                            MessageWindow.Append[IO.PutFR1["ButtonOpen: Couldn't find %g ... trying released version", [rope[buttonData.localName]]], TRUE];
                            MessageWindow.Blink[];
                            TryRemote[];
                            };
                    }
                ELSE TryRemote[];
            }
        ELSE TryRemote[];
        };

    ButtonOpenDF: TiogaButtons.TiogaButtonProc = {
        TryRemote: PROC RETURNS [errorMsg: ROPE Ź NIL] = {
            MessageWindow.Append[Rope.Concat["ButtonOpen DF: ", buttonData.inDFName], TRUE];
            IF buttonData.inDFName # NIL THEN errorMsg Ź ButtonOpen[dfName: buttonData.inDFName, wDir: macroTool.workingDirectory, column: 
            right];
            };
        buttonData: ButtonData Ź NARROW[clientData];
        macroTool: MacroToolRef Ź buttonData.macroTool;
        errorMsg: ROPE;
        IF mouseButton = red OR mouseButton = yellow THEN {
            MessageWindow.Append[Rope.Concat["ButtonOpen DF: ", buttonData.localName], TRUE];
            IF buttonData.localName # NIL THEN errorMsg Ź ButtonOpen[dfName: buttonData.localName, wDir: macroTool.workingDirectory, column: 
            right];
            IF errorMsg # NIL THEN errorMsg Ź TryRemote[];
            }
        ELSE errorMsg Ź TryRemote[];
        IF errorMsg # NIL THEN {
            MessageWindow.Append[errorMsg, TRUE];
            MessageWindow.Blink[];
            };
        };

    PressDirectory: TiogaButtons.TiogaButtonProc = {
        buttonData: ButtonData Ź NARROW[clientData];
        macroTool: MacroToolRef Ź buttonData.macroTool;
        MessageWindow.Append[Rope.Concat["Creating viewer in directory: ", buttonData.inDFName], TRUE];
        [] Ź TiogaMenuOps.Open[fileName: buttonData.inDFName, column: left];
        };


    ExpandFileName: PROC [name: Rope.ROPE, wDir: ROPE] RETURNS [fullName: Rope.ROPE, success: BOOL Ź TRUE] = {
        name Ź FileNames.StripVersionNumber[name];
        [fullName, ----, ----] Ź FS.ExpandName[name, wDir ! FS.Error => {
            success Ź FALSE;
            CONTINUE;
            }
            ];
        IF NOT success THEN fullName Ź NIL;
        };

    AddFile: PROC [fileName, comment: ROPE, macroTool: MacroToolRef, inDFDirectory: ROPE] RETURNS [success: BOOL Ź FALSE] = {
        buttonData: ButtonData Ź NEW[ButtonDataObj];
        [buttonData.localName, success] Ź ExpandFileName[fileName, macroTool.workingDirectory];
        [buttonData.inDFName, success] Ź ExpandFileName[fileName, inDFDirectory];
        buttonData.macroTool Ź macroTool;
        macroTool.prevButton Ź TiogaButtons.AppendToButton[
            button: macroTool.prevButton,
            rope: Rope.Cat["  ", comment, FileNames.StripVersionNumber[fileName], "\n"],
            looks: "",
            proc: OpenFile,
            clientData: buttonData,
            fork: FALSE];
        };

    AddDF: PROC [localName, remoteName, comment: ROPE, macroTool: MacroToolRef] RETURNS [success: BOOL Ź TRUE] = {
        buttonData: ButtonData Ź NEW[ButtonDataObj];
        buttonData.localName Ź localName;
        buttonData.inDFName Ź remoteName;
        buttonData.macroTool Ź macroTool;
        macroTool.prevButton Ź TiogaButtons.AppendToButton[
            button: macroTool.prevButton,
            rope: "  [ ] ",
            looks: "b",
            proc: ButtonOpenDF,
            clientData: buttonData,
            fork: FALSE];
        macroTool.prevButton Ź TiogaButtons.AppendToButton[
            button: macroTool.prevButton,
            rope: Rope.Cat[" ", comment, FileNames.StripVersionNumber[remoteName], "\n"],
            looks: "",
            proc: OpenFile,
            clientData: buttonData,
            fork: FALSE];
        };

    AddDirectory: PROC [path1: Rope.ROPE, macroTool: MacroToolRef] = {
        buttonData: ButtonData Ź NEW[ButtonDataObj];
        buttonData.inDFName Ź path1;
        buttonData.macroTool Ź macroTool;
        macroTool.prevButton Ź TiogaButtons.AppendToButton[
            button: macroTool.prevButton,
            rope: Rope.Concat[buttonData.inDFName, "\n"],
            looks: "",
            proc: PressDirectory,
            clientData: buttonData,
            fork: FALSE];
        };

    ButtonOpenCommand: Commander.CommandProc = {
        <<CommandProc: TYPE = PROC [cmd: Handle] RETURNS [result: REF _ NIL, msg: ROPE _ NIL];>>
        dfName: ROPE;
        wDir: Rope.ROPE Ź FileNames.CurrentWorkingDirectory[];
        IF Args.NArgs[cmd] > 0 THEN {
            dfName Ź Args.GetRope[cmd, 0];
            msg Ź ButtonOpen[dfName, wDir, right];
            };
        };

    ButtonOpen: PROC [dfName, wDir: ROPE, column: ViewerOps.Column Ź right] RETURNS [errorMsg: ROPE] = {
        fullDFName, badName: ROPE;
        successSoFar: BOOL Ź TRUE;
        cp: FS.ComponentPositions;
        dfFilter: DFUtilities.Filter Ź [
            comments: FALSE,
            filterA: all,
            filterB: all,
            filterC: all,
            list: NIL
            ];
        dfStream: IO.STREAM;
        macroTool: MacroToolRef;
        AddToMacroTool: DFUtilities.ProcessItemProc = {
            <<ProcessItemProc: TYPE = PROC [item: REF ANY] RETURNS [stop: BOOL _ FALSE];>>
            WITH item SELECT FROM
                fileItem: REF DFUtilities.FileItem => {
                    success: BOOL;
                    fullName: Rope.ROPE;
                    [fullName, cp] Ź FS.ExpandName[fileItem.name, macroTool.workingDirectory];
                    success Ź AddFile[fileItem.name, NIL, macroTool, inDFDirectory];
                    IF NOT success AND successSoFar THEN {
                        badName Ź fileItem.name;
                        successSoFar Ź FALSE;
                        };
                    };
                directoryItem: REF DFUtilities.DirectoryItem => {
                    inDFDirectory Ź directoryItem.path1;
                    AddDirectory[directoryItem.path1, macroTool];
                    };
                includeItem: REF DFUtilities.IncludeItem => {
                    success: BOOL;
                    shortName, localName, remoteName: ROPE;
                    [remoteName, cp,] Ź FS.ExpandName[includeItem.path1];
                    shortName Ź Rope.Concat[Rope.Substr[remoteName, cp.base.start, cp.base.length], ".df"];
                    [localName, cp,] Ź FS.ExpandName[shortName, macroTool.workingDirectory];
                    success Ź AddDF[localName, remoteName, "Include ", macroTool];
                    IF NOT success AND successSoFar THEN {
                        badName Ź includeItem.path1;
                        successSoFar Ź FALSE;
                        };
                    };
                importsItem: REF DFUtilities.ImportsItem => {
                    success: BOOL;
                    shortName, localName, remoteName: ROPE;
                    [remoteName, cp,] Ź FS.ExpandName[importsItem.path1];
                    shortName Ź Rope.Concat[Rope.Substr[remoteName, cp.base.start, cp.base.length], ".df"];
                    [localName, cp,] Ź FS.ExpandName[shortName, macroTool.workingDirectory];
                    success Ź AddDF[localName, remoteName, "Imports ", macroTool];
                    IF NOT success AND successSoFar THEN {
                        badName Ź importsItem.path1;
                        successSoFar Ź FALSE;
                        };
                    };
                ENDCASE;
            };
        inDFDirectory: ROPE Ź NIL;
        [fullDFName, cp] Ź FS.ExpandName[dfName, wDir];
        IF NOT Rope.Equal[Rope.Substr[fullDFName, cp.ext.start, cp.ext.length], "df", FALSE] THEN {
            RETURN["ButtonOpen only works on DF files"];
            };
        dfStream Ź FS.StreamOpen[dfName, $read
            ! FS.Error => {errorMsg Ź Rope.Concat[error.explanation, "\n"]; CONTINUE}];
        IF errorMsg # NIL THEN RETURN;
        IF dfStream # NIL THEN {
            macroTool Ź CreateMacroTool[Rope.Cat[dfName, ", ", wDir], wDir];
            DFUtilities.ParseFromStream[dfStream, AddToMacroTool, dfFilter];
            IF NOT successSoFar THEN
                MessageWindow.Append[Rope.Concat["FS Error during name expansion of ", badName], TRUE]
            ELSE {
                ViewerOps.ChangeColumn[macroTool.container, column];
                ViewerOps.OpenIcon[macroTool.container];
                };
            };
        };

    Commander.Register[key: "ButtonOpen", proc: ButtonOpenCommand, doc: "Takes a DF file name.  Opens a TiogaButton files with one 
    button for each file mentioned in the DF file", clientData: NIL, interpreted: TRUE]
    END.