
    <<BringOverToolImpl.mesa>>
        <<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
        <<last edited by Levin on December 16, 1983 2:30 pm>>
        <<Doug Wyatt, March 6, 1985 12:56:00 pm PST>>
        <<Spreitzer, May 20, 1985 5:52:13 pm PDT>>

    DIRECTORY
        Buttons USING [ButtonProc, Create],
        Containers USING [ChildXBound, Create],
        DFOperations USING [BringOverAction, BringOverFilter, BringOverFilterA, BringOverFilterB, BringOverFilterC, InteractionProc],
        DFOperationsQueue USING [Enqueue, RequestRecord],
        DFToolInternal USING [AddOpToTable, Choice, CreateSelector, DFTool, EnsureDFName, MakeCenteredLabel, offScreenY, OpDefiner, 
        Operation, OpsInteraction, OpSpecificProc, OptionSelector, Parameters, SelectOption, ViewerToRopeList],
        FileViewerOps USING [WaitUntilSaved],
        Rope USING [Concat, ROPE],
        ViewerClasses USING [Viewer],
        ViewerOps USING [MoveViewer],
        ViewerTools USING [GetContents, MakeNewTextViewer, SetContents, SetSelection];

    BringOverToolImpl: CEDAR PROGRAM
    IMPORTS Buttons, Containers, DFOperationsQueue, DFToolInternal, FileViewerOps, Rope, ViewerOps, ViewerTools
    = BEGIN OPEN 
    Ops: DFOperations, 
    OpsQ: DFOperationsQueue, 
    Tool: DFToolInternal;

    ROPE: TYPE = Rope.ROPE;
    <<>>
    <<-- ---- ---- ---- ---- ---- ---- ---->>
    <<BringOver-specific Code>>
    <<-- ---- ---- ---- ---- ---- ---- ---->>

    BringOverData: TYPE = RECORD [
        filter: Ops.BringOverFilter _ [],
        filterASelector: REF Tool.OptionSelector _ NIL,
        filterBSelector: REF Tool.OptionSelector _ NIL,
        filterCSelector: REF Tool.OptionSelector _ NIL,
        action: Ops.BringOverAction _ enter,
        actionSelector: REF Tool.OptionSelector _ NIL,
        usingList: ViewerClasses.Viewer _ NIL  -- undigested TEXT for filter.list
        ];

    selectedFilesLines: NAT = 2;

    BringOverSpecific: Tool.OpSpecificProc = {
        SELECT action FROM
            $createOptions => {
                op: Tool.Operation = NARROW[param];
                tool: Tool.DFTool = op.tool;
                parameters: Tool.Parameters = tool.parameters;
                prev: ViewerClasses.Viewer;
                x: INTEGER;
                data: REF BringOverData = NEW[BringOverData _ []];
                initialChoice: Tool.Choice;
                op.options _ data;
                op.optionsContainer _ Containers.Create[info: [
                    wx: 0, wy: Tool.offScreenY,
                    ww: 9999,  -- arbitrary; Containers.ChildXBound overrides
                    wh: 0,
                    parent: tool.inner,
                    border: FALSE,
                    scrollable: FALSE
                    ]];
                Containers.ChildXBound[tool.inner, op.optionsContainer];
                Tool.MakeCenteredLabel[op, op.definer.opAlias.Concat[" Options"]];
                [data.filterASelector, initialChoice, x] _ Tool.CreateSelector[
                    name: "Origin", proc: SelectBringOverFilterA, clientData: data,
                    choices: LIST[
                        ["all", NEW[Ops.BringOverFilterA _ $all]],
                        ["derived", NEW[Ops.BringOverFilterA _ $derived]],
                        ["source", NEW[Ops.BringOverFilterA _ $source]]
                        ],
                    op: op
                    ];
                data.filter.filterA _ NARROW[initialChoice.value, REF Ops.BringOverFilterA]^;
                [data.filterBSelector, initialChoice, x] _ Tool.CreateSelector[
                    name: "Access", proc: SelectBringOverFilterB, clientData: data,
                    choices: LIST[
                        ["all", NEW[Ops.BringOverFilterB _ $all]],
                        ["private", NEW[Ops.BringOverFilterB _ $private]],
                        ["public", NEW[Ops.BringOverFilterB _ $public]]
                        ],
                    op: op,
                    x: x + parameters.entryHSpace
                    ];
                data.filter.filterB _ NARROW[initialChoice.value, REF Ops.BringOverFilterB]^;
                [data.filterCSelector, initialChoice, x] _ Tool.CreateSelector[
                    name: "Reference", proc: SelectBringOverFilterC, clientData: data,
                    choices: LIST[
                        ["all", NEW[Ops.BringOverFilterC _ $all]],
                        ["imported", NEW[Ops.BringOverFilterC _ $imported]],
                        ["defining", NEW[Ops.BringOverFilterC _ $defining]]
                        ],
                    op: op,
                    x: x + parameters.entryHSpace
                    ];
                data.filter.filterC _ NARROW[initialChoice.value, REF Ops.BringOverFilterC]^;
                op.height _ op.height + parameters.entryHeight + parameters.entryVSpace;
                data.usingList _ ViewerTools.MakeNewTextViewer[info: [
                    wx: 0,  -- we'll move it soon
                    wy: op.height,
                    ww: 9999,  -- arbitrary; Containers.ChildXBound overrides
                    wh: selectedFilesLines*tool.parameters.entryHeight,
                    data: NIL,
                    parent: op.optionsContainer,
                    scrollable: TRUE,
                    border: FALSE
                    ]];
                prev _ Buttons.Create[
                    info: [name: "Selected files:",
                        wx: parameters.entryHSpace,
                        wy: op.height,
                        wh: tool.parameters.entryHeight,
                        parent: op.optionsContainer, 
                        border: FALSE
                        ],
                    proc: SelectUsingList,
                    fork: FALSE,
                    clientData: data.usingList,
                    font: parameters.font
                    ];
                ViewerOps.MoveViewer[
                    viewer: data.usingList,
                    x: prev.wx + prev.ww + parameters.entryHSpace, y: data.usingList.wy,
                    w: data.usingList.ww, h: data.usingList.wh,
                    paint: FALSE
                    ];
                Containers.ChildXBound[op.optionsContainer, data.usingList];
                op.height _ op.height + selectedFilesLines*tool.parameters.entryHeight + parameters.entryVSpace;
                [data.actionSelector, initialChoice, x] _ Tool.CreateSelector[
                    name: "Action for each file", proc: SelectBringOverAction, clientData: data,
                    choices: LIST[
                        ["enter in directory as attachment", NEW[Ops.BringOverAction _ $enter]],
                        ["check remote server", NEW[Ops.BringOverAction _ $check]],
                        ["check remote server, then enter in directory",
                            NEW[Ops.BringOverAction _ $checkAndEnter]],
                        ["enter in directory as attachment and fetch", NEW[Ops.BringOverAction _ $fetch]]
                        ],
                    op: op
                    ];
                data.action _ NARROW[initialChoice.value, REF Ops.BringOverAction]^;
                op.height _ op.height + tool.parameters.entryHeight + parameters.entryVSpace;
                ViewerOps.MoveViewer[
                    viewer: op.optionsContainer,
                    x: op.optionsContainer.wx, y: op.optionsContainer.wy,
                    w: op.optionsContainer.ww, h: op.height,
                    paint: FALSE
                    ];
                };
            $doOp => {
                op: Tool.Operation = NARROW[param];
                tool: Tool.DFTool = op.tool;
                wDir: ROPE = ViewerTools.GetContents[tool.wDir];
                data: REF BringOverData = NARROW[op.options];
                data.filter.list _ Tool.ViewerToRopeList[data.usingList];
                FOR list: LIST OF ROPE _ Tool.ViewerToRopeList[tool.dfNames], list.rest UNTIL list = NIL DO
                    short, long: ROPE;
                    [short, long] _ Tool.EnsureDFName[list.first, wDir];
                    FileViewerOps.WaitUntilSaved[long, tool.feedback];
                    tool.opsQueue.Enqueue[NEW[OpsQ.RequestRecord _ [
                        dfFile: short,
                        wDir: wDir,
                        interact: Tool.OpsInteraction,
                        log: tool.log,
                        clientData: op,
                        opSpecific: bringOver[filter: data.filter, action: data.action]
                        ]]];
                    ENDLOOP;
                };
            ENDCASE;
        };

    SelectBringOverFilterA: Buttons.ButtonProc = {
        <<Note: runs synchronously with Viewers' notifier to ensure atomicity with $doOp logic.>>
        data: REF BringOverData = NARROW[clientData];
        data.filter.filterA _
            NARROW[Tool.SelectOption[data.filterASelector].value, REF Ops.BringOverFilterA]^;
        };

    SelectBringOverFilterB: Buttons.ButtonProc = {
        <<Note: runs synchronously with Viewers' notifier to ensure atomicity with $doOp logic.>>
        data: REF BringOverData = NARROW[clientData];
        data.filter.filterB _
            NARROW[Tool.SelectOption[data.filterBSelector].value, REF Ops.BringOverFilterB]^;
        };

    SelectBringOverFilterC: Buttons.ButtonProc = {
        <<Note: runs synchronously with Viewers' notifier to ensure atomicity with $doOp logic.>>
        data: REF BringOverData = NARROW[clientData];
        data.filter.filterC _
            NARROW[Tool.SelectOption[data.filterCSelector].value, REF Ops.BringOverFilterC]^;
        };

    SelectBringOverAction: Buttons.ButtonProc = {
        <<Note: runs synchronously with Viewers' notifier to ensure atomicity with $doOp logic.>>
        data: REF BringOverData = NARROW[clientData];
        data.action _ NARROW[Tool.SelectOption[data.actionSelector].value, REF Ops.BringOverAction]^;
        };

    SelectUsingList: Buttons.ButtonProc = {
        <<Note: runs synchronously with Viewers' notifier to ensure than manipulation of the using list is atomic.>>
        usingList: ViewerClasses.Viewer = NARROW[clientData];
        IF mouseButton = blue THEN ViewerTools.SetContents[usingList, NIL];
        ViewerTools.SetSelection[usingList, NIL];
        };

    <<-- ---- ---- ---- ---- ---- ---- ---->>
    <<Initialization>>
    <<-- ---- ---- ---- ---- ---- ---- ---->>

    Tool.AddOpToTable[
        NEW[Tool.OpDefiner _ ["BringOver", $bringOver, $individual, BringOverSpecific]]];

    END.