<<>>
<<AdobeToolImpl>>
<<Copyright Ó 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
<<Philip James, March 10, 1992 11:58 am PST>>

    DIRECTORY
        AdobeCommon USING [AdobeTimeRope, AdobeViewerDataRec, ButtonsSeq, ButtonSeqObject, DependentsSequence, DependentsSequenceRec, 
        EnumeratedTypes, EnumeratedTypesRec, GetFullLoginName, Handle, SelectionsSequence],
        AdobeCommonInternal,
        AdobeOps USING [ARSystemHandle, ArFIO, DateFIO, NumFIO, FixFIO, EnumFIO, StrFIO, ToolType],
        AdobeTool,
        BasicTime USING [GMT, Now],
        Imager,
        IO USING [PutF, Value],
        Rope USING [Cat, Concat, Equal, ROPE];

    AdobeToolImpl: CEDAR MONITOR 
        IMPORTS AdobeCommon, AdobeTool, BasicTime, IO, Rope
        EXPORTS AdobeTool = {

        BumpNumOfDeps: PUBLIC PROC [add: AdobeCommon.EnumeratedTypes, addTo: AdobeCommon.EnumeratedTypes] = {

            IF addTo.dependentsSequence = NIL THEN {
                addTo.dependentsSequence Ź NEW[AdobeCommon.DependentsSequenceRec[5]];
                };
            FOR index: CARDINAL Ź 0, index + 1 UNTIL (index = addTo.dependentsSequence.length) DO
                IF addTo.dependentsSequence[index] = NIL THEN {
                    addTo.dependentsSequence[index] Ź add;
                    RETURN;
                    };
                ENDLOOP;

        <<Need more space>>
            {
                newDepSeq: AdobeCommon.DependentsSequence Ź NEW[AdobeCommon.DependentsSequenceRec[addTo.dependentsSequence.length + 5]];
                FOR index:CARDINAL IN [0..addTo.dependentsSequence.length) DO
                    newDepSeq[index] Ź addTo.dependentsSequence[index];
                    ENDLOOP;
                newDepSeq[addTo.dependentsSequence.length + 1] Ź add;
                addTo.dependentsSequence Ź newDepSeq;
                };

            };


        RopeFromTool: PROCEDURE [tool: AdobeOps.ToolType] RETURNS [rope: Rope.ROPE Ź NIL] = {
            SELECT tool FROM
                edit =>       {RETURN ["Edit"] };
                submit =>    {RETURN ["Submit"] };
                report =>     {RETURN ["Report"] };
                query =>     {RETURN ["Query"] };
                sort =>        {RETURN ["Sort"] };
                queryList => {RETURN ["QueryList"] };
                ENDCASE;
            };

        CountRopes: PUBLIC PROC [l: LIST OF Rope.ROPE] RETURNS [count: CARD Ź 0] ~ {
            FOR i: LIST OF Rope.ROPE Ź l, i.rest UNTIL i = NIL DO
                count Ź count + 1;
                ENDLOOP;
            RETURN[count];
            };

        SetUpEditTool: PROC [handle: AdobeCommon.Handle] = {

            x, y, w, h: CARD;
            procData: AdobeTool.CurrentButtonProcData;
            thisViewer: REF ANY Ź handle.fieldViewer.outer;
            thisSH: AdobeOps.ARSystemHandle Ź handle.systemHandle;
            thisField: AdobeCommon.EnumeratedTypes Ź NIL;
            lineIndex: INTEGER Ź 0;
            fieldHeight: CARDINAL Ź --VFonts.FontHeight[] + 2 --17;

            IF handle.fieldViewer.buttons # NIL THEN EmptyFieldViewer[handle];

            handle.currentAR Ź 0;
            handle.setContents[handle.editors[1], "0"];

            handle.fieldViewer.buttons Ź NEW[AdobeCommon.ButtonSeqObject[thisSH.fieldList.length]];

            FOR field: CARDINAL IN [0..thisSH.fieldList.length) DO
                handle.fieldViewer.buttons[field] Ź NEW[AdobeCommon.EnumeratedTypesRec];
                thisField Ź handle.fieldViewer.buttons[field];
                thisField.mainViewer Ź handle;
                thisField.boolVal Ź TRUE;
                FOR tt: AdobeOps.ToolType IN AdobeOps.ToolType DO
                    thisField.defaults[tt] Ź thisSH.fieldList[field].defaultInfo[tt].default;
                    ENDLOOP;
                procData  Ź NEW[AdobeTool.CurrentButtonProcDataRec];
                procData.h Ź handle;
                procData.e Ź handle.fieldViewer.buttons[field];
                WITH thisSH.fieldList[field] SELECT FROM
                    it: AdobeOps.EnumFIO => {
                        numSubMenus, saveKey, currentEnum: CARD Ź 0;
                        thisField.type Ź enumerated;
                        thisField.dependentsSequence Ź NEW[AdobeCommon.DependentsSequenceRec[5]];
                        IF it.field # LAST[CARD16] THEN {
                            currentSubMenu: CARD Ź 0;
                            thisField.dependentOn Ź handle.fieldViewer.buttons[it.field];
                            numSubMenus Ź CountRopes[thisField.dependentOn.allSelections[0].ropes];
                            BumpNumOfDeps[handle.fieldViewer.buttons[field], handle.fieldViewer.buttons[it.field]];
                            thisField.currentMenu Ź numSubMenus - 1;
                            thisField.allSelections Ź NEW[AdobeCommon.SelectionsSequence[numSubMenus]];

                            WITH thisSH.fieldList[it.field] SELECT FROM
                                dep: AdobeOps.EnumFIO => {
                                    --tmp-- itkd, depit, foo: CARD;
                                    did: BOOL Ź FALSE;
                                    -- tmp -- max: CARD Ź dep.possibilities[0].enumRecs.length;
                                    FOR index: CARD IN [0..dep.possibilities[0].enumRecs.length) DO
                                        did Ź FALSE;
                                        FOR itIndex: CARD IN [0..it.possibilities.length) DO
                                            -- tmp -- itkd Ź it.possibilities[itIndex].keyedDependency;
                                            -- tmp -- depit Ź dep.possibilities[0].enumRecs[index].item;
                                            IF it.possibilities[itIndex].keyedDependency = 
                                            dep.possibilities[0].enumRecs[index].item THEN {
                                                thisField.allSelections[currentSubMenu].num Ź index;
                                                -- tmp -- foo Ź it.possibilities[itIndex].enumRecs.length;
                                                FOR i: CARD IN [0..it.possibilities[itIndex].enumRecs.length) DO
                                                    thisField.allSelections[currentSubMenu].ropes Ź 
                                                    
                                                    
                                                    CONS[it.possibilities[itIndex].enumRecs[it.possibilities[itIndex].enumRecs.length 
                                                    - i - 1].tag, thisField.allSelections[currentSubMenu].ropes];
                                                    ENDLOOP;
                                                currentSubMenu Ź currentSubMenu + 1;
                                                did Ź TRUE;
                                                EXIT
                                                };
                                            ENDLOOP;
                                        IF ~did THEN {
                                            thisField.allSelections[currentSubMenu] Ź [index, LIST["Nil"]];
                                            currentSubMenu Ź currentSubMenu + 1;
                                            };
                                        ENDLOOP;
                                    };
                                ENDCASE => ERROR;
                        <<FOR index: CARD IN [0..numSubMenus) DO>>
                        <<IF currentEnum >= it.possibilities.length THEN>>
                        <<thisField.allSelections[index] _ [index, LIST["Nil"]]>>
                        <<ELSE>>
                        <<IF it.possibilities[currentEnum].keyedDependency = (saveKey + index) THEN {>>
                        <<>>
                        <<thisField.allSelections[index].num _ index;>>
                        <<FOR i: CARD IN [0..it.possibilities[currentEnum].enumRecs.length) DO>>
                        <<thisField.allSelections[index].ropes _ CONS[it.possibilities[currentEnum].enumRecs[it.possibilities[currentEnum].enumRecs.length 
                        - i - 1].tag, thisField.allSelections[index].ropes];>>
                        <<ENDLOOP;>>
                        <<currentEnum _ currentEnum + 1;>>
                        <<}>>
                        <<ELSE {>>
                        <<thisField.allSelections[index] _ [index, LIST["Nil"]];>>
                        <<};>>
                        <<ENDLOOP;>>
                            }
                        ELSE {
                            thisField.dependentOn Ź NIL;
                            thisField.currentMenu Ź 0;
                            thisField.allSelections Ź NEW[AdobeCommon.SelectionsSequence[1]];
                            thisField.allSelections[0].num Ź it.possibilities[0].enumRecs[0].item;
                            FOR index: CARD IN [0..it.possibilities[0].enumRecs.length) DO
                                thisField.allSelections[0].ropes Ź 
                                CONS[
                                it.possibilities[0].enumRecs[it.possibilities[0].enumRecs.length - index - 1].tag, 
                                thisField.allSelections[0].ropes];
                                ENDLOOP;
                            thisField.currentSelection Ź it.possibilities[0].enumRecs.length - 1;
                            };

                        thisField.button Ź handle.makeButton[thisViewer, 0, lineIndex * fieldHeight, Rope.Concat[it.name, ": "], procData, FALSE, 
                        $CurrentButtonProc, procData];
                        [x, y, w, h] Ź handle.getBoxGeometry[thisField.button];
                        thisField.controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        handle.setContents[thisField.controllerOf, "{}"];
                        thisField.boolVal Ź TRUE;
                        handle.inhibitEdits[thisField.controllerOf];
                        };
                    it: AdobeOps.ArFIO => {
                        handle.fieldViewer.buttons[field].type Ź arId;
                        handle.fieldViewer.buttons[field].button Ź handle.makeButton[thisViewer, 0, lineIndex * fieldHeight, Rope.Concat[it.name, ": "], 
                        procData, FALSE, $SubmitFieldButtonProc, procData];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[field].button];
                        handle.fieldViewer.buttons[field].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        handle.inhibitEdits[handle.fieldViewer.buttons[field].controllerOf];

                        };
                    it: AdobeOps.DateFIO => {
                        handle.fieldViewer.buttons[field].type Ź dateTime;
                        handle.fieldViewer.buttons[field].button Ź handle.makeButton[thisViewer, 0, lineIndex * fieldHeight, Rope.Concat[it.name, ": "], 
                        procData, FALSE, $SubmitFieldButtonProc, procData];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[field].button];
                        handle.fieldViewer.buttons[field].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        handle.inhibitEdits[handle.fieldViewer.buttons[field].controllerOf];

                        };
                    it: AdobeOps.NumFIO => {
                        handle.fieldViewer.buttons[field].type Ź numeric;
                        handle.fieldViewer.buttons[field].button Ź handle.makeButton[thisViewer, 0, lineIndex * fieldHeight, Rope.Concat[it.name, ": "], 
                        procData, FALSE, $SubmitFieldButtonProc, procData];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[field].button];
                        handle.fieldViewer.buttons[field].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: 400,
                            h: h,
                            border: FALSE,
                            scrollable: FALSE
                            ];
                        handle.inhibitEdits[handle.fieldViewer.buttons[field].controllerOf];

                        };
                    it: AdobeOps.FixFIO => {
                        handle.fieldViewer.buttons[field].type Ź fixedLengthString;
                        handle.fieldViewer.buttons[field].button Ź handle.makeButton[thisViewer, 0, lineIndex * fieldHeight, Rope.Concat[it.name, ": "], 
                        procData, FALSE, $SubmitFieldButtonProc, procData];
                        [x, y, w, h] Ź handle.getBoxGeometry[handle.fieldViewer.buttons[field].button];
                        handle.fieldViewer.buttons[field].controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: handle.getBoxGeometry[handle.outer].w - w - 5,
                            h: h,
                            border: FALSE,
                            scrollable: TRUE
                            ];
                    <<handle.fieldViewer.buttons[field].controllerOf _ ViewerTools.MakeNewTextViewer[>>
                    <<info:[>>
                    <<parent: thisViewer,>>
                    <<wx: handle.fieldViewer.buttons[field].button.ww+5,>>
                    <<wy: lineIndex * fieldHeight,>>
                    <<ww: handle.outer.ww - handle.fieldViewer.buttons[field].button.ww - 5,>>
                    <<wh: handle.fieldViewer.buttons[field].button.wh,>>
                    <<border: FALSE,>>
                    <<scrollable: TRUE>>
                    <<]>>
                    <<];>>
                        handle.xBoundBox[handle.fieldViewer.outer, handle.fieldViewer.buttons[field].controllerOf];
                        handle.fieldViewer.buttons[field].maxLength Ź it.maxLength;
                        handle.inhibitEdits[handle.fieldViewer.buttons[field].controllerOf];

                        };
                    it: AdobeOps.StrFIO => {
                        thisField.type Ź string;
                        thisField.button Ź handle.makeButton[thisViewer, 0, lineIndex * fieldHeight, Rope.Concat[it.name, ": "], procData, FALSE, 
                        $SubmitFieldButtonProc, procData];
                        [x, y, w, h] Ź handle.getBoxGeometry[thisField.button];
                        thisField.adjButton Ź handle.makeButton[thisViewer, x + w - --VFonts.StringWidth["<Adj>"]-- 35 -5, (lineIndex+1) * fieldHeight, 
                        "<Adj>", handle.fieldViewer.buttons[field], TRUE, $AdjustStringHeight, handle.fieldViewer.buttons[field]];
                        thisField.controllerOf Ź handle.newFieldBox[
                            parent: thisViewer,
                            x: w+5,
                            y: lineIndex * fieldHeight,
                            w: handle.getBoxGeometry[handle.outer].w - w - 5,
                            h: (h * handle.unboundFieldHeight) - 2,
                            border: FALSE,
                            scrollable: TRUE
                            ];
                        handle.xBoundBox[handle.fieldViewer.outer, thisField.controllerOf];
                    <<Containers.ChildXBound[handle.fieldViewer.outer, thisField.controllerOf];>>
                        thisField.currentHeight Ź handle.unboundFieldHeight;
                    <<thisField.stream _ ViewerIO.CreateViewerStreams[>>
                    <<name: Rope.Concat[it.name, ".stream"],>>
                    <<viewer: thisField.controllerOf,>>
                    <<editedStream: TRUE>>
                    <<].out;>>
                        lineIndex Ź lineIndex + thisField.currentHeight - 1;
                        handle.inhibitEdits[thisField.controllerOf];

                        };
                    ENDCASE;
                lineIndex Ź lineIndex + 1;
                ENDLOOP;
            };

        Report: PROCEDURE [handle: AdobeCommon.Handle, format: Rope.ROPE, v1, v2, v3: IO.Value Ź [null[]] ] = {
            handle.messageViewer.reportStream.PutF[format, v1, v2, v3];
            };

        SetEnumValue: PUBLIC PROC [handle: AdobeCommon.Handle, enum: AdobeCommon.EnumeratedTypes, val: CARD, evenIfAlready: BOOL Ź FALSE] ~ 
        {
            tmpList: LIST OF Rope.ROPE Ź enum.allSelections[enum.currentMenu].ropes;
            FOR index: CARD IN [0..val) DO
                tmpList Ź tmpList.rest;
                ENDLOOP;
            SetEnumField[handle, enum, tmpList.first, evenIfAlready];
            };

        SetEnumField: PUBLIC PROC [handle: AdobeCommon.Handle, enum: AdobeCommon.EnumeratedTypes, sel: Rope.ROPE Ź NIL, evenIfAlready: BOOL 
        Ź FALSE] ~ {
            ropeToPutIn: Rope.ROPE Ź sel;
            index: CARD Ź 0;

            IF enum.dependentOn # NIL THEN 
                enum.currentMenu Ź enum.dependentOn.currentSelection;

            IF sel = NIL OR Rope.Equal[sel, "Nil", FALSE] THEN 
                index Ź CountRopes[enum.allSelections[enum.currentMenu].ropes] - 1
            ELSE {
                tmpList: LIST OF Rope.ROPE Ź NIL;
                FOR tmpList Ź enum.allSelections[enum.currentMenu].ropes, tmpList.rest UNTIL
                tmpList = NIL OR Rope.Equal[tmpList.first, sel, FALSE] DO
                    index Ź index + 1;
                    ENDLOOP;
                IF tmpList = NIL THEN
                    RETURN;
                ropeToPutIn Ź tmpList.first;
                };
            IF ~evenIfAlready THEN 
                IF enum.currentSelection = index THEN
                    RETURN;
            IF Rope.Equal[ropeToPutIn, "Nil", FALSE] THEN ropeToPutIn Ź "";
            ropeToPutIn Ź Rope.Concat["{", ropeToPutIn.Concat["}"]];
            handle.setContents[enum.controllerOf, ropeToPutIn];
            enum.currentSelection Ź index;
            IF enum.dependentsSequence # NIL THEN
                FOR index: CARDINAL IN [0..enum.dependentsSequence.length) DO
                    IF enum.dependentsSequence[index] # NIL THEN
                        SetEnumField[handle, enum.dependentsSequence[index], "Nil"];
                    ENDLOOP;
            };

        EnableUserEdits: PUBLIC PROC [handle: AdobeCommon.Handle] = {
            IF handle.fieldViewer.buttons # NIL THEN
                FOR loop: CARDINAL IN [0..handle.fieldViewer.buttons.length) DO
                    IF handle.fieldViewer.buttons[loop].defaults[handle.tool] = NIL THEN
                    SELECT handle.fieldViewer.buttons[loop].type FROM
                        arId => NULL;
                        enumerated => handle.fieldViewer.buttons[loop].boolVal Ź FALSE;
                        ENDCASE => {
                            handle.fieldViewer.buttons[loop].boolVal Ź FALSE;
                            handle.enableEdits[handle.fieldViewer.buttons[loop].controllerOf];
                            };
                    ENDLOOP;
            };

        DisableUserEdits: PUBLIC PROC [handle: AdobeCommon.Handle] = {
            IF handle.fieldViewer.buttons # NIL THEN
                FOR loop: CARDINAL IN [0..handle.fieldViewer.buttons.length) DO
                    handle.inhibitEdits[handle.fieldViewer.buttons[loop].controllerOf];
                    handle.fieldViewer.buttons[loop].boolVal Ź TRUE;
                    ENDLOOP;
            };

        EmptyFieldViewer: PUBLIC PROC [handle: AdobeCommon.Handle] = {
            IF handle.fieldViewer.buttons # NIL THEN {
                FOR loop: CARDINAL IN [0..handle.fieldViewer.buttons.length) DO
                    handle.destroyBox[handle, handle.fieldViewer.buttons[loop].controllerOf, FALSE];
                    handle.destroyBox[handle, handle.fieldViewer.buttons[loop].adjButton, FALSE];
                    handle.destroyBox[handle, handle.fieldViewer.buttons[loop].button, FALSE];
                    ENDLOOP;
                handle.fieldViewer.buttons Ź NIL;
                handle.paintBox[handle.fieldViewer.outer, $all];
                };
            };


        ClearWindow: PUBLIC PROC [handle: AdobeCommon.Handle] ~ {
            EmptyFieldViewer[handle];
            };

        SetUpWindow: PUBLIC PROC [handle: AdobeCommon.Handle] ~ {
            nameBase: Rope.ROPE Ź NIL;
            SELECT handle.tool FROM
                edit => SetUpEditTool[handle];
                submit => AdobeTool.SetUpSubmitTool[handle];
                query => AdobeTool.SetUpQueryTool[handle];
                report => AdobeTool.SetUpReportTool[handle];
                queryList => AdobeTool.SetUpQueryListTool[handle];
                ENDCASE ;
            nameBase Ź Rope.Concat["Adobe ", RopeFromTool[handle.tool]];
            handle.setMainName[handle.outer, nameBase];
            IF handle.systemHandle # NIL THEN
                handle.setMainName[handle.outer, nameBase.Cat[" using ", handle.systemHandle.name]];
            handle.paintBox[handle.outer, $caption];
            };

        SetUpDefaults: PUBLIC PROCEDURE [handle: AdobeCommon.Handle] ~ {
            r, s: Rope.ROPE Ź NIL;
            FOR i :CARD IN [0..handle.fieldViewer.buttons.length) DO
                r Ź handle.fieldViewer.buttons[i].defaults[handle.tool];
                IF r # NIL THEN {
                    SELECT TRUE FROM
                        Rope.Equal[r, "CurrentTOD", FALSE] => handle.setContents[handle.fieldViewer.buttons[i].controllerOf, 
                        AdobeCommon.AdobeTimeRope[BasicTime.Now[]]];
                        Rope.Equal[r, "LoginName", FALSE] => handle.setContents[handle.fieldViewer.buttons[i].controllerOf, 
                        AdobeCommon.GetFullLoginName[handle]];
                        ENDCASE => handle.setContents[handle.fieldViewer.buttons[i].controllerOf, r];
                    handle.fieldViewer.buttons[i].boolVal Ź TRUE;
                    };
                ENDLOOP;
            };
        EmptyContents: PUBLIC PROCEDURE[handle: AdobeCommon.Handle] ~ {
            FOR index: CARD Ź 0, index + 1 UNTIL index = handle.fieldViewer.buttons.length DO
                handle.setContents[handle.fieldViewer.buttons[index].controllerOf, ""--, TRUE--];
                ENDLOOP;
            };

        }.