
    <<CDCellsInteractionsImpl.mesa   (part of ChipNDale)>>
        <<Copyright © 1983, 1986 by Xerox Corporation.  All rights reserved.>>
        <<Created by Christian Jacobi,   June 24, 1983 5:00 pm >>
        <<Last Edited by: Christian Jacobi, September 1, 1986 4:40:27 pm PDT>>

    DIRECTORY
        CD, 
        CDInstances,
        CDCells,
        CDCellsInteractions,
        CDDirectory,
        CDDirectoryOps,
        PopUpMenus,
        CDEvents,
        CDBasics,
        CDMarks,
        CDOps,
        CDOrient,
        CDProperties,
        CDSequencer,
        CDSequencerExtras, 
        Rope,
        TerminalIO;

    CDCellsInteractionsImpl: CEDAR PROGRAM 
        IMPORTS CDCells, CDInstances, CDDirectory, CDDirectoryOps, CDEvents, CDBasics, CDMarks, PopUpMenus, CDOps, CDOrient, CDProperties, 
        CDSequencer, CDSequencerExtras, Rope, TerminalIO
        EXPORTS CDCellsInteractions
        SHARES CD =
    BEGIN

    EventRegistration: TYPE = CDEvents.EventRegistration;

    beforeReplace: EventRegistration = CDEvents.RegisterEventType[$BeforeCellReplacement];
    afterReplace: EventRegistration = CDEvents.RegisterEventType[$AfterCellReplacement];
    pushEvent: EventRegistration = CDEvents.RegisterEventType[$AfterPush];
    popEvent: EventRegistration = CDEvents.RegisterEventType[$AfterPop];
    createEvent: EventRegistration = CDEvents.RegisterEventType[$InteractiveCreatedCell];

    fullPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from cell", "select menu entry to go back outside"];
    partialPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from cell", "replace is not possible! it would create recursion"];
    emptyPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from cell: empty cell", "cell is empty; you can not create an empty cell"];
    expandPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from expanded object"];

    expandResultKey: REF = NEW[INT];

    Init: PROC [] = {
        [] _ PopUpMenus.Entry[fullPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
        [] _ PopUpMenus.Entry[partialPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
        [] _ PopUpMenus.Entry[emptyPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
        [] _ PopUpMenus.Entry[fullPopMenu, "new cell", NIL, $new, "create a new cell; original cell is unmodified"];
        [] _ PopUpMenus.Entry[partialPopMenu, "new cell", NIL, $new, "create a new cell; original cell is unmodified"];
        [] _ PopUpMenus.Entry[fullPopMenu, "replace", NIL, $replace, "make edits permanent in all instances of cell"];
        [] _ PopUpMenus.Entry[expandPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
        [] _ PopUpMenus.Entry[expandPopMenu, "new cell this instance", NIL, $new, "create a new cell; original object is unmodified"];
        [] _ PopUpMenus.Entry[expandPopMenu, "new cell and replace all instances", NIL, $newAll, "tries to forget original object"];
        }; 

    CreateCellObject: PROC [use: CD.InstanceList, orient: CD.Orientation _ CDOrient.original] RETURNS [CD.Object] = {
        <<-- not yet included in design>>
        ob: CD.Object = CDCells.CreateEmptyCell[];
        cp: CD.CellPtr = NARROW[ob.specificRef];
        gOutR: CD.Rect = CDInstances.BoundingRectO[use]; -- coordsys of use, non oriented
        ob.size _ CDOrient.OrientedSize[CDBasics.SizeOfRect[gOutR], orient];
        cp.contents _ CDInstances.DeComposedList[use, CDBasics.BaseOfRect[gOutR], ob.size, orient];
        cp.ir _ cp.dIr _ CDInstances.BoundingRectI[cp.contents];
        cp.simplifyOn _ 50.0/MAX[ob.size.y, 1];
        RETURN [ob]
        };

    IncludeAndNameCell: PROC [design: CD.Design, cell: CD.Object, interactive: BOOL _ TRUE, allowAbort: BOOL _ FALSE] RETURNS [done: 
    BOOL] = {
        IF ~interactive THEN {
            [] _ CDDirectory.Include[design, cell];
            RETURN [done_TRUE];
            };
        <<--interactive>>
        DO 
            fiddle: BOOL _ FALSE; aborted: BOOL _ FALSE; name: Rope.ROPE;
            name _ TerminalIO.RequestRope["enter object name: "  
                ! TerminalIO.UserAbort => {aborted _ TRUE; fiddle _ TRUE; CONTINUE}
                ];
            IF aborted THEN {
                TerminalIO.WriteRope[" **name input aborted\n"];
                IF allowAbort THEN RETURN [done_FALSE];
                };
            IF Rope.IsEmpty[name] THEN {
                fiddle _ TRUE; 
                name _ "-no name";
                };
            IF Rope.Fetch[name, name.Length[]-1]='@ THEN {
                fiddle _ TRUE;
                name _ Rope.Substr[name, 0, name.Length[]-1];
                }; 
            IF CDDirectory.Include[design, cell, name, fiddle] THEN { 
                TerminalIO.WriteRopes[CDDirectory.Name[cell], " included\n"]; 
                RETURN [done_TRUE];
                };
            TerminalIO.WriteRopes[name, " does already exist\nnot accepted, please repeat\n"];
            ENDLOOP;
        };

    CreateCellSelected: PUBLIC PROC [design: CD.Design, name: Rope.ROPE _ NIL] RETURNS [done: BOOL _ FALSE, cellOb: CD.Object _ NIL] = {

        RemoveSelectedFromWorld: PROC [design: CD.Design] RETURNS [remove: CD.InstanceList] = {
            <<-- removes the selected instances from design and returns them>>
            keep: CD.InstanceList;
            [others: keep, selected: remove] _ CDInstances.SplitSelected[CDOps.InstList[design]];
            CDOps.SetInstList[design, keep];
            };

        sel: CD.InstanceList = RemoveSelectedFromWorld[design];
        inst: CD.Instance = NEW[CD.InstanceRep];
        b: CD.Rect = CDInstances.BoundingRectO[sel];
        cp: CD.CellPtr;
        inst.ob _ cellOb _ CreateCellObject[use: sel];
        cp _ NARROW[cellOb.specificRef];
        cp.name _ name;
        inst.location _ CDBasics.BaseOfRect[b];
        inst.selected _ TRUE;
        IF NOT CDBasics.NonEmpty[b] THEN {
            TerminalIO.WriteRope["no empty cell\n"]; 
            RETURN [done: FALSE, cellOb: NIL]
            };
        IF name=NIL THEN {
            IF ~IncludeAndNameCell[design: design, cell: cellOb, allowAbort: TRUE, interactive: TRUE].done THEN {
                <<--undo the command>>
                CDOps.IncludeInstanceList[design, sel, FALSE];
                RETURN [done: FALSE, cellOb: NIL]
                };
            }
        ELSE [] _ CDDirectory.Include[design, cellOb];
        CDOps.IncludeInstance[design, inst, TRUE]; -- redraw removes seletion
        [] _ CDEvents.ProcessEvent[createEvent, design, cellOb];
        RETURN [done: TRUE, cellOb: cellOb]
        };

    PushInCellInstance: PUBLIC PROC [design: CD.Design, inst: CD.Instance, convertIfNecessary: BOOL _ TRUE] RETURNS [done: BOOL _ 
    FALSE] = {

        IsCellInstance: PROC [inst: CD.Instance] RETURNS [yes: BOOL _ FALSE] = {
            <<--verbose if inst is not a cell>>
            SELECT TRUE FROM
                inst=NIL => TerminalIO.WriteRope[" no object\n"];
                inst.ob=NIL OR inst.ob.specificRef=NIL => TerminalIO.WriteRope[" bad object\n"]; 
                ISTYPE[inst.ob.specificRef, CD.CellPtr] => yes _ TRUE;
                ENDCASE => TerminalIO.WriteRopes[" object is not cell but ", CDOps.ObjectInfo[inst.ob], "\n"];
            };

        CheckRecursionForPush: PROC [design: CD.Design, ob: CD.Object] RETURNS [yes: BOOL _ FALSE] = {
            <<--Returns "pushing into ob would cause recursion">>
            FOR l: LIST OF CD.PushRec _ design.actual, l.rest WHILE l#NIL DO
                IF l.first.mightReplace#NIL AND l.first.mightReplace.ob=ob THEN RETURN [yes _ TRUE]
                ENDLOOP;
            };

        old: CD.Object _ inst.ob; --the original object; or if not a cell: the original conversion
        WHILE old#NIL AND ~CDCells.IsCell[old] AND convertIfNecessary DO
            ob2: CD.Object _ CDDirectory.ExpandComplete[old, design, design];
            IF ob2=NIL OR ob2=old THEN {TerminalIO.WriteRope["expand failed\n"]; RETURN [FALSE]};
            old _ ob2;
            CDProperties.PutProp[inst, expandResultKey, ob2];
            ENDLOOP;
        IF CDCells.IsCell[old] THEN {
            dummy: CD.Object = CDCells.CreateEmptyCell[];
            oldCp: CD.CellPtr = NARROW[old.specificRef];
            newCp: CD.CellPtr = NARROW[dummy.specificRef];
            dummyCellInst: CD.Instance;
            dummy.size _ CDBasics.highposition;
            IF CheckRecursionForPush[design, old] THEN {
                TerminalIO.WriteRopes[" recursive push into ", CDOps.ObjectInfo[old], " not possible\n"]; 
                RETURN [FALSE];
                };
            newCp^ _ oldCp^; --copies interest rect ....
            newCp.ir _ CDOrient.MapRect[
                itemInCell: oldCp.ir,
                cellSize: inst.ob.size, 
                cellInstOrient: inst.orientation, 
                cellInstPos: inst.location
                ];
            newCp.dIr _ CDOrient.MapRect[
                itemInCell: oldCp.dIr,
                cellSize: inst.ob.size, 
                cellInstOrient: inst.orientation, 
                cellInstPos: inst.location
                ];
            newCp.contents _ CDInstances.ComposedList[
                il: newCp.contents, 
                cellPos: inst.location, 
                cellSize: inst.ob.size, 
                cellOrient: inst.orientation
                ];
            dummyCellInst _ NEW[CD.InstanceRep_[
                ob: dummy, 
                selected: TRUE,
                properties: CDProperties.DCopyProps[inst.properties]
                ]];
            CDProperties.CopyProps[inst.ob.properties, dummy];
            CDOps.RemoveInstance[design, inst]; 
            design^.actual _ CONS[
                CD.PushRec[dummyCell: dummyCellInst, specific: newCp, mightReplace: inst], 
                design^.actual
                ];
            CDProperties.PutObjectProp[dummy, $dummyCell, $TRUE];
            [] _ CDEvents.ProcessEvent[pushEvent, design];
            RETURN [done _ TRUE];
            }
        };

    PopFromCell: PUBLIC PROC [design: CD.Design, m: CDCellsInteractions.Method_interactive, name: Rope.ROPE_NIL] RETURNS [done: BOOL] = 
    {
        done _ IPopFromCell[design, m, name];
        IF done THEN [] _ CDEvents.ProcessEvent[popEvent, design];
        };

    IPopFromCell: PROC [design: CD.Design, m: CDCellsInteractions.Method, name: Rope.ROPE] RETURNS [done: BOOL_FALSE] = {
        currentRect, originalRect: CD.Rect; --cd coords
        currentInst, originalInst: CD.Instance;
        currentCell, originalCell: CD.Object;
        currentCP: CD.CellPtr;
        recursive: BOOL _ FALSE;

        CheckRecursionForPop: PROC [mark: CDMarks.MarkRange] = {
            CDMarks.MarkUnMarkedInclusiveChildren[design, currentCell, mark];
            recursive _ (originalInst.ob.marked=mark);
            };

        RemoveExpandedStuff: PROC [design: CD.Design, originalInst: CD.Instance] = {
            <<--if originalInst wasn't a cell, tries to remove results of original expansion>>
            IF ~CDCells.IsCell[originalInst.ob] THEN
                WITH CDProperties.GetProp[originalInst, expandResultKey] SELECT FROM
                    ob: CD.Object => {
                        CDProperties.PutProp[originalInst, expandResultKey, NIL];
                        [] _ CDDirectoryOps.RemoveIfUnused[design, ob];
                        };
                    ENDCASE => NULL;
            };

        DoFlush: PROC [] = {
            b: BOOL _ design^.actual.first.indirectlyChanged;
            TerminalIO.WriteRope["flush\n"];
            design^.actual _ design^.actual.rest;
            design^.actual.first.indirectlyChanged _ TRUE;
            IF b THEN design^.actual.first.indirectlyChanged _ TRUE;
            CDOps.IncludeInstance[design, originalInst, FALSE];
            RemoveExpandedStuff[design, originalInst];
            };

        HackSetOwner: PROC [ob: CD.Object, design: CD.Design] = {
            CDProperties.PutObjectProp[ob, $OwnerDesign, design.reserved];
            };

    Offset: PROC [newSize, oldSize: CD.Position] RETURNS [offset: CD.Position] = {
        fakeOrigin: CD.Position; --world coordinates
        fakeOrigin _ CDOrient.MapPoint[
            pointInCell: [0, 0],
            cellSize: newSize,
            cellInstOrient: currentInst.orientation,
            cellInstPos: currentInst.location
            ].pointInWorld;
        offset _  CDOrient.DeMapPoint[
            pointInWorld: fakeOrigin,
            cellSize: oldSize,
            cellInstOrient: originalInst.orientation,
            cellInstPos: originalInst.location
            ].pointInCell;
    };

        DoReplace: PROC [] = {
            needsRep: BOOL _ FALSE;
            originalCP: CD.CellPtr _ NARROW[originalCell.specificRef];
            [] _ CDEvents.ProcessEvent[beforeReplace, design, originalCell];
            TerminalIO.WriteRope["replace\n"];
            CDProperties.CopyProps[currentCell.properties, originalCell, $Replace];
            <<--HACK for CDDirectory-->>
                HackSetOwner[originalCell, design];
            design^.actual _ design^.actual.rest;
            design^.actual.first.indirectlyChanged _ TRUE;
            needsRep _ originalRect#currentRect OR originalCP.ir#currentCP.ir OR currentCP.dIr#originalCP.dIr OR 
            originalCP.useDIr#currentCP.useDIr;
            originalCP.contents _ currentCP.contents;
            originalCP.useDIr _ currentCP.useDIr;
            originalCP.ir _ currentCP.ir;
            IF needsRep THEN { 
                oldSize: CD.Position _ originalCell.size;
                newSize: CD.Position _ CDOrient.OrientedSize[CDBasics.SizeOfRect[currentRect], originalInst.orientation];
                offset: CD.Position _ Offset[newSize, oldSize];
                originalCell.size _ newSize;
                originalCP.origin _ CDBasics.SubPoints[originalCP.origin, offset];
                IF ~originalCP.useDIr THEN 
                    originalCP.ir _ CDBasics.MoveRect[originalCP.ir, CDBasics.NegOffset[offset]];
                CDDirectory.RepositionObject[design: design, 
                    ob: originalCell, 
                    oldSize: oldSize, 
                    baseOff: offset
                    ];
                };
            originalInst.location _ currentInst.location;
            CDOps.IncludeInstance[design, originalInst, FALSE];
            [] _ CDEvents.ProcessEvent[afterReplace, design, originalCell];
            CDDirectory.PropagateChange[originalCell, design];
            CDSequencerExtras.MarkChangedIOOnly[design];
            };

        DoNewCell: PROC [interactive: BOOL_FALSE, all: BOOL_FALSE] = {
            IF all THEN TerminalIO.WriteRope["new cell and replace all instances\n"]
            ELSE TerminalIO.WriteRope["new cell for this instance\n"];
            currentInst.ob _ currentCell; 
            design^.actual _ design^.actual.rest;
            design^.actual.first.indirectlyChanged _ TRUE;
            design^.actual.first.changed _ TRUE;
            IF ~IncludeAndNameCell[design, currentCell, interactive, FALSE].done THEN ERROR;
            CDOps.IncludeInstance[design, currentInst, FALSE];
            [] _ CDEvents.ProcessEvent[createEvent, design, currentCell];
            CDDirectory.PropagateChange[currentCell, design];
            IF ~currentCP.useDIr THEN  {
                offset: CD.Position _ Offset[currentCell.size, originalCell.size];
                currentCP.ir _ CDBasics.MoveRect[currentCP.ir, CDBasics.NegOffset[offset]];
                };
            IF ~CDCells.IsCell[originalCell] AND all THEN {
                CDDirectory.ReplaceObject[design: design, old: originalCell, new: currentCell]
                };
            CDSequencer.MarkChanged[design];
            CDProperties.PutObjectProp[currentCell, $dummyCell, NIL];
            RemoveExpandedStuff[design, originalInst]
            };

        menu: PopUpMenus.Menu _ fullPopMenu;
        IF design^.actual.rest=NIL THEN {
            TerminalIO.WriteRope["not in cell\n"]; 
            RETURN [FALSE]
            };
        originalInst _ design^.actual.first.mightReplace;
        originalCell _ originalInst.ob;
        originalRect _ CDOrient.RectAt[originalInst.location, originalCell.size, originalInst.orientation]; 
        TerminalIO.WriteRopes["Pop from ", CDOps.ObjectInfo[originalCell], "\n"];
        CDInstances.DeSelectList[CDOps.InstList[design]];
        currentRect _ CDInstances.BoundingRectO[CDOps.InstList[design]]; -- design coordinates
        currentCell _ CreateCellObject[CDOps.InstList[design], originalInst.orientation];
        currentCP _ NARROW[currentCell.specificRef];
        currentCP.useDIr _ design^.actual.first.specific.useDIr;
        IF ~currentCP.useDIr THEN
            currentCP.ir _ CDOrient.DeMapRect[
                itemInWorld: design^.actual.first.specific.ir,
                cellSize: originalCell.size, 
                cellInstOrient: originalInst.orientation, 
                cellInstPos: originalInst.location
                ].itemInCell;
        currentInst _ NEW[CD.InstanceRep _ [
            ob: currentCell,
            location: CDBasics.BaseOfRect[currentRect],
            orientation: originalInst.orientation,
            selected: TRUE,
            properties: CDProperties.DCopyProps[design^.actual.first.dummyCell.properties] 
            ]];
        CDProperties.CopyProps[design^.actual.first.dummyCell.ob.properties, currentCell];
        IF m=flush OR (m=interactive AND ~design^.actual.first.changed) THEN {
            DoFlush[]; RETURN [TRUE]
            };
        IF CDBasics.NonEmpty[currentRect] THEN { 
            IF m=newcell THEN {DoNewCell[interactive: FALSE]; RETURN [TRUE]};
            CDMarks.DoWithMark[design, CheckRecursionForPop];
            IF recursive THEN { 
                TerminalIO.WriteRope[" Original cell used inside, replace not possible\n"];
                IF m=replace THEN {DoNewCell[interactive: FALSE, all: FALSE]; RETURN [TRUE]};
                menu _ partialPopMenu;
                }
            ELSE IF ~CDCells.IsCell[originalCell] THEN { 
                IF m=replace THEN {DoNewCell[interactive: FALSE, all: TRUE]; RETURN [TRUE]};
                menu _ expandPopMenu;
                }
            ELSE { --ok, normal case
                IF m=replace THEN {
                    DoReplace[]; 
                    RETURN [TRUE]
                    };
                }
            }
        ELSE {  -- empty
            TerminalIO.WriteRope[" create empty cell not possible\n"];
            IF m#interactive THEN {DoFlush[]; RETURN [TRUE]};
            menu _ emptyPopMenu;
            };
        SELECT PopUpMenus.Call[menu] FROM
            $flush => DoFlush[];
            $replace => DoReplace[];
            $new => DoNewCell[interactive: TRUE, all: FALSE];
            $newAll => DoNewCell[interactive: TRUE, all: TRUE];
            ENDCASE => {TerminalIO.WriteRope["skipped\n"]; RETURN [FALSE]};
        RETURN [TRUE];
        };

    Init[];
    END.