DIRECTORY
GGBasicTypes, GGBoundBox, GGInterfaceTypes, GGModelTypes, GGOutline, GGParent, GGScene, GGSceneType, GGSegmentTypes, GGSelect, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, ImagerPath, Rope, TextNode;

GGSceneImpl: CEDAR MONITOR
IMPORTS GGBoundBox, GGParent, GGScene, GGOutline, GGSelect, GGSlice, GGSliceOps, GGTraj, GGUtility
EXPORTS GGScene, GGModelTypes = BEGIN

BoundBox: TYPE = GGModelTypes.BoundBox;
BoundBoxGenerator: TYPE = GGModelTypes.BoundBoxGenerator;
BoundBoxGeneratorObj: TYPE = GGModelTypes.BoundBoxGeneratorObj;
Camera: TYPE = GGModelTypes.Camera;
CameraObj: TYPE = GGModelTypes.CameraObj;
CurveType: TYPE = {line, bezier, conic};
FeatureCycler: TYPE = GGInterfaceTypes.FeatureCycler;
GGData: TYPE = GGInterfaceTypes.GGData;
Joint: TYPE = GGSegmentTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
JointGeneratorObj: TYPE = GGModelTypes.JointGeneratorObj;
JointObj: TYPE = GGSegmentTypes.JointObj;
OutlineData: TYPE = GGOutline.OutlineData;
Point: TYPE = GGBasicTypes.Point;
Scene: TYPE = GGModelTypes.Scene;
SceneObj: PUBLIC TYPE = GGSceneType.SceneObj; -- export of opaque type
SelectedData: PUBLIC TYPE = GGSceneType.SelectedData; -- export of opaque type
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
Segment: TYPE = GGModelTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SegmentObj: TYPE = GGSegmentTypes.SegmentObj;
Slice: TYPE = GGModelTypes.Slice;
SliceParts: TYPE = GGModelTypes.SliceParts;
SlicePartsWalkProc: TYPE = GGModelTypes.SlicePartsWalkProc;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceDescriptorWalkProc: TYPE = GGModelTypes.SliceDescriptorWalkProc;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceGeneratorObj: TYPE = GGModelTypes.SliceGeneratorObj;
SliceWalkProc: TYPE = GGScene.SliceWalkProc;
Traj: TYPE = GGModelTypes.Traj;
TrajData: TYPE = GGModelTypes.TrajData;
TrajParts: TYPE = GGModelTypes.TrajParts;
TrajEnd: TYPE = GGModelTypes.TrajEnd; -- {lo, hi};
Vector: TYPE = GGBasicTypes.Vector;
WalkLevel: TYPE = GGModelTypes.WalkLevel;


Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = CODE;

CreateScene: PUBLIC PROC [entities: LIST OF Slice _ NIL] RETURNS [scene: Scene] = {
scene  _ NEW[SceneObj _ [entities: entities, prioritiesValid: FALSE] ];
};

SetScene: PUBLIC PROC [from: Scene, to: Scene]  = {
to2: REF SceneObj _ NARROW[to];
from1: REF SceneObj _ NARROW[from];
to2^ _ from1^;
};

<<SetScene: PUBLIC PROC [from: Scene, to: Scene]  = {
toObj: REF SceneObj _ NARROW[to];
fromObj: REF SceneObj _ NARROW[from];

toObj.ptrValid _ FALSE;
toObj.ptr _ NIL;
toObj.entities _ GGUtility.CopySliceList[fromObj.entities];
toObj.oldEntities _ NIL; -- obsolete

toObj.prioritiesValid _ fromObj.prioritiesValid;
toObj.currentColor _ fromObj.currentColor;

toObj.selected.normal _ GGUtility.AppendSliceDescriptorList[fromObj.selected.normal, NIL];
toObj.selected.normalPtr _ NIL;
toObj.selected.normalPtrValid _ FALSE;
toObj.selected.hot _ GGUtility.AppendSliceDescriptorList[fromObj.selected.hot, NIL];
toObj.selected.hotPtr _ NIL;
toObj.selected.hotPtrValid _ FALSE;
toObj.selected.active _ GGUtility.AppendSliceDescriptorList[fromObj.selected.active, NIL];
toObj.selected.activePtr _ NIL;
toObj.selected.activePtrValid _ FALSE;
toObj.selected.match _ GGUtility.AppendSliceDescriptorList[fromObj.selected.match, NIL];
toObj.selected.matchPtr _ NIL;
toObj.selected.matchPtrValid _ FALSE;

toObj.selected.featureCycler _ NIL;

toObj.savedSelected.normal _ GGUtility.AppendSliceDescriptorList[fromObj.savedSelected.normal, NIL];
toObj.savedSelected.normalPtr _ NIL;
toObj.savedSelected.normalPtrValid _ FALSE;
toObj.savedSelected.hot _ GGUtility.AppendSliceDescriptorList[fromObj.savedSelected.hot, NIL];
toObj.savedSelected.hotPtr _ NIL;
toObj.savedSelected.hotPtrValid _ FALSE;
toObj.savedSelected.active _ GGUtility.AppendSliceDescriptorList[fromObj.savedSelected.active, NIL];
toObj.savedSelected.activePtr _ NIL;
toObj.savedSelected.activePtrValid _ FALSE;
toObj.savedSelected.match _ GGUtility.AppendSliceDescriptorList[fromObj.savedSelected.match, NIL];
toObj.savedSelected.matchPtr _ NIL;
toObj.savedSelected.matchPtrValid _ FALSE;

toObj.savedSelected.featureCycler _ NIL;
};
>>
CreateDefaultCamera: PUBLIC PROC [] RETURNS [camera: Camera] = {
camera _ NEW[CameraObj];
};

AddSlice: PUBLIC PROC [scene: Scene, slice: Slice, priority: INT _ -1] = {
IF slice=NIL THEN RETURN;
slice.parent _ NIL;
IF priority = -1 OR TopPriority[scene]<priority THEN AppendSlice[scene, slice]
ELSE IF priority = 0 THEN {
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
scene.entities _ CONS[slice, scene.entities];
}
ELSE PutBehind[scene, GetAtPriority[scene, priority], LIST[slice]];
};

AddSlices: PUBLIC PROC [scene: Scene, slices: LIST OF Slice, priority: INT _ -1] = {
IF slices=NIL THEN RETURN;
FOR list: LIST OF Slice _ slices, list.rest UNTIL list = NIL DO
list.first.parent _ NIL;
ENDLOOP;
IF priority = -1 OR TopPriority[scene]<priority THEN {
FOR list: LIST OF Slice _ slices, list.rest UNTIL list = NIL DO
AppendSlice[scene, list.first];
ENDLOOP;
}
ELSE IF priority = 0 THEN {
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
scene.entities _ GGUtility.AppendSliceList[slices, scene.entities]; -- COPIES first argument
}
ELSE {
copiedSlices: LIST OF Slice _ GGUtility.CopySliceList[slices];
PutBehind[scene, GetAtPriority[scene, priority], copiedSlices];
};
};

AddHole: PUBLIC PROC [outline: Slice, hole: Slice, scene: Scene] RETURNS [holier: Slice] = {
holeOutline: Slice _ GGParent.GetParent[hole];
priority: INT _ GetPriority[scene: scene, slice: outline];
IF holeOutline = outline THEN ERROR;
holier _ GGOutline.AddChild[outline, hole];
DeleteSlice[scene, IF holeOutline=NIL THEN hole ELSE holeOutline];
DeleteSlice[scene, outline];
AddSlice[scene, holier, priority];
};

AppendHoles: PUBLIC PROC [outline: Slice, holes: LIST OF Slice] = {
outlineData: OutlineData _ NARROW[outline.data];
FOR holeList: LIST OF Slice _ holes, holeList.rest UNTIL holeList=NIL DO
outlineData.children _ GGUtility.AppendSliceList[outlineData.children, LIST[holeList.first]];
holeList.first.parent _ outline;
IF GGSliceOps.GetType[holeList.first]=$Traj THEN GGTraj.SetTrajRole[holeList.first, hole];
ENDLOOP;
GGSlice.KillBoundBox[outline];
};

AppendSlice: PROC [scene: Scene, slice: Slice] = {
scene.prioritiesValid _ FALSE;
IF NOT scene.ptrValid THEN UpdatePtr[scene];
[scene.entities, scene.ptr] _ GGUtility.AddSlice[slice, scene.entities, scene.ptr];
};

UpdatePtr: PROC [scene: Scene] = {
IF scene.entities=NIL THEN scene.ptr _ NIL ELSE
FOR list: LIST OF Slice _ scene.entities, list.rest UNTIL list=NIL DO
scene.ptr _ list;
ENDLOOP;
scene.ptrValid _ TRUE;
};

CopySelectedParts: PUBLIC PROC [fromScene: Scene, toScene: Scene] RETURNS [newSlices: LIST OF Slice _ NIL] = {
MakeNewSlices: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
copies: LIST OF Slice _ GGSliceOps.Copy[sliceD.slice, sliceD.parts];
FOR list: LIST OF Slice _ copies, list.rest UNTIL list = NIL DO
list.first.priority _ GGScene.GetPriority[fromScene, sliceD.slice];
[newSlices, ptr] _ GGUtility.AddSlice[list.first, newSlices, ptr];
ENDLOOP;
};
ptr: LIST OF Slice _ NIL;
[] _ GGScene.WalkSelectedSlices[fromScene, first, MakeNewSlices, normal];
newSlices _ GGUtility.SortSliceListByPriority[newSlices]; -- preserves order of equal elements
GGSelect.DeselectAll[toScene, normal];
FOR sliceList: LIST OF Slice _ newSlices, sliceList.rest UNTIL sliceList = NIL DO
GGScene.AddSlice[toScene, sliceList.first, -1];
GGSelect.SelectEntireSlice[sliceList.first, toScene, normal];
ENDLOOP;
};

UpdatePriorities: PROC [scene: Scene] = {
DoUpdate: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
slice.priority _ index;
index _ index + 1;
};
index: NAT _ 0;
[] _ GGScene.WalkSlices[scene, first, DoUpdate];
scene.prioritiesValid _ TRUE;
};

GetPriority: PUBLIC PROC [scene: Scene, slice: Slice] RETURNS [priority: INT] = {
IF NOT scene.prioritiesValid THEN UpdatePriorities[scene];
priority _ slice.priority;
};

TopPriority: PUBLIC PROC [scene: Scene] RETURNS [priority: INT] = {
IF NOT scene.prioritiesValid THEN UpdatePriorities[scene];
IF NOT scene.ptrValid THEN UpdatePtr[scene];
RETURN[IF scene.ptr=NIL THEN 0 ELSE scene.ptr.first.priority];
};

UpOne: PUBLIC PROC [scene: Scene, slice: Slice] = {
ExchangeWithNextEntity: PROC [scene: Scene, slice: Slice] = {
previous, next: LIST OF Slice _ NIL;
FOR list: LIST OF Slice _ scene.entities, list.rest UNTIL list = NIL DO
IF list.first=slice 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;
};
scene.ptrValid _ scene.prioritiesValid _ FALSE;
ExchangeWithNextEntity[scene, slice];
};

PutInFront: PUBLIC PROC [scene: Scene, slice: Slice, slices: LIST OF Slice] = {
IF slice#NIL AND slices#NIL THEN {
beforeEnt, ent, afterEnt, slicesRest: LIST OF Slice;
found: BOOL _ FALSE;
[beforeEnt, ent, afterEnt, found] _ GGUtility.FindSliceAndNeighbors[slice, scene.entities];
IF found THEN {
IF ent.first#slice THEN ERROR; -- debugging test
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
ent.rest _ slices; -- ent is really part of scene.entities. Skip over slice and then Splice in new slices.
FOR sList: LIST OF Slice _ slices, sList.rest UNTIL sList=NIL DO
slicesRest _ sList;
ENDLOOP;
slicesRest.rest _ afterEnt;
};
};
};

DownOne: PUBLIC PROC [scene: Scene, slice: Slice] = {
ExchangeWithPreviousEntity: PROC [scene: Scene, slice: Slice] = {
preprev, previous: LIST OF Slice _ NIL;
FOR list: LIST OF Slice _ scene.entities, list.rest UNTIL list=NIL DO
IF list.first=slice 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;
};
scene.ptrValid _ scene.prioritiesValid _ FALSE;
ExchangeWithPreviousEntity[scene, slice];
};

PutBehind: PUBLIC PROC [scene: Scene, slice: Slice, slices: LIST OF Slice] = {
IF slice#NIL AND slices#NIL THEN {
beforeEnt, ent, afterEnt, slicesRest: LIST OF Slice;
found: BOOL _ FALSE;
[beforeEnt, ent, afterEnt, found] _ GGUtility.FindSliceAndNeighbors[slice, scene.entities];
IF found THEN {
IF ent.first#slice THEN ERROR; -- debugging test
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
IF beforeEnt#NIL THEN beforeEnt.rest _ slices ELSE scene.entities _ slices; -- beforeEnt is really part of scene.entities. Splice in new slices before the existing slice
FOR sList: LIST OF Slice _ slices, sList.rest UNTIL sList=NIL DO
slicesRest _ sList;
ENDLOOP;
slicesRest.rest _ ent; -- add on the original slice and the remaining entities
};
};
};

ReplaceSlice: PUBLIC PROC [scene: Scene, slice: Slice, slices: LIST OF Slice] = {
beforeEnt, ent, afterEnt, slicesRest: LIST OF Slice;
found: BOOL _ FALSE;
IF slice#NIL AND slices#NIL THEN {
[beforeEnt, ent, afterEnt, found] _ GGUtility.FindSliceAndNeighbors[slice, scene.entities];
IF found THEN {
IF ent.first#slice THEN ERROR; -- debugging test
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
IF beforeEnt#NIL THEN beforeEnt.rest _ slices ELSE scene.entities _ slices; -- beforeEnt is really part of scene.entities. Splice in new slices before the existing slice
FOR sList: LIST OF Slice _ slices, sList.rest UNTIL sList=NIL DO
slicesRest _ sList;
ENDLOOP;
slicesRest.rest _ afterEnt;
};
};
};

PutAtPriority: PUBLIC PROC [scene: Scene, slice: Slice, priority: INT _ -1] = {
RemoveSlice[scene, slice];
AddSlice[scene, slice, priority];
};

GetAtPriority: PUBLIC PROC [scene: Scene, priority: INT] RETURNS [slice: Slice] = {
IF NOT scene.prioritiesValid THEN UpdatePriorities[scene];
IF priority = -1 THEN { -- special case: frontmost
IF NOT scene.ptrValid THEN UpdatePtr[scene];
RETURN[scene.ptr.first];
}
ELSE IF priority = 0 THEN RETURN[scene.entities.first] -- special case: rear-most
ELSE { -- somewhere in the middle
count: INT _ 1;
FOR sliceList: LIST OF Slice _ scene.entities.rest, sliceList.rest UNTIL sliceList=NIL DO
IF count=priority THEN RETURN[sliceList.first];
count _ count+1;
ENDLOOP;
IF NOT scene.ptrValid THEN UpdatePtr[scene];
RETURN[scene.ptr.first];
};
};

DeleteAtPriority: PUBLIC PROC [scene: Scene, priority: INT] RETURNS [deleted: Slice] = {
deleted _ GetAtPriority[scene, priority];
DeleteSlice[scene, deleted];
};

RemoveSlice: PUBLIC PROC [scene: Scene, slice: Slice] =  {
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
scene.entities _ GGUtility.DeleteSliceFromList[slice, scene.entities];
};

DeleteSlice: PUBLIC PROC [scene: Scene, slice: Slice] =  {
scene.ptrValid _ FALSE;
scene.prioritiesValid _ FALSE;
GGSelect.DeselectEntityAllClasses[slice, scene];
scene.entities _ GGUtility.DeleteSliceFromList[slice, scene.entities];
};

DeleteSequence: PUBLIC PROC [seq: SliceDescriptor, scene: Scene] RETURNS [oldOutline: Slice, newOutlines: LIST OF Slice] = {
priority: INT;
traj: Slice _ seq.slice;
smallerOutline: Slice;
oldOutline _ GGParent.GetParent[traj];
GGOutline.SaveSelectionsInOutlineAllClasses[oldOutline];
priority _ GGScene.GetPriority[scene, oldOutline];
[smallerOutline, newOutlines] _ GGTraj.DeleteSequence[seq];
IF smallerOutline # NIL THEN newOutlines _ CONS[smallerOutline, newOutlines];
IF newOutlines#NIL THEN AddSlices[scene, newOutlines, priority];
DeleteSlice[scene, oldOutline];
FOR list: LIST OF Slice _ newOutlines, list.rest UNTIL list = NIL DO
GGSelect.ReselectSliceAllClasses[list.first, scene];
ENDLOOP;
};

OutlinesFromOutlineExcept: PROC [outline: Slice, except: Traj] RETURNS [newOutlines: LIST OF Slice] = {
ptr: LIST OF Slice;
newSlice, newOutline: Slice;
children: LIST OF Slice _ NARROW[outline.data, OutlineData].children;
[newOutlines, ptr] _ GGUtility.StartSliceList[];
FOR childList: LIST OF Slice _ children, childList.rest UNTIL childList = NIL DO
IF childList.first = except THEN LOOP;
newSlice _ GGSliceOps.Copy[childList.first].first;
newOutline _ GGOutline.CreateOutline[newSlice, GGSliceOps.GetFillColor[outline, NIL].color];
[newOutlines, ptr] _ GGUtility.AddSlice[newOutline, newOutlines, ptr];
ENDLOOP;
};

noGarbage: BOOL _ FALSE;
MakeSceneGarbage: PUBLIC PROC [scene: Scene] = {
oldEntities: LIST OF LIST OF Slice;
entities: LIST OF Slice;
IF noGarbage THEN RETURN;
oldEntities _ scene.oldEntities;
scene.oldEntities _ NIL;
entities _ scene.entities;
scene.entities _ NIL; -- in case a screen refresh is attempted while we are doing this.
FOR sllist: LIST OF LIST OF Slice _ oldEntities, sllist.rest UNTIL sllist=NIL DO
FOR list: LIST OF Slice _ sllist.first, list.rest UNTIL list=NIL DO
IF list.first.class#NIL THEN GGSliceOps.Unlink[list.first]; -- if class=NIL, already unlinked
ENDLOOP;
ENDLOOP;
FOR list: LIST OF Slice _ entities, list.rest UNTIL list=NIL DO
IF list.first.class#NIL THEN GGSliceOps.Unlink[list.first]; -- if class=NIL, already unlinked
ENDLOOP;
};

MergeScenes: PUBLIC PROC [back: Scene, front: Scene] RETURNS [combined: Scene] = {
combined _ NEW[SceneObj _ [prioritiesValid: FALSE]];
combined.entities _ GGUtility.AppendSliceList[back.entities, front.entities];
combined.selected.normal _ GGUtility.AppendSliceDescriptorList[back.selected.normal, front.selected.normal];
combined.selected.hot _ GGUtility.AppendSliceDescriptorList[back.selected.hot, front.selected.hot];
combined.selected.active _ GGUtility.AppendSliceDescriptorList[back.selected.active, front.selected.active];
combined.selected.match _ GGUtility.AppendSliceDescriptorList[back.selected.match, front.selected.match];
};


WalkSlices: PUBLIC PROC [scene: Scene, level: WalkLevel, walkProc: SliceWalkProc, classType: ATOM _ NIL] RETURNS [aborted: BOOL _ FALSE] = {
FOR slices: LIST OF Slice _ scene.entities, slices.rest UNTIL slices = NIL DO
thisType: ATOM _ GGSliceOps.GetType[slices.first];
IF (level # leaf OR GGParent.IsLeafOfClass[slices.first, classType]) AND (classType = NIL OR thisType = classType) THEN {
aborted _  walkProc[slices.first];
IF aborted THEN RETURN;
};
IF (level = all OR level = leaf OR (level = highest AND thisType # classType)) AND GGParent.IsParent[slices.first] THEN {
aborted _  GGParent.WalkChildren[slices.first, level, walkProc, classType];
IF aborted THEN RETURN;
};
ENDLOOP;
};

WalkSelectedSlices: PUBLIC PROC [scene: Scene, level: WalkLevel, walkProc: SliceDescriptorWalkProc, selectClass: SelectionClass, classType: ATOM _ NIL] RETURNS [aborted: BOOL _ FALSE] = {
FOR list: LIST OF SliceDescriptor _ GGSelect.ListSelected[scene, selectClass], list.rest UNTIL list = NIL DO
thisSlice: Slice _ list.first.slice;
thisParts: SliceParts _ list.first.parts;
thisType: ATOM _ GGSliceOps.GetType[thisSlice];
IF (classType = NIL OR thisType = classType) AND (level # leaf OR GGParent.IsLeafOfClass[thisSlice, classType]) THEN {
aborted _  walkProc[list.first];
IF aborted THEN RETURN;
};
IF (level = all OR level = leaf OR (level = highest AND thisType # classType)) AND GGParent.IsParent[thisSlice] THEN {
aborted _  GGParent.WalkIncludedChildren[thisSlice, thisParts, level, walkProc, classType];
IF aborted THEN RETURN;
};
ENDLOOP;
};

ListSlices: PUBLIC PROC [scene: Scene, level: WalkLevel, classType: ATOM _ NIL] RETURNS [sliceList: LIST OF Slice] = {
ptr: LIST OF Slice;
DoAppendSlice: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
[sliceList, ptr] _ GGUtility.AddSlice[slice, sliceList, ptr];
};
[sliceList, ptr] _ GGUtility.StartSliceList[];
[] _ WalkSlices[scene, level, DoAppendSlice, classType];
};

ListSelectedSlices: PUBLIC PROC [scene: Scene, level: WalkLevel, selectClass: SelectionClass, classType: ATOM _ NIL] RETURNS [selectedList: LIST OF SliceDescriptor] = {
ptr: LIST OF SliceDescriptor;
DoAppendSlice: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
[selectedList, ptr] _ GGUtility.AddSliceDescriptor[childD, selectedList, ptr];
};
[selectedList, ptr] _ GGUtility.StartSliceDescriptorList[];
[] _ WalkSelectedSlices[scene, level, DoAppendSlice, selectClass, classType];
};
CountSlices: PUBLIC PROC [scene: Scene, level: WalkLevel, classType: ATOM _ NIL] RETURNS [count: INT _ 0] = {
AddEmUp: PROC [child: Slice] RETURNS [done: BOOL _ FALSE] = {
count _ count + 1;
};
[] _ WalkSlices[scene, level, AddEmUp, classType];
};

CountSelectedSlices: PUBLIC PROC [scene: Scene, level: WalkLevel, selectClass: SelectionClass, classType: ATOM _ NIL] RETURNS [count: INT _ 0] = {
AddEmUp: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
count _ count + 1;
};
[] _ WalkSelectedSlices[scene, level, AddEmUp, selectClass, classType];
};

FirstSelectedSlice: PUBLIC PROC [scene: Scene, level: WalkLevel, selectClass: SelectionClass, classType: ATOM _ NIL] RETURNS [sliceD: SliceDescriptor] = {
StopAtFirstSlice: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
sliceD _ childD;
RETURN[TRUE];
};
[] _ WalkSelectedSlices[scene, level, StopAtFirstSlice, selectClass, classType];
};

LastSelectedSlice: PUBLIC PROC [scene: Scene, level: WalkLevel, selectClass: SelectionClass, classType: ATOM _ NIL] RETURNS [sliceD: SliceDescriptor] = {
StopAtLastSlice: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
sliceD _ childD;
};
[] _ WalkSelectedSlices[scene, level, StopAtLastSlice, selectClass, classType];
};

IsTopLevel: PUBLIC PROC [slice: Slice] RETURNS [BOOL] = {
RETURN[slice.parent = NIL];
};

BoundBoxesInScene: PUBLIC PROC [scene: Scene] RETURNS [bBoxGen: BoundBoxGenerator] = {
list: LIST OF BoundBox;
thisBox: BoundBox;
FOR entities: LIST OF Slice _ scene.entities, entities.rest UNTIL entities = NIL DO
IF GGSliceOps.GetType[entities.first]=$Outline THEN { -- multiple bound boxes wanted
outlineData:  OutlineData _ NARROW[entities.first.data];
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children=NIL DO
thisBox _ GGSliceOps.GetBoundBox[children.first, NIL];
list _ CONS[thisBox, list];
ENDLOOP;
}
ELSE {
thisBox _ GGSliceOps.GetBoundBox[entities.first, NIL];
list _ CONS[thisBox, list];
};
ENDLOOP;
bBoxGen _ NEW[BoundBoxGeneratorObj _ [
list: list
]];
};

TightBoxesInScene: PUBLIC PROC [scene: Scene] RETURNS [bBoxGen: BoundBoxGenerator] = {
list: LIST OF BoundBox;
thisBox: BoundBox;
FOR entities: LIST OF Slice _ scene.entities, entities.rest UNTIL entities = NIL DO
thisBox _ GGSliceOps.GetTightBox[entities.first, NIL];
list _ CONS[thisBox, list];
ENDLOOP;
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;
};
};
BoundBoxOfScene: PUBLIC PROC [scene: Scene] RETURNS [bBox: BoundBox] = {
bbGen: GGModelTypes.BoundBoxGenerator _ BoundBoxesInScene[scene];
bBox _ GGBoundBox.BoundBoxOfBoxes[bbGen.list];  -- cheating to go inside generator
};

TightBoxOfScene: PUBLIC PROC [scene: Scene] RETURNS [bBox: BoundBox] = {
bbGen: GGModelTypes.BoundBoxGenerator _ TightBoxesInScene[scene];
bBox _ GGBoundBox.BoundBoxOfBoxes[bbGen.list];  -- cheating to go inside generator
};
SelectionBoxOfSelected: PUBLIC PROC [scene: Scene, selectClass: SelectionClass _ normal, full: BOOL _ FALSE] RETURNS [bigBox: BoundBox] = {
nextBox: BoundBox;
DoEnlargeBox: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
nextBox _
IF GGSliceOps.GetType[sliceD.slice]=$Text
THEN GGSliceOps.GetTightBox[sliceD.slice, IF full THEN NIL ELSE sliceD.parts]
ELSE GGSliceOps.GetBoundBox[sliceD.slice, IF full THEN NIL ELSE sliceD.parts];
GGBoundBox.EnlargeByBox[bBox: bigBox, by: nextBox];
};
bigBox _ GGBoundBox.NullBoundBox[];
[] _ GGScene.WalkSelectedSlices[scene, first, DoEnlargeBox, selectClass];
};

BoundBoxOfSelected: PUBLIC PROC [scene: Scene, selectClass: SelectionClass _ normal, sliceLevel: BOOL _ FALSE] RETURNS [bigBox: BoundBox] = {
nextBox: BoundBox;
DoEnlargeBox: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
nextBox _ GGSliceOps.GetBoundBox[sliceD.slice, IF sliceLevel THEN NIL ELSE sliceD.parts];
GGBoundBox.EnlargeByBox[bBox: bigBox, by: nextBox];
};
bigBox _ GGBoundBox.NullBoundBox[];
[] _ GGScene.WalkSelectedSlices[scene, first, DoEnlargeBox, selectClass];
};

TightBoxOfSelected: PUBLIC PROC [scene: Scene, selectClass: SelectionClass _ normal, sliceLevel: BOOL _ FALSE] RETURNS [bigBox: BoundBox] = {
nextBox: BoundBox;
DoEnlargeBox: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
nextBox _ GGSliceOps.GetTightBox[sliceD.slice, IF sliceLevel THEN NIL ELSE sliceD.parts];
GGBoundBox.EnlargeByBox[bBox: bigBox, by: nextBox];
};
bigBox _ GGBoundBox.NullBoundBox[];
[] _ GGScene.WalkSelectedSlices[scene, first, DoEnlargeBox, selectClass];
};

useSelected: BOOL _ FALSE;
BoundBoxOfMoving: PUBLIC PROC [scene: Scene, editConstraints: GGModelTypes.EditConstraints, bezierDrag: GGInterfaceTypes.BezierDragRecord, selectClass: SelectionClass _ normal] RETURNS [bigBox: BoundBox] = {

nextBox: BoundBox;
DoEnlargeBox: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
overlay, rubber, drag, movingParts: SliceDescriptor;
[----, overlay, rubber, drag] _ GGSliceOps.MovingParts[sliceD.slice, sliceD.parts, editConstraints, bezierDrag];
movingParts _ GGSliceOps.UnionParts[overlay, rubber];
movingParts _ GGSliceOps.UnionParts[movingParts, drag];
nextBox _ GGSliceOps.GetBoundBox[sliceD.slice, movingParts.parts];
GGBoundBox.EnlargeByBox[bBox: bigBox, by: nextBox];
};
IF useSelected THEN RETURN[BoundBoxOfSelected[scene, selectClass]];
bigBox _ GGBoundBox.NullBoundBox[];
[] _ GGScene.WalkSelectedSlices[scene, first, DoEnlargeBox, selectClass];
};

DeleteAllSelected: PUBLIC PROC [scene: Scene] RETURNS [bBox: BoundBox] = {
DeleteTopLevel: PROC [topLevelD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
IF GGSliceOps.IsCompleteParts[topLevelD] THEN {
affectedBox _ GGSliceOps.GetBoundBox[topLevelD.slice, NIL];
DeleteSlice[scene, topLevelD.slice]; -- fast case
}
ELSE {
newSlices: LIST OF Slice;
priority: INT _ GetPriority[scene, topLevelD.slice];
GGSelect.SaveSelectionsInSliceAllClasses[topLevelD.slice, scene];
[newSlices, affectedBox] _ DeleteSliceParts[topLevelD];
DeleteSlice[scene, topLevelD.slice];
AddSlices[scene, newSlices, priority];
FOR list: LIST OF Slice _ newSlices, list.rest UNTIL list = NIL DO
GGSelect.ReselectSliceAllClasses[list.first, scene];
GGSelect.DeselectEntireSlice[list.first, scene, active]; -- do this in case some active selections remain for parts which were not deleted.  This fixes a problem when a control point is selected (not a joint) and DEL is invoked but the CP is not deleted.
ENDLOOP;
};
GGBoundBox.EnlargeByBox[bBox, affectedBox];
};
affectedBox: BoundBox;
bBox _ GGScene.BoundBoxOfSelected[scene, normal];
GGSelect.DuplicateSelections[scene, normal, active];
[] _ GGScene.WalkSelectedSlices[scene, first, DeleteTopLevel, active];
};

DeleteSliceParts: PROC [sliceD: SliceDescriptor] RETURNS [newSlices: LIST OF Slice, bBox: BoundBox] = {
bBox _ GGBoundBox.NullBoundBox[];
SELECT GGSliceOps.GetType[sliceD.slice] FROM
$Traj => ERROR;
$Cluster => {
DoDeleteParts: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
affectedBox: BoundBox;
IF GGSliceOps.IsCompleteParts[childD] THEN {
smallerCluster: Slice;
affectedBox _ GGSliceOps.GetBoundBox[childD.slice, NIL];
smallerCluster _ GGSlice.RemoveChild[sliceD.slice, childD.slice]; -- fast case
}
ELSE {
newSlices: LIST OF Slice;
priority: INT _ GGParent.GetChildPriority[sliceD.slice, childD.slice];
[newSlices, affectedBox] _ DeleteSliceParts[childD];
[] _ GGSlice.RemoveChild[sliceD.slice, childD.slice];
GGSlice.AddChildrenToCluster[sliceD.slice, newSlices, priority];
};
GGBoundBox.EnlargeByBox[bBox, affectedBox];
};
IF GGSliceOps.IsCompleteParts[sliceD] THEN RETURN[NIL, bBox];
[] _ GGParent.WalkIncludedChildren[sliceD.slice, sliceD.parts, first, DoDeleteParts];
newSlices _ LIST[sliceD.slice];
};
$Outline => {
thisBox: BoundBox;
childD: SliceDescriptor;
outlineParts: SliceParts;
original, outline: Slice;
openTrajOutlines: LIST OF Slice;

original _ sliceD.slice;
outlineParts _ sliceD.parts;
outline _ sliceD.slice; -- gets smaller with each iteration
childD _ GGParent.FirstIncludedChild[outline, outlineParts, first];
UNTIL childD = NIL DO
IF GGSliceOps.GetType[childD.slice] = $Traj THEN {
IF GGSliceOps.IsCompleteParts[childD] THEN {
outline _ GGOutline.ReplaceChild[outline, childD.slice, NIL];
}
ELSE {
[outline, openTrajOutlines] _ GGTraj.DeleteSequence[childD];
newSlices _ GGUtility.AppendSliceList[openTrajOutlines, newSlices];
};
}
ELSE { -- $Box or $Circle
screenStyle: BOOL _ TRUE;
fillText: TextNode.Location;

GGBoundBox.EnlargeByBox[bBox: bBox, by: GGSliceOps.GetBoundBox[outline]];
[fillText, screenStyle] _ GGSlice.GetBoxText[outline];
outline _ GGOutline.ReplaceChild[outline, childD.slice, NIL];
IF outline # NIL
THEN GGOutline.SetFillText[outline, fillText.node, screenStyle, NIL];
};
IF outline = NIL THEN childD _ NIL
ELSE {
outlineParts _ GGSliceOps.RemakeSelections[outline, active];
childD _ GGParent.FirstIncludedChild[outline, outlineParts, first];
};
ENDLOOP;
IF outline # NIL THEN newSlices _ CONS[outline, newSlices]; -- filled outline backmost
thisBox _ BoundBoxOfSlices[newSlices];
GGBoundBox.EnlargeByBox[bBox: bBox, by: thisBox];
};
ENDCASE => {
newSlices _ NIL;
};
};

BoundBoxOfSlices: PROC [sliceList: LIST OF Slice] RETURNS [bBox: BoundBox] = {
bBox _ GGBoundBox.NullBoundBox[];
FOR list: LIST OF Slice _ sliceList, list.rest UNTIL list = NIL DO
GGBoundBox.EnlargeByBox[bBox: bBox, by: GGSliceOps.GetBoundBox[list.first, NIL]];
ENDLOOP;
};

SaveSelections: PUBLIC PROC [scene: Scene] = {
scene.savedSelected.normal _ GGUtility.CopySliceDescriptorList[scene.selected.normal];
scene.savedSelected.featureCycler _ scene.selected.featureCycler;
};

RestoreSelections: PUBLIC PROC [scene: Scene] = {
GGSelect.DeselectAll[scene, normal];  -- get rid of any transient selections
FOR list: LIST OF SliceDescriptor _ scene.savedSelected.normal, list.rest UNTIL list = NIL DO
GGSelect.SelectSlice[list.first, scene, normal];
ENDLOOP;
scene.selected.featureCycler _ scene.savedSelected.featureCycler;
};


SelectInBox: PUBLIC PROC [scene: Scene, box: BoundBox, selectClass: SelectionClass _ normal] = {
SelectSlice: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
IF GGSliceOps.WithinBoundBox[slice, box]
THEN GGSelect.SelectEntireSlice[slice, scene, selectClass];
};
[] _ GGScene.WalkSlices[scene, first, SelectSlice];
};

SelectPartsInBox: PUBLIC PROC [scene: Scene, box: BoundBox, selectClass: SelectionClass _ normal] = {
inParts: SliceDescriptor;
SelectSliceParts: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
inParts _ GGSliceOps.PartsInBoundBox[slice, box];
IF inParts # NIL THEN GGSelect.SelectSlice[inParts, scene, selectClass];
};
[] _ GGScene.WalkSlices[scene, first, SelectSliceParts];
};

<<lockFree: CONDITION;
LockScene: PUBLIC ENTRY PROC [scene: Scene, name: ATOM, wait: BOOL _ TRUE] RETURNS [success: BOOL _ FALSE] = {
IF scene.lock = $NotLocked THEN {
scene.lock _ name;
success _ TRUE;
}
ELSE {
IF NOT wait THEN RETURN;
UNTIL scene.lock = $NotLocked DO WAIT lockFree ENDLOOP;
scene.lock _ name;
success _ TRUE;
};
};

UnLockScene: PUBLIC ENTRY PROC [scene: Scene] = {
scene.lock _ $NotLocked;
NOTIFY lockFree;
};
>>

END.
GGSceneImpl.mesa
Contents:  The procedural interface to the Gargoyle object modeler.
Copyright Σ 1985, 1988 by Xerox Corporation.  All rights reserved.
Stone, August 5, 1985 4:13:18 pm PDT
Pier, February 4, 1991 1:56 pm PST
Kurlander August 28, 1986 6:15:29 pm PDT
Bier, May 29, 1990 9:59:21 am 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.

Creating, Modifying Scenes
The list scene.entities is kept in back to front order.  Hence, newly added objects are usually added to the end of the list.  This list may be mutated freely.  Copies of it are made when needed.

Add the given slice to the scene with the given priority (the higher the priority number, the closer the slice is to the front of the scene).  If priority is -1, the slice will be the front-most entity.  If the priority given is too high, we proceed as if priority = -1.
Adds the slices, assumed to be in back to front order, to the scene.  IF priority = -1, they become the frontmost entities.  Otherwise, the specified priority becomes the priority of the first entity in the list, if possible.  If the priority given is too high, we proceed as if priority = -1.
Copy incoming list to avoid mutations by PutBehind
holes should not have parents.  May create obsolete sequences, so be careful.
Manipulations on Multiple Scenes

Copy all parts that are current selectedly in "from" and place the copies in "to" at the frontmost priority.
Add all of the new slices to the "to" scene and select them.
Priority order

If returned priority is 0, the slice is the back-most entity.
Returns the priority of the frontmost position in the scene.
Moves the named slice one step closer to the front in the priority order.
Destructively splices slices into scene
Moves the named slice one step closer to the back in the priority order.
Destructively splices slices into scene
Removes slice from scene and puts back-to-front slices in its place.
Destructively splices slices into scene
If priority is 0, the slice will be the back-most entity.  If priority is -1, the slice will be the front-most entity.  If the priority given is too high, we proceed as if priority = -1.
or off the scale
Ruthlessly destroy an entire scene so the Cedar gargbage collector can sweep up.

Browsing the Scene Hierarchy -- Generators
Built-in classes include: $Cluster, $Outline, $Traj, $Box, $Circle, $Text, and $IP.  This routine finds all such slices, even within clusters.  class=NIL => all classes.  Use level=all to walk every slice of a given class.
Top level classes
Depth first walk
Built-in classes include: $Cluster, $Outline, $Traj, $Box, $Circle, $Text, and $IP.  This routine finds all such slices, even within clusters.  class=NIL => all classes.  Use level=all to walk every selected slice of a given class.
Top level classes
Depth first walk


Bounding Boxes

Generates all of the boundBoxes in the scene, wherever they occur.
Generates all of the boundBoxes in the scene, whereever they occur.
list: LIST OF BoundBox _ ListTightBoxesInScene[scene];

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

Returns the composite tight box for all selected parts, or all selected slices if sliceLevel=TRUE.
routine called to calculate the boundBox of all objects that are about to move; that is, all selected slices, selected CPs, selected joints AND the dangling segments of selected joints AND the segments of selected CPs.
In the common case, drag will be the only non-null descriptor.
Selections

Returns bounding box of area requiring refresh.
This is a partially-selected cluster.  We will return a single cluster, that differs from the original in that DeleteSliceParts has been recursively applied to all of its children.
Select all slices that are completely contained within or on the edge of box.
Select all slice parts that are completely contained within or on the surface of box.
Getting Exclusive Access to a Scene

Name is an indication of what you are going to do while you have locked the scene (e.g., $Get, or $Gravity).  Locking is provided to prevent the TIP Notify process from performing spatial calculations on a scene while the Slack process is garbage collecting it.
Κ$Δ˜Icode™šΟnœ;™CKš
œB™BKšœ!Οk™$Kš
œ"™"Kšœ%ž™(Kš
œ!™!—K™š
ž	˜	Jš
œΚ
˜Κ
K˜—šœžœ
ž˜Jšžœ[˜bKšžœž˜%—˜Kšœ
žœ˜'Kšœžœ"˜9Kšœžœ%˜?Kšœžœ˜#Kšœžœ˜)Kšœžœ˜(Kšœžœ"˜5Kšœžœ˜'Kšœžœ˜#Kšœžœ˜3Kšœžœ"˜9Kšœ
žœ˜)Kšœ
žœ˜*Kšœžœ˜!Kšœžœ˜!Kšœ
žœ
žœΟc˜FKšœžœ
žœŸ˜NKšœžœ!˜5Kšœ	žœ˜%Kšœžœ!˜7Kšœžœ˜-Kšœžœ˜!Kšœžœ˜+Kšœžœ#˜;Kšœžœ ˜5Kšœžœ)˜GKšœžœ(˜EKšœžœ˜3Kšœžœ"˜9Kšœžœ˜,Kšœžœ˜Kšœ
žœ˜'Kšœžœ˜)Kšœ	žœŸ˜2Kšœžœ˜#Kšœžœ˜)K˜š
œ4žœ7žœ
žœ*žœ
žœ#žœΐ
™™K™a——K˜Kš
œžœ
žœžœžœ
˜/K™š
œ™K˜Kš
œΓ
™Γ
K™—šœžœ
žœžœ
žœ	žœžœ˜SKšœ	žœ2žœ˜GK˜K˜—šœžœ
žœ˜3Kšœžœžœ˜Kšœžœžœ˜#K˜K˜K˜—š
œžœ
žœ˜5Kšœžœžœ˜!Kšœ	žœžœ˜%K˜Kšœžœ
˜Kšœžœ
˜Kš
œ;˜;KšœžœŸ˜$K˜Kš
œ0˜0Kš
œ*˜*K˜KšœUžœ˜ZKšœžœ
˜Kšœ žœ
˜&KšœOžœ˜TKšœžœ
˜Kšœžœ
˜#KšœUžœ˜ZKšœžœ
˜Kšœ žœ
˜&KšœSžœ˜XKšœžœ
˜Kšœžœ
˜%K˜Kšœžœ
˜#K˜Kšœ_žœ˜dKšœ žœ
˜$Kšœ%žœ
˜+KšœYžœ˜^Kšœžœ
˜!Kšœ"žœ
˜(Kšœ_žœ˜dKšœ žœ
˜$Kšœ%žœ
˜+Kšœ]žœ˜bKšœžœ
˜#Kšœ$žœ
˜*K˜Kšœ$žœ
˜(K˜Kš
˜—šœžœ
žœžœ˜@Kšœ	žœ˜K˜K˜—šœžœ
žœ(žœ
˜JKš
œŽ™ŽKšžœžœ
žœ
žœ
˜Kšœžœ
˜Kšžœžœžœ˜Nšžœ
žœžœ˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜-K˜
—Kšžœ2žœ	˜CK˜K˜—š	œžœ
žœžœ
žœžœ
˜TKšœFžœέ
™₯Kšžœžœ
žœ
žœ
˜šžœžœ
žœžœžœ
ž˜?Kšœžœ
˜Kšžœ
˜—šžœžœžœ˜6šžœžœ
žœžœžœ
ž˜?Kš
œ˜Kšžœ
˜—K˜
—šžœ
žœžœ˜Kšœžœ
˜Kšœžœ
˜KšœDŸ˜\K˜
—šžœ˜Kš
œ2™2Kšœžœ
žœ)˜>Kš
œ?˜?K˜—K˜K˜—šœžœ
žœ-žœ˜\Kš
œ.˜.K•StartOfExpansion:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]šœ
žœ-˜:Kšžœžœ
žœ
˜$Kš
œ+˜+Kš	œžœ
žœ
žœžœ˜BKš
œ˜Kš
œ"˜"K˜K˜—š
œžœ
žœžœ
žœ˜CK™MKšœžœ˜0šžœžœ
žœžœ
žœ
ž˜HKšœGžœ˜]Kš
œ ˜ Kšžœ*žœ*˜ZKšžœ
˜—Kš
œ˜K˜K˜—šœžœ!˜2Kšœžœ
˜Kšžœ
žœžœ˜,Kš
œS˜SK˜K˜—š	œžœ˜"Kš	žœžœ
žœ
žœ
ž˜/šžœžœ
žœ#žœžœ
ž˜EK˜Kšžœ
˜—Kšœžœ
˜Kš
œ˜—K˜™ K™—šœžœ
žœ$žœ
žœ
žœ	žœ˜nKš
œl™lš

œžœžœžœžœ˜NJšœžœ
žœ5˜Dšžœžœ
žœžœžœ
ž˜?Kš
œC˜CKš
œB˜BKšžœ
˜—Kš
œ˜—Jšœžœ
žœ	žœ
˜Jšœ0Οtœ
 œ ˜IJšœ:Ÿ$˜^Jš
œ&˜&Jš
Οb<™<šžœžœ
žœ#žœ
žœ
ž˜QJš
œ/˜/Jš
œ=˜=Jšžœ
˜—K˜K˜—™K™—šœžœ˜)š
œžœžœžœžœ˜>Jš
œ˜Jš
œ˜J˜—Jšœžœ˜Kšœ$ œ ˜0Jšœžœ
˜Kš
œ˜K˜—š
œžœ
žœžœžœ˜QKš
œ=™=Kšžœ
žœžœ˜:Kš
œ˜K˜K˜—š
œžœ
žœžœžœ˜CKš
œ<™<Kšžœ
žœžœ˜:Kšžœ
žœžœ˜,Kš
žœ
žœžœ
žœžœ˜>K˜K˜—šœžœ
žœ!˜3Kš
œI™Išœžœ!˜=Kšœžœ
žœ	žœ
˜$šžœžœ
žœ#žœžœ
ž˜GšžœžœŸ.˜IK˜Kš	žœžœ
žœ
žœŸ+˜DKš
œ)˜)Kšžœ
žœ
žœžœ˜EK˜
—Kšžœ˜Kšžœ
˜—K˜—Kšœ)žœ
˜/Kš
œ%˜%K˜K˜—š

œžœ
žœ&žœ
žœ˜OKš
œ'™'š
žœžœ
žœžœ
žœ˜"Kšœ&žœ
žœ˜4Kšœžœžœ
˜Kš
œ[˜[šžœžœ˜Kšžœžœ
žœŸ˜0Kšœžœ
˜Kšœžœ
˜KšœŸW˜jšžœžœ
žœžœžœ
ž˜@K˜Kšžœ
˜—K˜K˜—K˜—K˜K˜—šœžœ
žœ!˜5Kš
œH™Hšœžœ!˜AKšœžœ
žœ	žœ
˜'šžœžœ
žœ#žœžœ
ž˜EšžœžœŸ2˜Mšžœ
žœ
ž˜Kš
œžœ
žœ
žœžœŸ˜Dšœžœ
žœ
žœŸ#˜EKšœIžœ
˜PK˜—Kš
œžœ
žœ
žœžœŸ˜>šœžœ
žœ
žœŸ%˜GKšœHžœ
˜OKš
œ˜—KšžœžœŸ˜)—K˜
—Kšžœ+˜/Kšžœ
˜—K˜—Kšœ)žœ
˜/Kš
œ)˜)K˜K˜—š
	œžœ
žœ&žœ
žœ˜NKš
œ'™'š
žœžœ
žœžœ
žœ˜"Kšœ&žœ
žœ˜4Kšœžœžœ
˜Kš
œ[˜[šžœžœ˜Kšžœžœ
žœŸ˜0Kšœžœ
˜Kšœžœ
˜Kš	žœžœ
žœžœŸ]˜©
šžœžœ
žœžœžœ
ž˜@K˜Kšžœ
˜—KšœŸ7˜NK˜—Kš
œ˜—Kš
œ˜K˜—š
œžœ
žœ&žœ
žœ˜QKš
œD™DKš
œ'™'Kšœ&žœ
žœ˜4Kšœžœžœ
˜š
žœžœ
žœžœ
žœ˜"Kš
œ[˜[šžœžœ˜Kšžœžœ
žœŸ˜0Kšœžœ
˜Kšœžœ
˜Kš	žœžœ
žœžœŸ]˜©
šžœžœ
žœžœžœ
ž˜@K˜Kšžœ
˜—K˜K˜—K˜—K˜K˜—š
œžœ
žœ(žœ
˜OKš
œΊ
™Ί
Kš
œ˜Kš
œ!˜!K˜K˜—š

œžœ
žœžœžœ˜SKšžœ
žœžœ˜:šžœžœŸ˜2Kšžœ
žœžœ˜,Kšžœ˜K˜
—Kš	žœ
žœžœ
žœŸ˜QšžœŸ˜!Kšœžœ˜šžœžœ
žœ-žœžœ
ž˜YKšžœžœ
žœ˜/Kš
œ˜Kšžœ
˜—Kš
œ™Kšžœ
žœžœ˜,Kšžœ˜K˜—K˜K˜—š
œžœ
žœžœžœ˜XKš
œ)˜)K–<[scene: 
GGSceneImpl.SceneRef, slice: 
GGModelTypes.Slice]š
œ˜K˜—K˜šœžœ
žœ"˜:Kšœžœ
˜Kšœžœ
˜Kš
œF˜FK˜K˜—šœžœ
žœ"˜:Kšœžœ
˜Kšœžœ
˜Kš
œ0˜0Kš
œF˜FK˜K˜—šœžœ
žœ&žœ"žœ
žœ˜|K–:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]šœ
žœ
˜Kš
œ˜Kš
œ˜Kš
œ&˜&Kš
œ8˜8K–:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]š
œ2˜2Kšœ'‘œ˜;Kšžœžœ
žœžœ˜MKšžœ
žœ
žœ)˜@Kš
œ˜šžœžœ
žœ žœžœ
ž˜DKš
œ4˜4Kšžœ
˜—K˜K˜—š
œžœ žœžœ
žœ˜gKšœžœ
žœ˜Kš
œ˜Kšœ
žœ
žœ	žœ%˜EKš
œ0˜0šžœžœ
žœ"žœ
žœ
ž˜PKšžœžœ
žœ
˜&Kš
œ2˜2KšœPžœ	˜\Kš
œF˜FKšžœ
˜—K˜K˜—Kšœžœžœ
˜šœžœ
žœ˜0K™PKš	œ
žœ
žœ
žœ
žœ˜#Kšœ
žœ
žœ˜Kšžœžœ
žœ
˜Kš
œ ˜ Kšœžœ
˜Kš
œ˜KšœžœŸA˜Wšžœ	žœ
žœ
žœ
žœ"žœžœ
ž˜Pšžœžœ
žœ!žœžœ
ž˜CKšžœžœ
žœ Ÿ!˜]Kšžœ
˜—Kšžœ
˜—šžœžœ
žœžœžœ
ž˜?Kšžœžœ
žœ Ÿ!˜]Kšžœ
˜—K˜K˜—šœžœ
žœžœ˜RKšœžœžœ˜4Kš
œM˜MKš
œl˜lKš
œc˜cKš
œl˜lKš
œi˜iK˜—K™šœŸ
™*K˜K˜—š
œžœ
žœFžœžœžœžœžœ˜Œ
Kšœ–
žœE™ή
šžœ	žœ
žœ%žœ
žœ
ž˜MKšœ
žœ$˜2Kš
œ™šžœžœ2žœžœ
žœžœ˜yKš
œ"˜"Kšžœ	žœ
žœ
˜K˜—K™šžœžœžœžœžœ!žœ˜yKš
œK˜KKšžœ	žœ
žœ
˜K˜—Jšžœ
˜—K˜K˜—šœžœ
žœmžœžœžœžœžœ˜»
Kšœ–
žœN™η
šžœžœ
žœHžœžœ
ž˜lKš
œ$˜$Kš
œ)˜)Kšœ
žœ!˜/Kš
œ™šžœžœ
žœžœžœ/žœ˜vKš
œ ˜ Kšžœ	žœ
žœ
˜K˜—Kš
œ™šžœžœžœžœžœžœ˜vKš
œ[˜[Kšžœ	žœ
žœ
˜K˜—Jšžœ
˜—K˜K˜—š
œžœ
žœ-žœžœžœ
žœ
žœ˜vKšœžœ
žœ˜š

œžœžœžœžœ˜CKš
œ=˜=K˜—Kš
œ.˜.Kš
œ8˜8K˜K˜—šœžœ
žœJžœžœžœžœ
žœ˜¨
Kšœžœ
žœ˜š

œžœžœžœžœ˜NKš
œN˜NK˜—Kš
œ;˜;Kš
œM˜MK˜K™—šœžœ
žœ-žœžœžœ	žœ	˜mš
œžœžœžœžœ˜=Kš
œ˜K˜—Kš
œ2˜2K˜K˜—šœžœ
žœJžœžœžœ	žœ	˜’
š
œžœžœžœžœ˜HKš
œ˜K˜—Kš
œG˜GK˜K˜—š
œžœJžœžœžœ˜š
š
œžœžœžœžœ˜QKš
œ˜Kšžœ
žœ˜
K˜—Kš
œP˜PK˜K˜—š
œžœJžœžœžœ˜™
š
œžœžœžœžœ˜PKš
œ˜K˜—Kš
œO˜OK˜K˜—š

œžœ
žœžœžœ˜9Kšžœžœ˜K˜K˜—K™™K™—šœžœ
žœžœ!˜VK™BKšœžœ
žœ
˜Kš
œ˜šžœžœ
žœ'žœžœ
ž˜Sšžœ-žœŸ˜TKšœžœ˜8šžœžœ
žœ-žœ
žœ
ž˜WKšœ1žœ˜6Kšœžœ˜Kšžœ
˜—K˜
—šžœ˜Kšœ1žœ˜6Kšœžœ˜K˜—Kšžœ
˜—šœ
žœ˜&Kš
œ
˜
K˜—K˜K˜—šœžœ
žœžœ!˜VK™CKšœžœ
žœ)™6Kšœžœ
žœ
˜Kš
œ˜šžœžœ
žœ'žœžœ
ž˜SKšœ1žœ˜6Kšœžœ˜Kšžœ
˜—šœ
žœ˜&Kš
œ
˜
K˜—K˜K˜—šœžœ
žœžœ˜HKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—K˜—K™šœžœ
žœžœ˜HKšœžœ™Kš
œA˜AKšœ0Ÿ"˜RK˜K˜—šœžœ
žœžœ˜HKšœžœ™Kš
œA˜AKšœ0Ÿ"˜RK˜—K™šœžœ
žœ<žœžœžœ˜‹
Kš
œ˜š
œžœžœžœžœ˜MKš
œ	˜	šžœ'˜)Kš
žœ&žœžœ
žœ
žœ˜MKš
žœ&žœžœ
žœ
žœ˜N—Kš
œ3˜3J˜—Kš
œ#˜#Kšœ, œ œ ˜IK˜K˜—šœžœ
žœBžœžœžœ˜
Kš
œ˜š
œžœžœžœžœ˜MKšœ‘œžœžœ
žœ
žœ˜YKš
œ3˜3J˜—Kš
œ#˜#Kšœ, œ œ ˜IK˜K˜—šœžœ
žœBžœžœžœ˜
Kš
œb™bKš
œ˜š
œžœžœžœžœ˜MKšœ‘œžœžœ
žœ
žœ˜YKš
œ3˜3J˜—Kš
œ#˜#Kšœ, œ œ ˜IK˜K˜—Kšœ
žœžœ
˜šœžœ
žœ”
žœ˜Ο
KšœŒ
žœ*žœ™Ϊ
K˜Kš
œ˜š
œžœžœžœžœ˜MKš
œ>™>Kš
œ4˜4Kšœ
Ÿœk˜pKš
œ5˜5Kš
œ7˜7Kš
œB˜BKš
œ3˜3J˜—Kšžœ
žœ
žœ)˜CKš
œ#˜#Kšœ, œ œ ˜IK˜—K˜™
K™—šœžœ
žœžœ˜Jš
œžœžœžœžœ˜R–h[slice: 
GGModelTypes.Slice, scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass]šžœ'žœ˜/K–:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]šœ6žœ˜;Kš‘œŸ˜1K˜
—šžœ˜Kšœžœ
žœ˜Kšœ
žœ'˜4Kš
œA˜AKšœ‘œ˜7Kš‘œ˜$Kš‘	œ˜&šžœžœ
žœžœžœ
ž˜BKš
œ4˜4Kšœ9ŸΕ
˜ώ
Kšžœ
˜—K˜—Jš
œ+˜+J˜—Jš
œ˜Jš
œ1˜1Kš
œ4˜4Kšœ, œ œ ˜FKš
œ˜K˜—š
œžœžœ
žœ
žœ˜gK™/Kš
œ!˜!šžœ"ž˜,Kšœ	žœ
˜˜
š

œžœžœžœžœ˜NJš
œ˜–h[slice: 
GGModelTypes.Slice, scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass]šžœ$žœ˜,K–:[scene: 
GGModelTypes.Scene, slice: 
GGModelTypes.Slice]˜Kšœ3žœ˜8KšœBŸ˜NK˜
—šžœ˜Kšœžœ
žœ˜Kšœ
žœ9˜FKš
œ4˜4Kš
œ5˜5Kš
œ@˜@K˜—Jš
œ+˜+J˜—Kšžœ$žœ
žœ
žœ˜=Kš
œ΄
™΄
Kš
œU˜UKšœžœ˜K˜—˜
Jš
œ˜Kš
œ˜K˜Kš
œ˜Kšœžœ
žœ˜ K˜Kš
œ˜Kš
œ˜KšœŸ#˜;Kš
œC˜Cšžœ
žœ
ž˜šžœ*žœ˜2šžœ$žœ˜,Kšœ‘œžœ˜=J˜
—šžœ˜Jšœ%‘œ	˜<Kš
œC˜CK˜—K˜
—šžœŸ˜Kšœ
žœžœ
˜K˜K˜Kš
œI˜IKš
œ6˜6Kšœ‘œžœ˜=šžœž˜Kšžœ<žœ˜E—K˜—Kšžœžœ
žœ
ž˜"šžœ˜Kš
œ<˜<Kš
œC˜CK˜—Kšžœ
˜—Kš	žœžœ
žœ
žœŸ˜VKš
œ&˜&Kš
œ1˜1K˜—šžœ˜Kšœžœ
˜K˜——K˜K˜—š
œžœ
žœ
žœžœ˜NKš
œ!˜!šžœžœ
žœžœžœ
ž˜BJšœKžœ˜QJšžœ
˜—K˜K˜—šœžœ
žœ˜.Kš
œV˜VKš
œA˜AK˜K˜—šœžœ
žœ˜1Kšœ&Ÿ&˜Lšžœžœ
žœ9žœžœ
ž˜]Kš
œ0˜0Jšžœ
˜—Kš
œA˜AK˜K˜—K˜šœžœ
žœH˜`K™Mš
œžœžœžœžœ˜Ašžœ&˜(Kšžœ7˜;—J˜—Kšœ$ œ ˜3K˜K˜—šœžœ
žœH˜eKš
œU™UKš
œ˜š
œžœžœžœžœ˜FKš
œ1˜1Kšžœžœ
žœ3˜HJ˜—Kšœ$ œ ˜8K˜K˜—K™#K™Kšœž	œ
˜š	œžœ
žœ
žœžœžœžœžœžœžœ˜nKšœ‘
žœq™…šžœžœ˜!Kš
œ˜Kšœ
žœ
˜K˜
—šžœ˜Kšžœ
žœžœ
žœ
˜Kšžœžœ
žœ
žœ
˜7Kš
œ˜Kšœ
žœ
˜K˜—K˜K˜—šœžœ
žœ
žœ˜1Kš
œ˜Kšžœ
˜K˜K˜K˜—Kšžœ
˜—…—t.«