DIRECTORY
List, GGBasicTypes, GGBoundBox, GGGravity, GGInterfaceTypes, GGMultiGravity, GGObjects, GGOutline, GGModelTypes, GGSceneType, GGSegment, GGSegmentTypes, GGSelect, GGSequence, GGTraj, GGUtility, GList, Imager, ImagerPath, Rope;

GGObjectsImpl: CEDAR PROGRAM
IMPORTS List, GGBoundBox, GGGravity, GGMultiGravity, GGObjects, GGOutline, GGSelect, GGSegment, GGSequence, GGTraj, GGUtility, GList, Imager
EXPORTS GGObjects, GGModelTypes = BEGIN

BoundBox: TYPE = GGModelTypes.BoundBox;
BoundBoxGenerator: TYPE = REF BoundBoxGeneratorObj;
BoundBoxGeneratorObj: TYPE = GGModelTypes.BoundBoxGeneratorObj;
CurveType: TYPE = {line, bezier, conic};
EntityGenerator: TYPE = REF EntityGeneratorObj;
EntityGeneratorObj: TYPE = GGModelTypes.EntityGeneratorObj;
Joint: TYPE = REF JointObj;
JointGenerator: TYPE = REF JointGeneratorObj;
JointGeneratorObj: TYPE = GGModelTypes.JointGeneratorObj;
JointObj: TYPE = GGSegmentTypes.JointObj;
Outline: TYPE = REF OutlineObj;
OutlineObj: TYPE = GGModelTypes.OutlineObj;
OutlineDescriptor: TYPE = GGModelTypes.OutlineDescriptor;
OutlineGenerator: TYPE = REF OutlineGeneratorObj;
OutlineGeneratorObj: TYPE = GGModelTypes.OutlineGeneratorObj;
Point: TYPE = GGBasicTypes.Point;
Segment: TYPE = REF SegmentObj;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SegmentObj: TYPE = GGSegmentTypes.SegmentObj;
Sequence: TYPE = REF SequenceObj;
SequenceGenerator: TYPE = GGModelTypes.SequenceGenerator;
SequenceObj: TYPE = GGModelTypes.SequenceObj;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceGenerator: TYPE = REF SliceGeneratorObj;
SliceGeneratorObj: TYPE = GGModelTypes.SliceGeneratorObj;
Traj: TYPE = REF TrajObj;
TrajEnd: TYPE = GGModelTypes.TrajEnd; -- {lo, hi};
TrajGenerator: TYPE = REF TrajGeneratorObj;
TrajGeneratorObj: TYPE = GGModelTypes.TrajGeneratorObj;
TrajObj: TYPE = GGModelTypes.TrajObj;
Vector: TYPE = GGBasicTypes.Vector;

GargoyleData: TYPE = GGInterfaceTypes.GargoyleData;

SceneRef: TYPE = REF SceneObj;
SceneObj: PUBLIC TYPE = GGSceneType.SceneObj;

NotYetImplemented: PUBLIC SIGNAL = CODE;
Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = CODE;
fillColor: PUBLIC Imager.Color _ Imager.MakeGray[0.5];

DeleteSequence: PUBLIC PROC [seq: Sequence, scene: SceneRef] RETURNS [oldOutline: Outline, newOutlines: LIST OF Outline] = {

oldOutline _ GGOutline.OutlineOfTraj[seq.traj];
SELECT seq.traj.role FROM
hole => {
smallerOutline: Outline;
newOutlines _ OutlinesOfTrajMinusSequence[seq];
smallerOutline _ OutlineMinusHole[oldOutline, seq.traj];
AddOutline[scene, smallerOutline, -1];
AddOutlinesToScene[newOutlines, scene]; -- put the deflated holes on top.
newOutlines _ CONS[smallerOutline, newOutlines];
};
open => {
newOutlines _ OutlinesOfTrajMinusSequence[seq];
AddOutlinesToScene[newOutlines, scene];
};
fence => {
fenceParts, freedHoles: LIST OF Outline;
fenceParts _ OutlinesOfTrajMinusSequence[seq];
AddOutlinesToScene[fenceParts, scene];
freedHoles _ OutlinesFromOutlineExcept[oldOutline, seq.traj];
AddOutlinesToScene[freedHoles, scene];
newOutlines _ AppendOutlines[fenceParts, freedHoles];
};
ENDCASE => ERROR;
DeleteOutline[scene, oldOutline];
};

AddOutlinesToScene: PROC [outlines: LIST OF Outline, scene: SceneRef] = {
FOR list: LIST OF Outline _ outlines, list.rest UNTIL list = NIL DO
AddOutline[scene, list.first, -1];
ENDLOOP;
};

OutlinesOfTrajMinusSequence: PROC [seq: Sequence] RETURNS [newOutlines: LIST OF Outline] = {
diff, wholeTraj: Sequence;
IF GGSequence.IsComplete[seq] THEN RETURN[NIL];
wholeTraj _ GGSequence.CreateComplete[seq.traj];
IF NOT GGSequence.IsEmpty[seq] AND seq.traj.segCount=1 THEN GGSegment.OpenUpSegment[GGTraj.FetchSegment[seq.traj, 0]]; -- cyclic segments must become acyclic
diff _ GGSequence.Difference[wholeTraj, seq];
[newOutlines] _ GroupPieces[diff];
};

GroupPieces: PROC [seq: Sequence] RETURNS [newOutlines: LIST OF Outline] = {
seqGen: SequenceGenerator;
newTraj: Traj;
newOutline, oldOutline: Outline;
runCount: NAT;
joint: Joint;
newOutlines _ NIL;
oldOutline _ GGOutline.OutlineOfTraj[seq.traj];
[seqGen, runCount] _ GGSequence.RunsInSequence[seq];
FOR run: Sequence _ GGSequence.NextSequence[seqGen], GGSequence.NextSequence[seqGen] UNTIL run = NIL DO
IF run.segCount=0 THEN LOOP; -- special case needed by BS command.
[newTraj] _ GGTraj.CopyTrajFromRun[run];
joint _ GGTraj.FetchJoint[newTraj, 0];
joint.TselectedInFull.active _ FALSE;
joint _ GGTraj.FetchJoint[newTraj, GGTraj.HiJoint[newTraj]];
joint.TselectedInFull.active _ FALSE;
newTraj.role _ open;
newOutline _ GGOutline.CreateOutline[newTraj, oldOutline.lineEnds, oldOutline.fillColor];
newOutlines _ CONS[newOutline, newOutlines];
ENDLOOP;
};
OutlinesFromOutlineExcept: PROC [outline: Outline, except: Traj] RETURNS [newOutlines: LIST OF Outline] = {
trajGen: TrajGenerator;
newTraj: Traj;
newOutline: Outline;
ptr: LIST OF Outline;
trajGen _ GGOutline.TrajsInOutline[outline];
[newOutlines, ptr] _ StartOutlineList[];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
IF traj = except THEN LOOP;
newTraj _ GGTraj.CopyTraj[traj];
newOutline _ GGOutline.CreateOutline[newTraj, outline.lineEnds, outline.fillColor];
[newOutlines, ptr] _ AddOutlineToList[newOutline, newOutlines, ptr];
ENDLOOP;
};

OutlineMinusHole: PROC [outline: Outline, except: Traj] RETURNS [newOutline: Outline] = {
holeGen: TrajGenerator;
newTraj, fence: Traj;
fence _ GGOutline.FenceOfOutline[outline];
newTraj _ GGTraj.CopyTraj[fence];
newOutline _ GGOutline.CreateOutline[newTraj, outline.lineEnds, outline.fillColor];
holeGen _ GGOutline.HolesOfOutline[outline];
FOR hole: Traj _ GGObjects.NextTraj[holeGen], GGObjects.NextTraj[holeGen] UNTIL hole = NIL DO
IF hole = except THEN LOOP;
newTraj _ GGTraj.CopyTraj[hole];
newOutline _ GGOutline.AddHole[newOutline, newTraj];
ENDLOOP;
};

AppendOutlines: PROC [list1, list2: LIST OF Outline] RETURNS [result: LIST OF Outline] = {
pos: LIST OF Outline;
newCell: LIST OF Outline;
IF list1 = NIL THEN RETURN[list2];
result _ CONS[list1.first, NIL];
pos _ result;
FOR l: LIST OF Outline _ list1.rest, l.rest UNTIL l = NIL DO
newCell _ CONS[l.first, NIL];
pos.rest _ newCell;
pos _ newCell;
ENDLOOP;
pos.rest  _ list2;
};

StartOutlineList: PROC [] RETURNS [entityList, ptr: LIST OF Outline] = {
ptr _ entityList _ NIL;
};

AddOutlineToList: PROC [entity: Outline, entityList, ptr: LIST OF Outline] RETURNS [newList, newPtr: LIST OF Outline] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};


DeleteOutline: PUBLIC PROC [scene: SceneRef, outline: Outline] =  {
DeleteEntity[scene, outline];
};


CreateScene: PUBLIC PROC [] RETURNS [scene: SceneRef] = {
scene  _ NEW[SceneObj _ [] ];
};

AddOutline: PUBLIC PROC [scene: SceneRef, outline: Outline, priority: INT _ -1] = {
AppendEntity[scene, outline];
};

AddSlice: PUBLIC PROC [scene: SceneRef, slice: Slice, priority: INT _ -1] = {
AppendEntity[scene, slice];
};

AddEntities: PUBLIC PROC [scene: SceneRef, entities: LIST OF REF ANY] = {

FOR list: LIST OF REF ANY _ entities, list.rest UNTIL list = NIL DO
AppendEntity[scene, list.first];
ENDLOOP;

};

AddEntity: PUBLIC PROC [scene: SceneRef, entity: REF ANY, priority: INT] = {
IF priority = -1 THEN AppendEntity[scene, entity]
ELSE IF priority = 0 THEN {
scene.ptrValid _ FALSE;
scene.entities _ CONS[entity, scene.entities];
};
};

AppendEntity: PROC [scene: SceneRef, entity: REF ANY] = {
IF NOT scene.ptrValid THEN { -- restore ptr
IF scene.entities=NIL THEN scene.ptr _ NIL ELSE
FOR list: LIST OF REF ANY _ scene.entities, list.rest UNTIL list=NIL DO
scene.ptr _ list;
ENDLOOP;
scene.ptrValid _ TRUE;
};
[scene.entities, scene.ptr] _ GGUtility.AddEntity[entity, scene.entities, scene.ptr];
};

DeleteEntity: PUBLIC PROC [scene: SceneRef, entity: REF ANY] = {
scene.ptrValid _ FALSE;
scene.entities _ List.DRemove[entity, scene.entities];
};

undeleteSize: INT _ 20; -- temporarily hardwired size of undelete stack
PushScene: PUBLIC PROC [scene: SceneRef] = {
CopyList: PROC [list: LIST OF REF ANY] RETURNS [copy: LIST OF REF ANY] = {
entityList, ptr: LIST OF REF ANY;
[entityList, ptr] _ GGUtility.StartList[];
FOR entity: LIST OF REF ANY _ list, entity.rest UNTIL entity=NIL DO
[entityList, ptr] _ GGUtility.AddEntity[entity.first, entityList, ptr];
ENDLOOP;
copy _ entityList;
};
tList: LIST OF LIST OF REF ANY;
scene.oldEntities _ CONS[
CopyList[scene.entities],
scene.oldEntities];
tList _ scene.oldEntities;
FOR index: INT IN [0..undeleteSize) DO IF tList#NIL THEN tList _ tList.rest; ENDLOOP;
IF tList#NIL THEN tList.rest _ NIL; -- truncate the undelete stack
};

EmptySceneStack: PUBLIC PROC [scene: SceneRef] RETURNS [BOOL] = {
RETURN[scene.oldEntities=NIL OR scene.oldEntities.first=NIL];
};

PopScene: PUBLIC PROC [scene: SceneRef] = {
IF EmptySceneStack[scene] THEN ERROR;
scene.entities _ scene.oldEntities.first;
scene.oldEntities _ scene.oldEntities.rest;
};

MergeScenes: PUBLIC PROC [back: SceneRef, front: SceneRef] RETURNS [combined: SceneRef] = {
combined _ NEW[SceneObj _ []];
combined.entities _ NARROW[GList.Append[back.entities, front.entities]];
};

UpOne: PUBLIC PROC [scene: SceneRef, entity: REF ANY] = {
ExchangeWithNextEntity: PROC [scene: SceneRef, entity: REF ANY] = {
previous, next: LIST OF REF ANY _ NIL;
FOR list: LIST OF REF ANY _ scene.entities, list.rest UNTIL list = NIL DO
IF list.first=entity THEN { -- exchange this entity with its next neighbor
next _ list.rest;
IF next=NIL THEN RETURN; -- entity already at end (i.e. top) of list
list.rest _ next.rest;  next.rest _ list;
IF previous#NIL THEN previous.rest _ next ELSE scene.entities _ next;
}
ELSE previous _ list;
ENDLOOP;
};
trueEntity: REF ANY;
WITH entity SELECT FROM
slice: Slice => trueEntity _ slice;
outline: Outline => trueEntity _ outline;
traj: Traj => trueEntity _ GGOutline.OutlineOfTraj[traj];
seq: Sequence => trueEntity _ GGOutline.OutlineOfTraj[seq.traj];
ENDCASE => ERROR;
ExchangeWithNextEntity[scene, trueEntity];
};

DownOne: PUBLIC PROC [scene: SceneRef, entity: REF ANY] = {
ExchangeWithPreviousEntity: PROC [scene: SceneRef, entity: REF ANY] = {
preprev, previous: LIST OF REF ANY _ NIL;
FOR list: LIST OF REF ANY _ scene.entities, list.rest UNTIL list=NIL DO
IF list.first=entity THEN { -- exchange this entity with its previous neighbor
SELECT TRUE FROM
preprev=NIL AND previous=NIL => RETURN; -- entity already on bottom 
preprev=NIL AND previous#NIL => { -- special case. Second from bottom
previous.rest _ list.rest;  list.rest _ previous; scene.entities _ list; RETURN;
};
preprev#NIL AND previous=NIL => ERROR; -- Assert: can't happen
preprev#NIL AND previous#NIL => { -- usual case. Exchange list elements
previous.rest _ list.rest;  list.rest _ previous;  preprev.rest _ list; RETURN;
};
ENDCASE => ERROR; -- Assert: can't happen
}
ELSE { preprev _ previous;  previous _ list; };
ENDLOOP;
};
trueEntity: REF ANY;
WITH entity SELECT FROM
slice: Slice => trueEntity _ slice;
outline: Outline => trueEntity _ outline;
traj: Traj => trueEntity _ GGOutline.OutlineOfTraj[traj];
seq: Sequence => trueEntity _ GGOutline.OutlineOfTraj[seq.traj];
ENDCASE => ERROR;
ExchangeWithPreviousEntity[scene, trueEntity];
};


TopLevelEntitiesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [entityGenerator: EntityGenerator] =  {
entityGenerator _ NEW[EntityGeneratorObj _ [
list: scene.entities,
countValid: FALSE,
count: 0
]];
};

NextEntity: PUBLIC PROC [g: EntityGenerator] RETURNS [next: REF ANY] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};

EntityCount: PUBLIC PROC [g: EntityGenerator] RETURNS [count: NAT] = {
IF g.countValid THEN RETURN[g.count];
count _ 0;
FOR list: LIST OF REF ANY _ g.list, list.rest UNTIL list = NIL DO
count _ count + 1;
ENDLOOP;
};

IsTopLevel: PUBLIC PROC [entity: REF ANY] RETURNS [BOOL] = {
WITH entity SELECT FROM
slice: Slice => RETURN[slice.parent = NIL];
outline: Outline => RETURN[outline.parent = NIL OR outline.parent.parent = NIL];
traj: Traj => RETURN[traj.parent.parent = NIL OR traj.parent.parent.parent = NIL];
seq: Sequence => RETURN[IsTopLevel[seq.traj.parent]];
ENDCASE => ERROR;
};

TrajsInScene: PUBLIC PROC [scene: SceneRef] RETURNS [trajGen: TrajGenerator] =  {
list: LIST OF Traj _ ListTrajsInScene[scene];
trajGen _ NEW[TrajGeneratorObj _ [
list: list
]];
};

OutlinesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [outlineGen: OutlineGenerator] =  {
list: LIST OF Outline _ ListOutlinesInScene[scene];
outlineGen _ NEW[OutlineGeneratorObj _ [
list: list
]];
};


NextTraj: PUBLIC PROC [g: TrajGenerator] RETURNS [next: Traj] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};

NextOutline: PUBLIC PROC [g: OutlineGenerator] RETURNS [next: Outline] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};

SlicesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [sliceGen: SliceGenerator] = {
list: LIST OF Slice _ ListSlicesInScene[scene];
sliceGen _ NEW[SliceGeneratorObj _ [
list: list
]];
};

NextSlice: PUBLIC PROC [g: SliceGenerator] RETURNS [next: Slice] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};

BoundBoxesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBoxGen: BoundBoxGenerator] = {
list: LIST OF BoundBox _ ListBoxesInScene[scene];
bBoxGen _ NEW[BoundBoxGeneratorObj _ [
list: list
]];
};

TightBoxesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBoxGen: BoundBoxGenerator] = {
list: LIST OF BoundBox _ ListTightBoxesInScene[scene];
bBoxGen _ NEW[BoundBoxGeneratorObj _ [
list: list
]];
};

NextBox: PUBLIC PROC [g: BoundBoxGenerator] RETURNS [next: BoundBox] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};
ListBoxesInScene: PROC [scene: SceneRef] RETURNS [allBoxes: LIST OF BoundBox] = {
thisBox: BoundBox;
allBoxes _ NIL;
FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO
WITH entities.first SELECT FROM
slice: Slice => {
thisBox _ slice.class.getBoundBox[slice, NIL];
allBoxes _ CONS[thisBox, allBoxes];
};
outline: Outline => {
thisBox _ outline.class.getBoundBox[outline, NIL];
allBoxes _ CONS[thisBox, allBoxes];
};
ENDCASE => ERROR;
ENDLOOP;
};

ListTightBoxesInScene: PROC [scene: SceneRef] RETURNS [allBoxes: LIST OF BoundBox] = {
thisBox: BoundBox;
allBoxes _ NIL;
FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO
WITH entities.first SELECT FROM
slice: Slice => {
thisBox _ slice.class.getTightBox[slice, NIL];
allBoxes _ CONS[thisBox, allBoxes];
};
outline: Outline => {
thisBox _ outline.class.getTightBox[outline, NIL];
allBoxes _ CONS[thisBox, allBoxes];
};
ENDCASE => ERROR;
ENDLOOP;
};


BoundBoxOfScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBox: BoundBox] = {
bbGen: GGModelTypes.BoundBoxGenerator _ BoundBoxesInScene[scene];
bBox _ GGBoundBox.BoundBoxOfBoxes[bbGen.list];  -- cheating to go inside generator
};

TightBoxOfScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBox: BoundBox] = {
bbGen: GGModelTypes.BoundBoxGenerator _ TightBoxesInScene[scene];
bBox _ GGBoundBox.BoundBoxOfBoxes[bbGen.list];  -- cheating to go inside generator
};

AppendTrajs: PUBLIC PROC [l1, l2: LIST OF Traj] RETURNS [result: LIST OF Traj] = {
z: LIST OF Traj _ l1;
IF z = NIL THEN RETURN[l2];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ l2;
RETURN[l1];
};

AppendBoxes: PUBLIC PROC [l1, l2: LIST OF BoundBox] RETURNS [result: LIST OF BoundBox] = {
z: LIST OF BoundBox _ l1;
IF z = NIL THEN RETURN[l2];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ l2;
RETURN[l1];
};

ListTrajsInScene: PUBLIC PROC [scene: SceneRef] RETURNS [allTrajs: LIST OF Traj] = {
allTrajs _ NIL;
FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO
WITH entities.first SELECT FROM
slice: Slice => {
};
outline: Outline => {
FOR trajs: LIST OF Traj _ outline.children, trajs.rest UNTIL trajs = NIL DO
allTrajs _ CONS[trajs.first, allTrajs];
ENDLOOP;
};
ENDCASE => ERROR;
ENDLOOP;
};

ListOutlinesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [allOutlines: LIST OF Outline] = {
allOutlines _ NIL;
FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO
WITH entities.first SELECT FROM
slice: Slice => {
};
outline: Outline => {
allOutlines _ CONS[outline, allOutlines];
};
ENDCASE => ERROR;
ENDLOOP;
};

ListSlicesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [allSlices: LIST OF Slice] = {
allSlices _ NIL;
FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO
WITH entities.first SELECT FROM
slice: Slice => {
allSlices _ CONS[slice, allSlices];
};
outline: Outline => {};
ENDCASE => ERROR;
ENDLOOP;
};

ListTrajsInOutline: PROC [outline: Outline] RETURNS [trajList: LIST OF Traj] =  {
trajList _ outline.children;
};

ListHolesOfOutline: PROC [outline: Outline] RETURNS [trajList: LIST OF Traj] =  {
trajList _ outline.children.rest;
};

ListSegmentsInTraj: PROC [traj: Traj] RETURNS [segList: LIST OF Segment] = {
segList _ NIL;
FOR i: NAT DECREASING IN [0..GGTraj.HiSegment[traj]] DO
segList _ CONS[GGTraj.FetchSegment[traj, i], segList];
ENDLOOP;
};

NearestTrajectoryInScene: PUBLIC PROC [scene: SceneRef, worldPt: Point, gargoyleData: GargoyleData] RETURNS [traj: Traj] = {
feature: GGModelTypes.FeatureData;
resultPoint: Point;
sceneObjects: GGInterfaceTypes.TriggerBag;
sceneObjects _ NARROW[gargoyleData.hitTest.sceneTriggerBag];
[resultPoint, feature] _ GGMultiGravity.StrictDistance[worldPt, gargoyleData.hitTest.criticalR, GGGravity.emptyObjectBag, sceneObjects, gargoyleData];
RETURN[IF feature=NIL OR feature.type=slice THEN NIL ELSE NARROW[feature.shape, Sequence].traj];
};


SaveSelections: PUBLIC PROC [scene: SceneRef] = {
scene.savedSelected.normal _ List.Append[scene.selected.normal, NIL];
};

RestoreSelections: PUBLIC PROC [scene: SceneRef] = {
normalSelectedList: LIST OF REF ANY _ scene.savedSelected.normal;
GGSelect.DeselectAll[scene, normal];  -- get rid of any transient selections
FOR list: LIST OF REF ANY _ normalSelectedList, list.rest UNTIL list = NIL DO
WITH list.first SELECT FROM
cD: SliceDescriptor => GGSelect.SelectSlice[cD.slice, cD.parts, scene, normal];
oD: OutlineDescriptor => GGSelect.SelectOutline[oD.slice, oD.parts, scene, normal];
ENDCASE => ERROR;
ENDLOOP;
};

GetSelections: PUBLIC PROC [scene: SceneRef, selectClass: GGSegmentTypes.SelectionClass] RETURNS [selected: LIST OF REF ANY] = {
SELECT selectClass FROM
normal => selected _ scene.selected.normal;
hot => selected _ scene.selected.hot;
active => selected _ scene.selected.active;
ENDCASE => ERROR;
};

END.
ŽGGObjectsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last edited by Bier on January 27, 1987 1:06:17 am PST
Contents:  The procedural interface to the Gargoyle object modeler.
Stone, August 5, 1985 4:13:18 pm PDT
Pier, December 11, 1986 4:59:23 pm PST
Kurlander August 28, 1986 6:15:29 pm PDT

The scene object has a list of entities, a "finger" REF (ptr) to the end of the list for quick appends, and a BOOL which is TRUE when ptr in fact points to the end.  ptr MUST BE invalidated by setting ptrValid _ FALSE whenever a remove or delete is done from the entities.  Any use of ptr must check ptrValid and recalculate its value if it is invalid.  The only place that happens in here is in AppendEntity.
entities are kept in back to front order so that the list can be painted with a single traversal.
Destroying and Modifying Sequences. Sequences are created via GGSequence.
Takes the trajectory of which seq is a part.  What is the role of this trajectory?
If role = hole, then create a new outline (and new trajectories), identical to seq.traj.outline, but without the hole.  The index corresponding to this outline will be 0.  Make separate outlines corresponding to those parts of the hole which were not deleted.  The index for each of these outlines will be the segment number, in the original hole traj, of segment 0 in the new outline. The old outline (and all of its parts) is now obsolete.
If role = fence, then create new outlines and new trajectories for all of the parts of seq.traj.outline which remain.  The index for each of these outlines will be the segment number, in the original fence traj, of segment 0 in the new outline.  The old outline (and all of its parts) is now obsolete.
If role = open, then create new outlines and new trajectories for all of the parts of seq.traj which remain.  The index for each of these outlines will be the segment number, in the original fence traj, of segment 0 in the new outline.  The old outline is obsolete.
The parts of the hole become top level parts of the scene.
The rest of the outline is replaced by a single new outline.
Parts of the trajectory are in the sequence.  Take the segments which remain, and all the joints that they touch.
Make sure the end joints of the run are not active selected.  They can be normal or hot selected.  This is important for the delete operation.

Non-destructive (copies the first list).
Creating, Modifying and Destroying  Outlines
scene.ptrValid _ FALSE;
scene.entities _ GGUtility.DeleteEntityFromList[outline, scene.entities];

Building and Destroying Clusters

MakeCluster: PUBLIC PROC [entities: LIST OF REF ANY] RETURNS [newCluster: Slice];
BreakCluster: PUBLIC PROC [oldCluster: Slice] RETURNS [entities: LIST OF REF ANY];
Creating, Modifying Scenes
Add the given outline to the scene with the given priority (the lower the priority number, the closer the outline is to the front.  If priority is -1, the outline will be the rear-most entity.  If an entity with the given priority already exists, all priority numbers greater than or equal to it will be increased by one. 
Like AddOutline, but adds a slice.
Adds the entities, assumed to be in back to front order, to the scene.
FOR list: LIST OF REF ANY _ entities, list.rest UNTIL list = NIL DO
scene.entities _ CONS[list.first, scene.entities];
ENDLOOP;
Adds the entity to the scene.  If priority = 0, it becomes the rearmost entity.  IF priority = -1, it becomes the frontmost entity.
Removes the named entity from the scene.  If the entity is not on the list, no action is taken.
Makes a copy of the current scene list, and pushes it on a stack.  For use in Undelete.
Lets scene be the most recently pushed scene, that has not yet been popped.
combined.entities _ NARROW[GList.Append[front.entities, back.entities]];
Moves the named entity one step closer to the front in the priority order.
Moves the named entity one step closer to the back in the priority order.

Browsing the Scene Hierarchy -- Generators
Generates all of the outlines and slices in the scene.
list: LIST OF REF ANY _ List.Reverse[scene.entities]; -- KAP October 22, 1986
Returns the unique fence trajectory of outline.
Generates all of the trajectories in the scene, wherever they occur.
Generates all of the outlines in the scene, wherever they occur.

Bounding Boxes
Generates all of the boundBoxes in the scene, whereever they occur.
Generates all of the boundBoxes in the scene, whereever they occur.

box is in local IP coordinates
box is in local IP coordinates

Utility Routines

Destructive append.
Destructive append.
Doesn't work on Gargoyle slices.
Hit Testing -- Outline-Specific routines.  These should go away when Outlines become Slices.

Selections

this is a trick to make a copy of the list quickly. The list will be modified in place later on.

Pier, December 5, 1985 10:13:59 am PST
changes to: removed camera from definitions
Bier, January 7, 1986 4:42:32 pm PST
changes to: Reordered procedures to match GGObjects.
ΚZ˜
code™Kšœ
Οm
œ1™<K™6K™CK™$K™&K™(—K™š
Οk	˜	Kš
œβ
˜β
K˜—šΟn
œžœ
ž˜Kšžœ…
˜Œ
Kšžœž˜'—˜Kšœ
žœ˜'Kšœžœžœ˜3Kšœžœ%˜?Kšœžœ˜(Kšœžœžœ˜/Kšœžœ#˜;Kšœžœžœ
˜Kšœžœžœ˜-Kšœžœ"˜9Kšœ
žœ˜)Kšœ	žœžœ˜Kšœžœ˜+Kšœžœ"˜9Kšœžœžœ˜1Kšœžœ$˜=Kšœžœ˜!Kšœ	žœžœ˜Kšœžœ!˜7Kšœžœ˜-Kšœ
žœžœ
˜!Kšœžœ"˜9Kšœ
žœ˜-Kšœžœ˜!Kšœžœ ˜5Kšœžœžœ˜-Kšœžœ"˜9Kšœžœžœ	˜Kšœ	žœΟc˜2Kšœžœžœ˜+Kšœžœ!˜7Kšœ	žœ˜%Kšœžœ˜#K˜Kšœžœ!˜3K˜šœΤ
žœΐ
™™K™a—Kšœ
žœžœ
˜Kšœ
žœ˜-—K˜KšŸœžœ
žœžœ
˜(Kš
Ÿœžœ
žœžœžœ
˜/Kšœžœ%˜6K˜Kš
œI™IšŸœžœ
žœ"žœ$žœ
žœ
˜|K™RK™ΉK™­K™‰K˜Kš
œ/˜/šžœž˜š
œ	˜	Kš
œ˜K™:š
œ/˜/Kš
Οb<™<—Kš
œ8˜8Kš
œ&˜&Kšœ( !˜IKšœžœ˜0K˜—š
œ	˜	Kš
œ/˜/Kš
œ'˜'K˜—š
œ
˜
Kšœžœ
žœ	˜(Kš
œ.˜.Kš
œ&˜&Kš
œ=˜=Kš
œ&˜&Kš
œ5˜5K˜—Kšžœžœ
˜—Kš
œ!˜!K˜K˜šŸœžœžœ
žœ˜Išžœžœ
žœžœžœ
ž˜CKš
œ"˜"—Kšžœ
˜K˜K˜—š
Ÿœžœžœžœ
žœ
˜\Kš
œ˜šžœžœ
žœ
žœ˜/K™q—Kš
œ0˜0Kšžœ
žœ1žœ< &˜
Kš
œ-˜-Kš
œ"˜"K˜K˜—š
Ÿœžœžœžœ
žœ
˜LKš
œ˜Kš
œ˜Kš
œ ˜ Kšœ
žœ
˜K˜
Kšœžœ
˜Kš
œ/˜/Kš
œ4˜4šžœRžœžœ
ž˜gKšžœžœ
žœ %˜BKš
œ(˜(š
‘Ž
™Ž
Kš
œ&˜&Kšœžœ
˜%Kš
œ<˜<Kšœžœ
˜%—Kš
œ˜Kš
œY˜YKšœžœ˜,Kšžœ
˜—K˜K™—š
Ÿœžœ"žœžœ
žœ
˜kK˜Kš
œ˜Kš
œ˜Kšœžœ
žœ	˜Kš
œ,˜,Kš
œ(˜(šžœGžœžœ
ž˜]Kšžœžœ
žœ
˜Kš
œ ˜ Kš
œS˜SKš
œD˜DKšžœ
˜—K˜K˜—šŸœžœ"žœ˜YK˜Kš
œ˜Kš
œ*˜*Kš
œ!˜!Kš
œS˜SKš
œ,˜,šžœGžœžœ
ž˜]Kšžœžœ
žœ
˜Kš
œ ˜ Kš
œ4˜4Kšžœ
˜—K˜K˜—šŸœžœžœ
žœ
žœ
žœ
žœ
˜ZK™(Kšœžœ
žœ	˜Kšœ	žœ
žœ	˜Kšžœ	žœ
žœ
žœ˜"Kšœ	žœžœ˜ Kš
œ
˜
šžœžœ
žœžœžœ
ž˜<Kšœ
žœ
žœ˜Kš
œ˜Kš
œ˜Kšžœ
˜—Kš
œ˜K˜K˜—š
Ÿœžœžœžœ
žœ
˜HKšœžœ
˜K˜K˜—šŸœžœ$žœ
žœ
žœžœ
žœ
˜yšžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜——Kšœ$‘™,K˜šŸ
œžœ
žœ)˜CKšœžœ
™Kš
œI™IKš
œ˜K˜K™—Kšœ‘™ K™KšŸœžœžœ
žœ
žœ
žœžœ™QKšŸœžœžœžœ
žœ
žœ
žœ™RK˜Kšœ‘™K˜šŸœžœ
žœžœ˜9Kšœ	žœ˜K˜K˜—šŸ
œžœ
žœ/žœ
˜SKš
œΒ™ΒK˜K˜K˜—šŸœžœ
žœ+žœ
˜MKš
œ"™"Kš
œ˜K˜K˜—šŸœžœ
žœžœ
žœ
žœ
žœ˜IK™FK˜šžœžœ
žœ
žœ
žœžœžœ
ž˜CKš
œ ˜ Kšžœ
˜—K˜šžœžœ
žœ
žœ
žœžœžœ
ž™CKšœžœ™2Kšžœ
™—K˜K˜—šŸ	œžœ
žœžœ
žœžœ˜LKš
œƒ
™ƒ
Kšžœžœ˜1šžœ
žœžœ˜Kšœžœ
˜Kšœžœ˜.K˜—K˜K˜—šŸœžœžœ
žœ˜9šžœ
žœžœ ˜+Kš	žœžœ
žœ
žœ
ž˜/šžœžœ
žœ
žœ
žœžœžœ
ž˜GK˜Kšžœ
˜—Kšœžœ
˜Kš
œ˜—Kš
œU˜UK˜K˜—š
Ÿœžœ
žœžœ
žœ˜@K™_Kšœžœ
˜Kš
œ6˜6K˜K˜—Kšœžœ /˜GšŸ	œžœ
žœ˜,K™WšŸœžœžœ
žœ
žœ
žœžœžœ
žœ
žœ
žœ˜JKš	œžœ
žœ
žœ
žœ
˜!Kš
œ*˜*šžœ	žœ
žœ
žœ
žœžœžœ
ž˜CKš
œG˜GKšžœ
˜—Kš
œ˜K˜—Kšœžœ
žœ
žœ
žœ
žœ
˜šœžœ
˜Kš
œ˜Kš
œ˜—Kš
œ˜Kšžœžœ
žœžœ
žœžœ
žœžœ
˜UKš	žœžœ
žœžœ ˜BK˜K˜—š
Ÿœžœ
žœžœžœ˜AKšžœžœ
žœžœ˜=K˜K˜—šŸœžœ
žœ˜+K™KKšžœžœ
žœ
˜%Kš
œ)˜)Kš
œ+˜+K˜K˜—šŸœžœ
žœ#žœ˜[Kšœžœ˜Kšœžœ.™HKšœžœ.˜HK˜K˜—š
Ÿœžœ
žœžœ
žœ˜9K™JšΠbnœžœžœ
žœ˜CKšœžœ
žœ
žœ
žœžœ
˜&šžœžœ
žœžœžœ
ž˜Išžœžœ .˜JK˜Kš	žœžœ
žœ
žœ +˜DKš
œ)˜)Kšžœ
žœ
žœžœ˜EK˜
—Kšžœ˜Kšžœ
˜—K˜—Kšœžœ
žœ
˜šžœžœ
ž˜Kš
œ#˜#Kš
œ)˜)Kš
œ9˜9Kš
œ@˜@Kšžœžœ
˜—Kš
œ*˜*K˜K˜—š
Ÿœžœ
žœžœ
žœ˜;K™IšŸœžœžœ
žœ˜GKšœžœ
žœ
žœ
žœžœ
˜)šžœžœ
žœ
žœ
žœžœžœ
ž˜Gšžœžœ 2˜Nšžœ
žœ
ž˜Kš
œžœ
žœ
žœžœ ˜Dšœžœ
žœ
žœ #˜EKšœIžœ
˜PK˜—Kš
œžœ
žœ
žœžœ ˜>šœžœ
žœ
žœ %˜GKšœHžœ
˜OKš
œ˜—Kšžœžœ ˜)—K˜
—Kšžœ+˜/Kšžœ
˜—K˜—Kšœžœ
žœ
˜šžœžœ
ž˜Kš
œ#˜#Kš
œ)˜)Kš
œ9˜9Kš
œ@˜@Kšžœžœ
˜—Kš
œ.˜.K˜K˜—K™Kšœ ‘
™*K˜šŸœžœ
žœžœ(˜fK™6Kš	œžœ
žœ
žœ
žœ8™Mšœžœ˜,Kš
œ˜Kšœžœ
˜K˜K˜—K˜K˜—šŸ
œžœ
žœžœžœ
žœ˜HKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—K˜K˜—š
Ÿœžœ
žœžœ	žœ˜FKšžœžœ
žœ
˜%Kš
œ
˜
šžœžœ
žœ
žœ
žœžœžœ
ž˜AKš
œ˜Kšžœ
˜—K˜K˜—šŸ
œžœ
žœ
žœ
žœžœžœ˜<Kš
œ/™/Kšžœžœ
ž˜Kšœžœžœ˜+Kš	œžœžœ
žœžœ˜PKš	œžœžœ
žœžœ˜RKšœžœ˜5Kšžœžœ
˜K˜K˜—šŸœžœ
žœžœ˜QK™DKšœžœ
žœ ˜-šœ
žœ˜"Kš
œ
˜
K˜—K˜K˜—šŸœžœ
žœžœ$˜ZK™@Kšœžœ
žœ&˜3šœ
žœ˜(Kš
œ
˜
K˜—K˜K˜K˜—šŸœžœ
žœžœ˜AKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—K˜K˜—šŸœžœ
žœžœ˜JKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—K˜K˜—šŸ
œžœ
žœžœ˜SKšœžœ
žœ"˜/šœžœ˜$Kš
œ
˜
K˜—K˜K˜—šŸ	œžœ
žœžœ˜DKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—K˜K˜—K™K™šŸœžœ
žœžœ!˜YK™CKšœžœ
žœ$˜1šœ
žœ˜&Kš
œ
˜
K˜—K˜K˜—šŸœžœ
žœžœ!˜YK™CKšœžœ
žœ)˜6šœ
žœ˜&Kš
œ
˜
K˜—K˜K˜—šŸœžœ
žœžœ˜HKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—K˜—K™š
Ÿœžœžœžœ
žœ˜QKš
œ˜Kšœžœ
˜šžœžœ
žœ
žœ
žœ!žœžœ
ž˜Ušžœžœ
ž˜š
œ˜Kšœ)žœ˜.Kšœžœ˜#K˜—˜Kšœ-žœ˜2Kšœžœ˜#K˜—Kšžœžœ
˜—Kšžœ
˜—K˜K˜—š
Ÿœžœžœžœ
žœ˜VKš
œ˜Kšœžœ
˜šžœžœ
žœ
žœ
žœ!žœžœ
ž˜Ušžœžœ
ž˜š
œ˜Kšœ)žœ˜.Kšœžœ˜#K˜—˜Kšœ-žœ˜2Kšœžœ˜#K˜—Kšžœžœ
˜—Kšžœ
˜—K˜K˜K˜—šŸœžœžœ˜KKš
Πbc™Kš
œA˜AKšœ0 "˜RK˜K˜—šŸœžœžœ˜KKš
£™Kš
œA˜AKšœ0 "˜RK˜K˜—K™K™K™šŸœžœ
žœ
žœ
žœžœ
žœ
žœ
˜RK™Kšœžœ
žœ˜Kšžœžœ
žœ
žœ˜Kšžœ
žœ
žœ
žœ
˜*Kš
œ˜Kšžœ˜Kš
œ˜K˜—šŸœžœ
žœ
žœ
žœžœ
žœ
žœ˜ZK™Kšœžœ
žœ˜Kšžœžœ
žœ
žœ˜Kšžœ
žœ
žœ
žœ
˜*Kš
œ˜Kšžœ˜Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœ
˜TKšœžœ
˜šžœžœ
žœ
žœ
žœ!žœžœ
ž˜Ušžœžœ
ž˜š
œ˜K˜—˜šžœžœ
žœ%žœ	žœ
ž˜KKšœžœ˜'—Kšžœ
˜K˜—Kšžœžœ
˜—Kšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ
žœ
˜]Kšœžœ
˜šžœžœ
žœ
žœ
žœ!žœžœ
ž˜Ušžœžœ
ž˜š
œ˜K˜—˜Kšœžœ˜)K˜—Kšžœžœ
˜—Kšžœ
˜—K˜K˜—šŸœžœ
žœžœ
žœ
žœ˜WKšœžœ
˜šžœžœ
žœ
žœ
žœ!žœžœ
ž˜Ušžœžœ
ž˜š
œ˜K™ Kšœžœ˜#K˜—K˜Kšžœžœ
˜—Kšžœ
˜—K˜K˜—š
Ÿœžœžœžœ
žœ˜QKš
œ˜K˜K˜—š
Ÿœžœžœžœ
žœ˜QKš
œ!˜!K˜K˜—š
Ÿœžœžœžœ
žœ
˜LKšœ
žœ
˜š	žœžœ
ž
œ
žœž˜7Kšœ
žœ(˜6Kšžœ
˜—K˜—K˜K™\K™šŸœžœ
žœ?žœ˜|Kš
œ"˜"Kš
œ˜Jš
œ*˜*Jšœžœ'˜<Kš
œ–
˜–
Kšžœ
žœ	žœ
žœžœ
žœ
žœ
žœ ˜`K˜K˜—K˜K™
K™šŸœžœ
žœ˜1šœ@žœ˜EK™`—K˜K˜—šŸœžœ
žœ˜4Kš	œžœ
žœ
žœ
žœ˜AKšœ& &˜Lšžœžœ
žœ
žœ
žœ!žœžœ
ž˜Mšžœžœ
ž˜Kš
œO˜OKš
œS˜SKšžœžœ
˜—Jšžœ
˜—K˜K˜—šŸ
œžœ
žœ?žœžœ
žœ
žœ
žœ˜€
šžœ
ž˜Kš
œ+˜+Kš
œ%˜%Kš
œ+˜+Kšžœžœ
˜—K˜K˜—Kšžœ
˜K™™&Kš
œ+™+—™$KšœΟr(™4——…—Iw