DIRECTORY
GGBasicTypes, GGBoundBox, GGInterfaceTypes, GGModelTypes, GGOutline, GGScene, GGSceneType, GGSegmentTypes, GGSelect, GGSequence, GGSlice, GGTraj, GGUtility;

GGSelectImpl: CEDAR PROGRAM
IMPORTS GGBoundBox, GGOutline, GGScene, GGSelect, GGSequence, GGSlice, GGTraj, GGUtility
EXPORTS GGModelTypes, GGSelect = BEGIN

BoundBox: TYPE = GGBasicTypes.BoundBox;
Caret: TYPE = GGInterfaceTypes.Caret;
EntityGenerator: TYPE = REF EntityGeneratorObj;
EntityGeneratorObj: TYPE = GGModelTypes.EntityGeneratorObj;
Joint: TYPE = GGModelTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Outline: TYPE = GGModelTypes.Outline;
OutlineDescriptorGenerator: TYPE = GGModelTypes.OutlineDescriptorGenerator;
OutlineDescriptor: TYPE = REF OutlineDescriptorObj;
OutlineDescriptorObj: TYPE = GGModelTypes.OutlineDescriptorObj;
SceneRef: TYPE = REF SceneObj;
SceneObj: PUBLIC TYPE = GGSceneType.SceneObj;
SegAndIndex: TYPE = GGSequence.SegAndIndex;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SelectionClass: TYPE = GGInterfaceTypes.SelectionClass;
Sequence: TYPE = REF SequenceObj;
SequenceGenerator: TYPE = REF SequenceGeneratorObj;
SequenceGeneratorObj: TYPE = GGModelTypes.SequenceGeneratorObj;
SequenceObj: TYPE = GGModelTypes.SequenceObj;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceDescriptorGeneratorObj: TYPE = GGModelTypes.SliceDescriptorGeneratorObj;
SliceDescriptorObj: TYPE = GGModelTypes.SliceDescriptorObj;
SliceGenerator: TYPE = REF SliceGeneratorObj;
SliceGeneratorObj: TYPE = GGModelTypes.SliceGeneratorObj;
SliceParts: TYPE = GGModelTypes.SliceParts;
Traj: TYPE = GGModelTypes.Traj;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajGenerator: TYPE = REF TrajGeneratorObj;
TrajGeneratorObj: TYPE = GGModelTypes.TrajGeneratorObj;

NotYetImplemented: PUBLIC SIGNAL = CODE;

OutlineSequenceGenerator: TYPE = REF OutlineSequenceGeneratorObj;
OutlineSequenceGeneratorObj: TYPE = GGSelect.OutlineSequenceGeneratorObj;
OutlineSequence: TYPE = REF OutlineSequenceObj;
OutlineSequenceObj: TYPE = GGSelect.OutlineSequenceObj;



ChangeDonkeyTail: PROC [sliceD: SliceDescriptor, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => sliceD.slice.normalSelectedParts _ sliceD;
hot => sliceD.slice.hotSelectedParts _ sliceD;
active => sliceD.slice.activeSelectedParts _ sliceD;
ENDCASE;
};

NoDonkeyTail: PROC [slice: Slice, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => slice.normalSelectedParts _ NIL;
hot => slice.hotSelectedParts _ NIL;
active => slice.activeSelectedParts _ NIL;
ENDCASE;
};


SelectAll: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] = {
sliceGen: SliceGenerator _ GGScene.TopLevelSlicesInScene[scene];
FOR slice: Slice _ GGScene.NextSlice[sliceGen], GGScene.NextSlice[sliceGen] UNTIL slice = NIL DO
SelectEntireSlice[slice, scene, selectClass];
ENDLOOP;
};

SelectSlice: PUBLIC PROC [sliceD: SliceDescriptor, scene: SceneRef, selectClass: SelectionClass] = {
oldSliceD, union: SliceDescriptor;
slice: Slice _ sliceD.slice;
IF slice.class.isEmptyParts[sliceD] THEN RETURN;
oldSliceD _ FindSelectedSlice[slice, scene, selectClass];
IF oldSliceD#NIL THEN {
union _ slice.class.unionParts[oldSliceD, sliceD];
DeselectSlice[slice, oldSliceD.parts, scene, selectClass]; -- throw away old selection
}
ELSE union _ sliceD;
IF selectClass = normal THEN union _ slice.class.augmentParts[union, selectClass];
AppendSelection[scene, union, selectClass];
ChangeDonkeyTail[union, selectClass];
}; -- end SelectSlice

SelectEntireSlice: PUBLIC PROC [slice: Slice, scene: SceneRef, selectClass: SelectionClass] = {
allParts: SliceDescriptor _ slice.class.newParts[slice, NIL, slice];
SelectSlice[allParts, scene, selectClass];
};
SelectSequence: PUBLIC PROC [seq: Sequence, scene: SceneRef, selectClass: SelectionClass] = {
outline: Outline _ GGOutline.OutlineOfTraj[seq.traj];
parts: SliceParts;
seqD: OutlineDescriptor;
IF GGSequence.IsEmpty[seq] THEN RETURN;
parts _ GGOutline.PartsFromSequence[outline, seq];
seqD _ GGSlice.DescriptorFromParts[outline, parts];
SelectSlice[seqD, scene, selectClass];
};

SelectTraj: PUBLIC PROC [traj: Traj, scene: SceneRef, selectClass: SelectionClass] = {
wholeSeq: Sequence;
wholeSeq _ GGSequence.CreateComplete[traj];
SelectSequence[wholeSeq, scene, selectClass];
};

DuplicateSelections: PROC [scene: SceneRef, fromClass: SelectionClass, toClass: SelectionClass] = {
sliceDescGen: GGSelect.SliceDescriptorGenerator;
seqGen: SequenceGenerator;
sliceDescGen _ SelectedSlices[scene, fromClass];
FOR sliceD: SliceDescriptor _ NextSliceDescriptor[sliceDescGen], NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
SelectSlice[sliceD, scene, toClass];
ENDLOOP;
seqGen _ SelectedSequences[scene, fromClass];
FOR seq: Sequence _ GGSequence.NextSequence[seqGen], GGSequence.NextSequence[seqGen] UNTIL seq = NIL DO
SelectSequence[seq, scene, toClass];
ENDLOOP;
};

DeselectAll: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] = {
FOR sliceD: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], sliceD.rest UNTIL sliceD = NIL DO
NoDonkeyTail[sliceD.first.slice, selectClass];
ENDLOOP;
SetSelectedList[scene, NIL, selectClass];
};

DeselectEntity: PUBLIC PROC [entity: REF ANY, scene: SceneRef, selectClass: SelectionClass] = {
WITH entity SELECT FROM
seq: Sequence => DeselectSequence[seq, scene, selectClass];
traj: Traj => DeselectTraj[traj, scene, selectClass];
slice: Slice => DeselectEntireSlice[slice, scene, selectClass];
sliceD: SliceDescriptor => DeselectSlice[sliceD.slice, sliceD.parts, scene, selectClass];
ENDCASE => ERROR;
};

DeselectEntityAllClasses: PUBLIC PROC [entity: REF ANY, scene: SceneRef] = {
DeselectEntity[entity, scene, normal];
DeselectEntity[entity, scene, active];
DeselectEntity[entity, scene, hot];
};

DeselectAllAllClasses: PUBLIC PROC [scene: SceneRef] = {
DeselectAll[scene, normal];
DeselectAll[scene, active];
DeselectAll[scene, hot];
};

DeselectEntireSlice: PUBLIC PROC [slice: Slice, scene: SceneRef, selectClass: SelectionClass] = {
sliceD: SliceDescriptor _ FindSelectedSlice[slice, scene, selectClass];
IF sliceD # NIL THEN {
DeleteSelection[scene, sliceD, selectClass];
NoDonkeyTail[sliceD.slice, selectClass];
};
};

DeselectSlice: PUBLIC PROC [slice: Slice, parts: SliceParts, scene: SceneRef, selectClass: SelectionClass] = {
oldD, newD, tempD: SliceDescriptor;
oldD _ FindSelectedSlice[slice, scene, selectClass];
IF oldD # NIL THEN {
tempD _ GGSlice.DescriptorFromParts[slice, parts];
newD _ slice.class.differenceParts[oldD, tempD];
DeleteSelection[scene, oldD, selectClass];
NoDonkeyTail[oldD.slice, selectClass];
IF NOT slice.class.isEmptyParts[newD] THEN {
IF selectClass = normal THEN newD _ slice.class.augmentParts[newD, selectClass];
AppendSelection[scene, newD, selectClass];
ChangeDonkeyTail[newD, selectClass];
};
};
};

DeselectSequence: PUBLIC PROC [seq: Sequence, scene: SceneRef, selectClass: SelectionClass] = {
outline: Outline _ GGOutline.OutlineOfTraj[seq.traj];
seqParts: SliceParts _ GGOutline.PartsFromSequence[outline, seq];
DeselectSlice[outline, seqParts, scene, selectClass];
};

DeselectTraj: PUBLIC PROC [traj: Traj, scene: SceneRef, selectClass: SelectionClass] = {
outline: Outline _ GGOutline.OutlineOfTraj[traj];
oldD, newD: OutlineDescriptor;
oldD _ FindSelectedSlice[outline, scene, selectClass];
IF oldD # NIL THEN {
newD _ GGOutline.RemoveTraj[oldD, traj];
DeleteSelection[scene, oldD, selectClass];
NoDonkeyTail[outline, selectClass];
IF NOT outline.class.isEmptyParts[newD] THEN {
AppendSelection[scene, newD, selectClass];
ChangeDonkeyTail[newD, selectClass];
};
};
};

ReselectTraj: PUBLIC PROC [traj: Traj, trajEnd: TrajEnd, scene: SceneRef, extend: BOOL] RETURNS [newHot: Sequence] = {
selSeq, newSeq: Sequence;
selSeq _ FindSelectedSequence[traj, scene, normal];
IF selSeq # NIL THEN {
newSeq _ GGSequence.Augment[selSeq, trajEnd, extend];
DeselectTraj[selSeq.traj, scene, normal];
SelectSequence[newSeq, scene, normal];
};
selSeq _ FindSelectedSequence[traj, scene, hot];
IF selSeq # NIL THEN {
newHot _ newSeq _ GGSequence.Augment[selSeq, trajEnd, extend];
DeselectTraj[selSeq.traj, scene, hot];
SelectSequence[newSeq, scene, hot];
};
selSeq _ FindSelectedSequence[traj, scene, active];
IF selSeq # NIL THEN {
ERROR; -- I don't think ReselectTraj should be used for active
};
};

DeleteSelection: PROC [scene: SceneRef, entity: SliceDescriptor, selectClass: SelectionClass] = {
SetSelectedList[scene,
DRemove[entity, ListSelected[scene, selectClass]],
selectClass];
};

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


SetJointField: PROC [joint: Joint, selected: BOOL, selectClass: SelectionClass]  = {
SELECT selectClass FROM
normal => joint.TselectedInFull.normal _ selected;
hot => joint.TselectedInFull.hot _ selected;
active => joint.TselectedInFull.active _ selected;
ENDCASE;
};


SetSegmentField: PROC [seg: Segment, selected: BOOL, selectClass: SelectionClass]  = {
SELECT selectClass FROM
normal => seg.TselectedInFull.normal _ selected;
hot => seg.TselectedInFull.hot _ selected;
active => seg.TselectedInFull.active _ selected;
ENDCASE;
};

AppendSelection: PROC [scene: SceneRef, entity: SliceDescriptor, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => scene.selected.normal _ Nconc[scene.selected.normal, LIST[entity]];
hot => scene.selected.hot _ Nconc[scene.selected.hot, LIST[entity]];
active => scene.selected.active _ Nconc[scene.selected.active, LIST[entity]];
ENDCASE => ERROR;
};

SetSelectedList: PROC [scene: SceneRef, value: LIST OF SliceDescriptor, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => scene.selected.normal _ value;
hot => scene.selected.hot _ value;
active => scene.selected.active _ value;
ENDCASE => ERROR;
};


IsSelectedInFull: PUBLIC PROC [slice: Slice, scene: SceneRef, selectClass: SelectionClass] RETURNS [BOOL] = {
donkeyTail: SliceDescriptor _ SELECT selectClass FROM
active => slice.activeSelectedParts,
hot => slice.hotSelectedParts,
normal => slice.normalSelectedParts,
ENDCASE => ERROR;
IF donkeyTail = NIL THEN RETURN[FALSE];
RETURN[slice.class.isCompleteParts[donkeyTail]];
};

IsSelectedInPart: PUBLIC PROC [entity: REF ANY, scene: SceneRef, selectClass: SelectionClass] RETURNS [BOOL] = {
WITH entity SELECT FROM
slice: Slice => {
sliceD: SliceDescriptor;
sliceD _ FindSelectedSlice[slice, scene, selectClass];
RETURN[sliceD # NIL];
};
traj: Traj => {
seq: Sequence;
seq _ FindSelectedSequence[traj, scene, selectClass];
RETURN[seq # NIL];
};
seq: Sequence => {
selSeq: Sequence;
selSeq _ FindSelectedSequence[seq.traj, scene, selectClass];
IF selSeq = seq THEN RETURN[TRUE];
IF selSeq = NIL THEN RETURN[FALSE];
RETURN[GGSequence.Overlap[seq, selSeq]];
};
ENDCASE => ERROR;
};
NoSelections: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [BOOL] = {
SELECT selectClass FROM
normal => RETURN[scene.selected.normal = NIL];
hot => RETURN[scene.selected.hot = NIL];
active => RETURN[scene.selected.active = NIL];
ENDCASE => ERROR;
};

FindSelectedSequence: PUBLIC PROC [traj: Traj, scene: SceneRef, selectClass: SelectionClass] RETURNS [seq: Sequence] = {
FOR sliceDList: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], sliceDList.rest UNTIL sliceDList = NIL DO
sliceD: SliceDescriptor _ sliceDList.first;
seq _ IF sliceD.slice.class.type=$Outline THEN GGOutline.FindTrajInDescriptor[sliceD, traj]
ELSE NIL;
IF seq # NIL THEN RETURN[seq];
ENDLOOP;
RETURN[NIL];
};

FindSequenceInList: PUBLIC PROC [traj: Traj, selectedList: LIST OF SliceDescriptor] RETURNS [seq: Sequence] = {
FOR sliceDList: LIST OF SliceDescriptor _ selectedList, sliceDList.rest UNTIL sliceDList = NIL DO
sliceD: SliceDescriptor _ sliceDList.first;
seq _ IF sliceD.slice.class.type=$Outline THEN GGOutline.FindTrajInDescriptor[sliceD, traj] 
ELSE NIL;
IF seq # NIL THEN RETURN[seq];
ENDLOOP;
RETURN[NIL];
};

SelectedSequences: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [seqGen: SequenceGenerator] = {
ptr, seqList: LIST OF Sequence;
seqGen _ NEW[SequenceGeneratorObj];
[seqGen.list, ptr] _ GGUtility.StartSequenceList[];
FOR sliceDList: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], sliceDList.rest UNTIL sliceDList = NIL DO
IF sliceDList.first.slice.class.type=$Outline THEN {
seqList _ GGOutline.SequencesOfOutline[sliceDList.first];
FOR list: LIST OF Sequence _ seqList, list.rest UNTIL list = NIL DO
[seqGen.list, ptr] _ GGUtility.AddSequence[list.first, seqGen.list, ptr];
ENDLOOP;
};
ENDLOOP;
};

SelectedOutlines: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [outDGen: OutlineDescriptorGenerator] = {
sliceD: OutlineDescriptor _ NIL;
ptr: LIST OF OutlineDescriptor _ NIL;
outDGen _ NEW[GGModelTypes.OutlineDescriptorGeneratorObj];
FOR sliceDList: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], sliceDList.rest UNTIL sliceDList = NIL DO
IF sliceDList.first.slice.class.type=$Outline THEN {
[outDGen.list, ptr] _ AddSliceDescriptor[sliceDList.first, outDGen.list, ptr];
};
ENDLOOP;
};

FindSelectedSlice: PUBLIC PROC [slice: Slice, scene: SceneRef, selectClass: SelectionClass] RETURNS [sliceD: SliceDescriptor] = {
SELECT selectClass FROM
normal => sliceD _ slice.normalSelectedParts;
hot => sliceD _ slice.hotSelectedParts;
active => sliceD _ slice.activeSelectedParts;
ENDCASE => ERROR;
};

SelectedSlices: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [sliceDescGen: SliceDescriptorGenerator] = {
ptr: LIST OF SliceDescriptor _ NIL;
sliceDescGen _ NEW[SliceDescriptorGeneratorObj];
FOR sliceDList: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], sliceDList.rest UNTIL sliceDList = NIL DO
[sliceDescGen.list, ptr] _ AddSliceDescriptor[sliceDList.first, sliceDescGen.list, ptr];
ENDLOOP;
};

NextSliceDescriptor: PUBLIC PROC [g: SliceDescriptorGenerator] RETURNS [next: SliceDescriptor] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};


AddSliceDescriptor: PROC [entity: SliceDescriptor, entityList, ptr: LIST OF SliceDescriptor] RETURNS [newList, newPtr: LIST OF SliceDescriptor] = {
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;
};
};


nilSeqGen: SequenceGenerator _ NEW[SequenceGeneratorObj _ [list: NIL]];
SelectedOutlineSequences: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [outSeqGen: OutlineSequenceGenerator] = {
holeSeqs, ptr: LIST OF Sequence;
outSeqPtr: LIST OF OutlineSequence;
outlineSeq: OutlineSequence;
fenceSeq, seq: Sequence;
sliceDescGen: SliceDescriptorGenerator;
seqList: LIST OF Sequence;
newSeqGen: SequenceGenerator;

outSeqGen _ NEW[OutlineSequenceGeneratorObj];
[outSeqGen.list, outSeqPtr] _ StartOutlineSequenceList[];
sliceDescGen _ SelectedSlices[scene, selectClass];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
IF sliceD.slice.class.type=$Outline THEN  {
fenceSeq _ NIL;
[holeSeqs, ptr] _ GGUtility.StartSequenceList[];
seqList _ GGOutline.SequencesOfOutline[sliceD];
seq _ seqList.first;
IF seq.traj.role = fence OR seq.traj.role = open THEN {
fenceSeq _ seq;
seqList _ seqList.rest;
};
FOR list: LIST OF Sequence _ seqList, list.rest UNTIL list = NIL DO
[holeSeqs, ptr] _ GGUtility.AddSequence[list.first, holeSeqs, ptr];
ENDLOOP;
newSeqGen _ IF holeSeqs=NIL THEN nilSeqGen ELSE NEW[SequenceGeneratorObj _ [list: holeSeqs]];
outlineSeq _ NEW[OutlineSequenceObj _ [outline: sliceD.slice, fenceSeq: fenceSeq, holeSeqs: newSeqGen]];
[outSeqGen.list, outSeqPtr] _ AddOutlineSequence[outlineSeq, outSeqGen.list, outSeqPtr];
};
ENDLOOP;
};

NextOutlineSequences: PUBLIC PROC [outSeqGen: OutlineSequenceGenerator] RETURNS [outSeq: OutlineSequence] = {
IF outSeqGen.list = NIL THEN RETURN[NIL];
outSeq _ outSeqGen.list.first;
outSeqGen.list _ outSeqGen.list.rest;
};

AddOutlineSequence: PUBLIC PROC [entity: OutlineSequence, entityList, ptr: LIST OF OutlineSequence] RETURNS [newList, newPtr: LIST OF OutlineSequence] = {
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;
};
};

StartOutlineSequenceList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF OutlineSequence] = {
ptr _ entityList _ NIL;
};


ForEachOutlineRun: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass, runProc: RunProc, segmentsOnly: BOOL _ TRUE, selectNewRuns: BOOL _ FALSE] RETURNS [bBox: BoundBox] = {
outSeqGen: OutlineSequenceGenerator;
fenceSeq: Sequence;
thisBox: BoundBox;
bBox _ GGBoundBox.BoundBoxOfSelected[scene, normal];
DuplicateSelections[scene, normal, active]; -- all normal selected objects become active
outSeqGen _ SelectedOutlineSequences[scene, active];
WHILE outSeqGen.list # NIL DO -- while any active objects remain.
FOR outSeq: GGSelect.OutlineSequence _ NextOutlineSequences[outSeqGen], NextOutlineSequences[outSeqGen] UNTIL outSeq = NIL DO
fenceSeq _ outSeq.fenceSeq;
IF fenceSeq # NIL THEN {
thisBox _ GetRunAndReplace[fenceSeq, scene, runProc, segmentsOnly, selectNewRuns];
GGBoundBox.EnlargeByBox[bBox: bBox, by: thisBox];
GOTO SelectionsHaveChanged;
};
FOR holeSeq: Sequence _ GGSequence.NextSequence[outSeq.holeSeqs], GGSequence.NextSequence[outSeq.holeSeqs] UNTIL holeSeq = NIL DO
thisBox _ GetRunAndReplace[holeSeq, scene, runProc, segmentsOnly, selectNewRuns];
GGBoundBox.EnlargeByBox[bBox: bBox, by: thisBox];
GOTO SelectionsHaveChanged;
ENDLOOP;
REPEAT
SelectionsHaveChanged => {
outSeqGen _ SelectedOutlineSequences[scene, active];
};
ENDLOOP;
ENDLOOP;
};


RunProc: TYPE = GGSelect.RunProc;
GetRunAndReplace: PROC [seq: Sequence, scene: SceneRef, runProc: RunProc, segmentsOnly: BOOL, selectNewRuns: BOOL] RETURNS [bBox: BoundBox] = {
oldOutline: Outline;
runGen: SequenceGenerator;
runCount: NAT;
newRun: Traj;
newOutlines: LIST OF Outline;
run: Sequence;
oldOutline _ GGOutline.OutlineOfTraj[seq.traj];
GGOutline.SaveSelectionsInOutline[oldOutline, scene];
IF GGSequence.IsComplete[seq] THEN run _ seq
ELSE {
[runGen, runCount] _ GGSequence.RunsInSequence[seq];
IF runCount = 0 THEN {
DeselectSequence[seq, scene, active]; -- maintain the important invariant
bBox _ GGBoundBox.emptyBoundBox;
RETURN; -- The sequence has only control points.
};
run _ GGSequence.NextSequence[runGen];
IF run = NIL THEN ERROR;
};
IF run.segCount>0 OR NOT segmentsOnly THEN {
newRun _ runProc[run];
IF newRun # NIL THEN {
SetSelectionBits[newRun, FALSE, active]; -- don't process run twice
IF selectNewRuns THEN SetSelectionBits[newRun, TRUE, normal];
};
[newOutlines: newOutlines] _ ReplaceRun[run, newRun, scene];
bBox _ BoundBoxOfOutlines[newOutlines];
DeselectEntityAllClasses[oldOutline, scene];
FOR list: LIST OF Outline _ newOutlines, list.rest UNTIL list = NIL DO
GGOutline.RemakeSelectionsFromOutline[list.first, scene];
ENDLOOP;
}
ELSE {
DeselectSequence[seq, scene, active]; -- maintain the important invariant
bBox _ GGBoundBox.emptyBoundBox;
};
};

ReplaceRun: PROC [run: Sequence, newRun: Traj, scene: SceneRef] RETURNS [newOutlines: LIST OF Outline, newTraj: Traj _ NIL] = {
IF newRun = NIL THEN [----, newOutlines] _ GGScene.DeleteSequence[run, scene]
ELSE {
newTraj _ GGTraj.SpliceIn[run, newRun];
newOutlines _ LIST[newTraj.parent];
GGScene.DeleteOutline[scene, GGOutline.OutlineOfTraj[run.traj]];
GGScene.AddOutline[scene, newTraj.parent, -1];
};
};

SubstituteForSegment: PUBLIC PROC [traj: Traj, segNum: NAT, newRun: Traj, scene: SceneRef] RETURNS [bBox: BoundBox, newTraj: Traj] = {
newOutlines: LIST OF Outline;
replaceSeq: Sequence _ GGSequence.CreateFromSegment[traj, segNum];
GGOutline.SaveSelectionsInOutline[traj.parent, scene];
DeselectTraj[traj, scene, normal];
DeselectTraj[traj, scene, hot];
[newOutlines, newTraj] _ ReplaceRun[replaceSeq, newRun, scene];
FOR list: LIST OF Outline _ newOutlines, list.rest UNTIL list = NIL DO
GGOutline.RemakeSelectionsFromOutline[list.first, scene];
ENDLOOP;
bBox _ BoundBoxOfOutlines[newOutlines];
};

SetSelectionBits: PUBLIC PROC [traj: Traj, selected: BOOL, selectClass: SelectionClass] = {
segGen: GGModelTypes.SegmentGenerator;
jointGen: GGModelTypes.JointGenerator;
joint: Joint;
segGen _ GGSequence.SegmentsInTraj[traj];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
SetSegmentField[seg, selected, selectClass];
FOR i: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
seg.class.controlPointFieldSet[seg, i, selected, selectClass];
ENDLOOP;
ENDLOOP;
jointGen _ GGSequence.JointsInTraj[traj];
FOR jointNum: INT _ GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL jointNum = -1 DO
joint _ GGTraj.FetchJoint[traj, jointNum];
SetJointField[joint, selected, selectClass];
ENDLOOP;
};


BoundBoxOfOutlines: PROC [outlines: LIST OF Outline] RETURNS [bBox: BoundBox] = {
bBox _ GGBoundBox.NullBoundBox[];
FOR list: LIST OF Outline _ outlines, list.rest UNTIL list = NIL DO
GGBoundBox.EnlargeByBox[bBox: bBox, by: list.first.boundBox];
ENDLOOP;
};

SliceProc: TYPE = GGSelect.SliceProc;
OutlineProc: TYPE = GGSelect.OutlineProc;

DoForEachSelectedSlice: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass, sliceProc: SliceProc] = {
sliceDescGen: SliceDescriptorGenerator _ SelectedSlices[scene, selectClass];
FOR sliceD: SliceDescriptor _ NextSliceDescriptor[sliceDescGen], NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
sliceProc[sliceD];
ENDLOOP;
};

DRemove: PROC [ref: SliceDescriptor, list: LIST OF SliceDescriptor] RETURNS[LIST OF SliceDescriptor] =  {
l, l1: LIST OF SliceDescriptor _ NIL;
l _ list;
UNTIL l = NIL DO
IF l.first=ref THEN {
IF l1 = NIL THEN RETURN[l.rest]; -- ref was first object on list
l1.rest _ l.rest;
RETURN[list];
};
l1 _ l;
l _ l.rest;
ENDLOOP;
RETURN [list];
};

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

END.
6GGSelectImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last edited by Bier on May 13, 1987 5:36:56 pm PDT
Contents:  Procedures dealing selecting and deselecting objects, including both selection actions and selection feedback.
Pier, May 14, 1987 4:04:00 pm PDT
Kurlander August 28, 1986 7:54:12 pm PDT

Implementation Notes (updated November 16, 1986, by Bier)
The Selection mechanism maintains two "structures" which must be kept consistent.  The first is a list of selected entities: scene.selected.  The second is the set of "selectedInFull" fields in each of the selected objects.  The following types of entities can appear on scene.selected: SliceDescriptor, and OutlineDescriptor.
To efficiently answer IsSelectedInFull queries, "selectedInFull" fields are found in slices, segments, joints, and control points.  IsSelectedInFull is expensive for trajectories, more expensive for outlines, and even more expensive for Gargoyle slices.
To efficiently answer IsSelectedInPart queries, the selectedInFull field does double duty in segments, joints, control points, and slices.  IsSelectedInPart is somewhat expensive for outlines.
The following invariants should be maintained:
1)  If an OutlineDescriptor is on the selected list, all of the selectedInFull fields of its joints, segments, and control points should be TRUE.  The selected fields are maintained for efficiency only.  The information they represent is always obtainable from the selected list as well.
Converse of 1:  If no sequence representing a given joint, segment, or control point is on the selected list, then the selectedInFull field of that entity should be FALSE.
2)  Only one sequence per trajectory may appear on the selected list.
Corollary of 1 and 2:  Any given selected flag is caused by a single element of the selected list.  GetSelectedSequence will find that element (for joint, segments, and control points).  A selected slice is its own cause.
3)  A non-gargoyle slice may only appear once on the selected list.
4)  Iff a sequence representing a trajectory is on the selected list, the "selectedInPart" field of the trajectory will TRUE.
5)  Iff a non-Gargoyle slice is on the selected list, the "selectedInFull" field of that slice will be true.
These invariants will be maintained with the help of SetComponentSelectedFields.

SetComponentSelectedFields: PROC [entity: REF ANY, selected: BOOL, selectClass: SelectionClass] = {
WITH entity SELECT FROM
sliceD: SliceDescriptor => {
SetSliceField[sliceD.slice, selected, selectClass];
};
outlineD: OutlineDescriptor => {
outlineD.slice.class.setSelectedFields[outlineD, selected, selectClass];
};
traj: Traj => { -- this case needed for ReselectTraj
joint: Joint;
jointGen: JointGenerator;
segGen: SegmentGenerator;
jointGen _ GGSequence.JointsInTraj[traj];
Joint Fields.
FOR jointNum: INT _ GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL jointNum = -1 DO
joint _ NARROW[Rosary.Fetch[traj.joints, jointNum]];
SetJointField[joint, selected, selectClass];
ENDLOOP;
Segment Fields.
segGen _ GGSequence.SegmentsInTraj[traj];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
SetSegmentField[seg, selected, selectClass];
ENDLOOP;
};
ENDCASE => ERROR;
};

Basic Selecting and Deselecting

ChangeDonkeyTailOutline: PROC [sliceD: OutlineDescriptor, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => sliceD.slice.normalSelectedParts _ sliceD;
hot => sliceD.slice.hotSelectedParts _ sliceD;
active => sliceD.slice.activeSelectedParts _ sliceD;
ENDCASE;
};

NoDonkeyTailOutline: PROC [slice: Outline, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => slice.normalSelectedParts _ NIL;
hot => slice.hotSelectedParts _ NIL;
active => slice.activeSelectedParts _ NIL;
ENDCASE;
};

SelectOutline: PUBLIC PROC [sliceD: OutlineDescriptor, scene: SceneRef, selectClass: SelectionClass] = {
oldD, union: OutlineDescriptor;
slice: Outline _ sliceD.slice;
IF slice.class.emptyParts[sliceD] THEN RETURN;
oldD _ FindSelectedOutline[slice, scene, selectClass];
IF oldD # NIL THEN {
union _ slice.class.unionParts[oldD, sliceD];
DeselectOutline[slice, oldD.parts, scene, selectClass];  -- throw away old selection
}
ELSE union _ sliceD;
IF selectClass = normal THEN union _ slice.class.augmentParts[union, selectClass];
AppendSelection[scene, union, selectClass];
ChangeDonkeyTailOutline[union, selectClass];
}; -- end SelectOutline

SelectEntireOutline: PUBLIC PROC [outline: Outline, scene: SceneRef, selectClass: SelectionClass] = {
allParts: OutlineDescriptor _ outline.class.newParts[outline, NIL, slice];
SelectOutline[allParts, scene, selectClass];
SelectEntireSlice[outline, scene, selectClass];
};


traj is now selected.  This overrides any selections on traj's parts.

Clear all flags that indicate the selection of each object.
SetComponentSelectedFields[selected.first, FALSE, selectClass];
outline: Outline => DeselectEntireOutline[outline, scene, selectClass];
outlineD: OutlineDescriptor => DeselectOutline[outlineD.slice, outlineD.parts, scene, selectClass];
DeselectEntireSliceOLDD: PUBLIC PROC [slice: Slice, scene: SceneRef, selectClass: SelectionClass] = {
If this is a non-gargoyle slice, then make sure it is on the list, and take it off.
selSliceD: SliceDescriptor _ FindSelectedSlice[slice, scene, selectClass];
IF selSliceD#NIL THEN {
IF selSliceD.slice.class.type = $Outline THEN ERROR NotYetImplemented;
DeleteSelection[scene, selSliceD, selectClass];
NoDonkeyTail[selSliceD.slice, selectClass];
SetComponentSelectedFields[selSliceD, FALSE, selectClass];
};
};

Remove this slice from the selected list, and reset all selected fields.
DeselectOutline: PUBLIC PROC [outline: Outline, parts: SliceParts, scene: SceneRef, selectClass: SelectionClass] = {
Deselect each of the component trajectories;
oldD, newD, tempD: OutlineDescriptor;
oldD _ FindSelectedOutline[outline, scene, selectClass];
IF oldD # NIL THEN {
tempD _ GGOutline.DescriptorFromParts[outline, parts];
newD _ outline.class.differenceParts[oldD, tempD];
DeleteSelection[scene, oldD, selectClass];
NoDonkeyTailOutline[outline, selectClass];
IF NOT outline.class.emptyParts[newD] THEN {
IF selectClass = normal THEN newD _ outline.class.augmentParts[newD, selectClass];
AppendSelection[scene, newD, selectClass];
ChangeDonkeyTailOutline[newD, selectClass];
};
};
};

DeselectEntireOutline: PUBLIC PROC [outline: Outline, scene: SceneRef, selectClass: SelectionClass] = {
Remove this outline from the selected list, and reset all selected fields.
outlineD: OutlineDescriptor _ FindSelectedOutline[outline, scene, selectClass];
IF outlineD # NIL THEN {
DeleteSelection[scene, outlineD, selectClass];
NoDonkeyTailOutline[outlineD.slice, selectClass];
};
};

Very much like DeselectOutline, but optimized for the single Traj case.

Updating Selections When Sequences Become Obsolete

normal selections
hot selections
active selections
Utilities

Deletes entity from list.  If it is not on the list, do nothing.
ListSelectedSequences: PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [selectedList: LIST OF Sequence] = {
This can be sped up by keeping separate lists for the different types of selected object.
seq: Sequence;
selectedList _ NIL;
FOR entityList: LIST OF REF ANY _ ListSelected[scene, selectClass], entityList.rest UNTIL entityList = NIL DO
IF ISTYPE[entityList.first, Sequence] THEN {
seq _ NARROW[entityList.first];
selectedList _ CONS[seq, selectedList];
};
ENDLOOP;
};
Operations which dispatch on the SelectionClass:

SetSliceField: PROC [slice: Slice, selected: BOOL, selectClass: SelectionClass]  = {
SELECT selectClass FROM
normal => slice.selectedInFull.normal _ selected;
hot => slice.selectedInFull.hot _ selected;
active => slice.selectedInFull.active _ selected;
ENDCASE;
};

Build the selection list in the proper order and keep it that way.
Enumerate Selected Objects
IsSelectedInFullOLDD: PUBLIC PROC [entity: REF ANY, scene: SceneRef, selectClass: SelectionClass] RETURNS [BOOL] = {
WITH entity SELECT FROM
slice: Slice => {
IF slice.class.type = $Outline THEN ERROR NotYetImplemented;
SELECT selectClass FROM
normal => RETURN[slice.selectedInFull.normal];
hot => RETURN[slice.selectedInFull.hot];
active => RETURN[slice.selectedInFull.active];
ENDCASE => ERROR;
};
outline: Outline => {
trajGen: TrajGenerator;
trajGen _ GGOutline.TrajsInOutline[outline];
FOR traj: Traj _ GGScene.NextTraj[trajGen], GGScene.NextTraj[trajGen] UNTIL traj = NIL DO
IF NOT IsSelectedInFull[traj, scene, selectClass] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};
traj: Traj => {
seq: Sequence;
seq _ FindSelectedSequence[traj, scene, selectClass];
IF seq = NIL THEN RETURN[FALSE];
RETURN[GGSequence.IsComplete[seq]];
};
ENDCASE => ERROR;
};

Returns TRUE if all or part of entity is selected.  These are the cases:
1)  entity is a slice.  Some outline is selected all or in part.
2)  entity is an outline.  Some trajectory is selected all or in part.
3)  entity is a trajectory.  Some joint or segment is selected.
4)  entity is a sequence.  Some joint or segment is selected.
outline: Outline => {
outlineD: OutlineDescriptor;
outlineD _ FindSelectedOutline[outline, scene, selectClass];
RETURN[outlineD # NIL]
};

FindSelectedOutline: PUBLIC PROC [outline: Outline, scene: SceneRef, selectClass: SelectionClass] RETURNS [outlineD: OutlineDescriptor] = {
SELECT selectClass FROM
normal => outlineD _ IF outline.normalSelectedParts = NIL THEN NIL ELSE outline.normalSelectedParts;
hot => outlineD _ IF outline.hotSelectedParts = NIL THEN NIL ELSE outline.hotSelectedParts;
active => outlineD _ IF outline.activeSelectedParts = NIL THEN NIL ELSE outline.activeSelectedParts;
ENDCASE => ERROR;
};

SelectedStuff: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [sliceDescGen: SliceDescriptorGenerator] = {
ptr: LIST OF SliceDescriptor _ NIL;
sliceDescGen _ NEW[SliceDescriptorGeneratorObj];
FOR sliceDList: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], sliceDList.rest UNTIL sliceDList = NIL DO
[sliceDescGen.list, ptr] _ AddSliceDescriptor[sliceDList.first, sliceDescGen.list, ptr];
ENDLOOP;
};

SelectedSlices: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [sliceDescGen: SliceDescriptorGenerator] = {
sliceD: SliceDescriptor _ NIL;
ptr: LIST OF SliceDescriptor _ NIL;
sliceDescGen _ NEW[SliceDescriptorGeneratorObj];
FOR entityList: LIST OF REF ANY _ ListSelected[scene, selectClass], entityList.rest UNTIL entityList = NIL DO
IF ISTYPE[entityList.first, SliceDescriptor] THEN {
sliceD _ NARROW[entityList.first];
[sliceDescGen.list, ptr] _ AddSliceDescriptor[sliceD, sliceDescGen.list, ptr];
};
ENDLOOP;
};

NextOutlineDescriptor: PUBLIC PROC [g: OutlineDescriptorGenerator] RETURNS [next: OutlineDescriptor] = {
IF g.list = NIL THEN RETURN[NIL]
ELSE {
next _ g.list.first;
g.list _ g.list.rest;
};
};
AddOutlineDescriptor: PROC [entity: OutlineDescriptor, entityList, ptr: LIST OF OutlineDescriptor] RETURNS [newList, newPtr: LIST OF OutlineDescriptor] = {
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;
};
};
SelectedOutlineSequencesOLDD: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass] RETURNS [outSeqGen: OutlineSequenceGenerator] = {
Returns a generator for all selected sequences, grouped by outline.
holeSeqs, ptr: LIST OF Sequence;
outSeqPtr: LIST OF OutlineSequence;
outlineSeq: OutlineSequence;
fenceSeq, seq: Sequence;
entityGen: GGModelTypes.EntityGenerator;
seqList: LIST OF Sequence;
newSeqGen: SequenceGenerator;

outSeqGen _ NEW[OutlineSequenceGeneratorObj];
[outSeqGen.list, outSeqPtr] _ StartOutlineSequenceList[];
entityGen _ SelectedStuff[scene, selectClass];
FOR entity: REF ANY _ GGScene.NextEntity[entityGen], GGScene.NextEntity[entityGen] UNTIL entity = NIL DO
WITH entity SELECT FROM
sliceD: SliceDescriptor => NULL;
outlineD: OutlineDescriptor => {
fenceSeq _ NIL;
[holeSeqs, ptr] _ GGUtility.StartSequenceList[];
seqList _ GGOutline.SequencesOfOutline[outlineD];
seq _ seqList.first;
IF seq.traj.role = fence OR seq.traj.role = open THEN {
fenceSeq _ seq;
seqList _ seqList.rest;
};
FOR list: LIST OF Sequence _ seqList, list.rest UNTIL list = NIL DO
[holeSeqs, ptr] _ GGUtility.AddSequence[list.first, holeSeqs, ptr];
ENDLOOP;
newSeqGen _ IF holeSeqs=NIL THEN nilSeqGen ELSE NEW[SequenceGeneratorObj _ [list: holeSeqs]];
outlineSeq _ NEW[OutlineSequenceObj _ [outline: outlineD.slice, fenceSeq: fenceSeq, holeSeqs: newSeqGen]];
[outSeqGen.list, outSeqPtr] _ AddOutlineSequence[outlineSeq, outSeqGen.list, outSeqPtr];
};
ENDCASE => ERROR;
ENDLOOP;
};

Returns a generator for all selected sequences, grouped by outline.
Modifying All Selected Runs With A Call-Back Proc
IF outSeqGen.list # NIL THEN {
GGCaret.NoAttractor[caret: caret];
GGCaret.SitOn[caret, NIL];
};
This procedure is a utility for ForEachOutlineRun.  We get the first run of seq and replace it with the results of runProc.
IMPORTANT INVARIANT:  When exiting from this loop, make sure that some part of seq has been deselected from the active list.  Otherwise, infinite loops are possible.
Only call the runProc if there is a segment in the run
Replaces a run with a new one.  Returns a list of new outlines created.  If only one traj was modified, the new traj is also returned.
Replaces a segment with a new run.  If newRun is not NIL, then only one trajectory is modified, and the new trajectory is returned.  Also returned is the bbox of modified Outlines.
DoForEachSelectedOutline: PUBLIC PROC [scene: SceneRef, selectClass: SelectionClass, outlineProc: OutlineProc] = {
outDGen: OutlineDescriptorGenerator _ SelectedOutlines[scene, selectClass];
FOR outlineD: OutlineDescriptor _ NextOutlineDescriptor[outDGen], NextOutlineDescriptor[outDGen] UNTIL outlineD = NIL DO
outlineProc[outlineD];
ENDLOOP;
};



 
Κ$!˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ2™2K™yKš
œ!™!K™(—K™š
Οk	˜	Jš
œœ
˜œ
K˜—šœžœ
ž˜JšžœQ˜XKšžœž˜&—˜Kšœ
žœ˜'Kšœžœ˜%Kšœžœžœ˜/Kšœžœ#˜;Kšœžœ˜!Kšœžœ˜3Kšœ	žœ˜%Kšœžœ+˜KKšœžœžœ˜3Kšœžœ%˜?Kšœ
žœžœ
˜Kšœ
žœ
žœ˜-Kšœ
žœ˜+Kšœ	žœ˜'Kšœžœ!˜7Kšœžœ#˜7Kšœ
žœžœ
˜!Kšœžœžœ˜3Kšœžœ%˜?Kšœ
žœ˜-Kšœžœ˜!Kšœžœ ˜5Kšœžœ)˜GKšœžœ,˜MKšœžœ#˜;Kšœžœžœ˜-Kšœžœ"˜9Kšœžœ˜+Kšœžœ˜Kšœ	žœ˜%Kšœžœžœ˜+šœžœ!˜7K˜—šœžœ
žœžœ
˜(K˜—Kšœžœžœ˜AKšœžœ(˜IKšœžœžœ˜/šœžœ˜7K˜——K˜Iheadš
œ9™9KšœŸΟb&œ
™ΖKš	œUŸœŸœŸœŸœ|™ύ
Kš
œΐ
™ΐ
™.Kš
œŸ™ŸKš
œ«
™«
K™EKš
œέ
™έ
K™CKš
œ}™}Kš
œl™l—š
œP™PK™—š
Οnœžœ
žœ
žœžœ"™cKšžœžœ
ž™š
œ™Kš
œ3™3K™—™ Kš
œH™HK™—šœΟc$™4K™
K™K™š
œ)™)Kš
œ
™
—šžœžœBžœž™iKšœžœ&™4Kš
œ,™,Kšžœ
™Kš
œ™—Kš
œ)™)šžœOžœžœ
ž™dKš
œ,™,Kšžœ
™—K™—Kšžœžœ
™K™K™—K˜K™K™š œžœ;˜Qšžœ
ž˜Kš
œ4˜4Kš
œ.˜.Kš
œ4˜4Kšžœ
˜—K˜K˜—š œžœ=™Zšžœ
ž™Kš
œ4™4Kš
œ.™.Kš
œ4™4Kšžœ
™—K™K™—š œžœ0˜Bšžœ
ž˜Kšœ&žœ
˜*Kšœ žœ
˜$Kšœ&žœ
˜*Kšžœ
˜—K˜K˜—š œžœ2™Kšžœ
ž™Kšœ&žœ
™*Kšœ žœ
™$Kšœ&žœ
™*Kšžœ
™—K™K™—K˜š 	œžœ
žœ3˜IKš
œ@˜@šžœIžœ	ž˜`Kš
œ-˜-Kšžœ
˜—K˜K˜—š œžœ
žœL˜dKš
œ"˜"Kš
œ˜Kšœ$žœ
žœ
˜0Kš
œ9˜9šžœžœ
žœ˜Kš
œ2˜2Kšœ;‘˜VK˜
—Kšžœ˜Kšžœžœ6˜RKš
œ+˜+Kš
œ%˜%Kšœ‘˜K˜—š 
œžœ
žœN™hKš
œ™Kš
œ™Kšžœ žœ
žœ
™.Kš
œ6™6šžœžœ
žœ™Kš
œ-™-Kšœ9‘™TK™
—Kšžœ™Kšžœžœ6™RKš
œ+™+Kš
œ,™,Kšœ‘™K™—š œžœE™eKšœ>žœ	™JKš
œ,™,Kš
œ/™/K™K™—š œžœA˜_Kšœ8žœ	˜DKš
œ*˜*K˜K™—š œžœ
žœB˜]Kš
œ5˜5Kš
œ˜Kš
œ˜Kšžœžœ
žœ
˜'Kš
œ2˜2Kš
œ3˜3Kš
œ&˜&K˜K˜—š 
œžœ
žœ?˜VK™EKš
œ˜Kš
œ+˜+Kš
œ-˜-K˜K™—K˜š œžœJ˜cJš
œ0˜0Jš
œ˜Jš
œ0˜0šžœ`žœ
žœ
ž˜xJš
œ$˜$Jšžœ
˜—Jš
œ-˜-šžœRžœžœ
ž˜gJš
œ$˜$Jšžœ
˜—˜J˜——š œžœ
žœ3˜KK™;šžœ	žœ
žœAžœ
žœ
ž˜iKšœ+žœ™?Kš
œ.˜.Kšžœ
˜—Kšœžœ˜)K˜K˜—š
 œžœ
žœ
žœ
žœ3˜_šžœžœ
ž˜Kš
œ;˜;Kš
œ5˜5Kš
œ?˜?Kš
œY˜YKš
œG™GKš
œc™cKšžœžœ
˜—K˜K˜—š
 œžœ
žœ
žœ
žœ˜LKš
œ&˜&Kš
œ&˜&Kš
œ#˜#K˜K˜—š œžœ
žœ˜8Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—š œžœ
žœA™eKš
ŸS™SKš
œJ™Jšžœžœ
žœ™Kšžœ'žœ
žœ™FKš
œ/™/Kš
œ+™+Kšœ&žœ™:K™—K™K™—š œžœ
žœA˜aKš
œH™HKš
œG˜Gšžœ
žœ
žœ˜Kš
œ,˜,Kš
œ(˜(K˜—K˜K˜—š 
œžœ
žœT˜nKš
œ#˜#Kš
œ4˜4šžœžœ
žœ˜Kš
œ2˜2Kš
œ0˜0Kš
œ*˜*Kš
œ&˜&šžœ
žœ žœ˜,Kšžœžœ4˜PKš
œ*˜*Kš
œ$˜$K˜—K˜—K˜K˜—š œžœ
žœX™tK™,Kš
œ%™%Kš
œ8™8šžœžœ
žœ™Kš
œ6™6Kš
œ2™2Kš
œ*™*Kš
œ*™*šžœ
žœ žœ™,Kšžœžœ6™RKš
œ*™*Kš
œ+™+K™—K™—K™K™—š œžœ
žœB˜_K˜5Kš
œA˜AKš 
œ(˜5K˜K˜—š œžœ
žœE™gK™JKš
œO™Ošžœžœ
žœ™Kš
œ.™.Kš
œ1™1K™—K™K™—š œžœ
žœ?˜XKš
œG™GKš
œ1˜1Kš
œ˜Kš
œ6˜6šžœžœ
žœ˜Kš
œ(˜(Kš
œ*˜*Kš
œ#˜#šžœ
žœ"žœ˜.Kš
œ*˜*Kš
œ$˜$K˜—K˜—K˜K˜—K™K™2K™š
 œžœ
žœ9žœžœ˜vKš
œ˜š
œ3˜3Kš
Ÿ™—šžœ
žœ
žœ˜Kš
œ5˜5Kš
œ)˜)Kš
œ&˜&K˜Kš
Ÿ™—Kš
œ0˜0šžœ
žœ
žœ˜Kš
œ>˜>Kš
œ&˜&Kš
œ#˜#K˜Kš
Ÿ™—Kš
œ3˜3šžœ
žœ
žœ˜Kšžœ‘7˜>K˜—K˜K˜—K™	K™š œžœL˜aK™@š
œ˜Kš
œ2˜2Kš
œ
˜
—K˜K˜—š œžœ
žœ0žœžœ
žœ˜|šžœ
ž˜Kš
œ/˜/Kš
œ)˜)Kš
œ/˜/Kšžœžœ
˜—K˜K˜—š
 œžœ0žœžœ
žœ™wK™YKš
œ™Kšœžœ
™šžœ
žœ
žœ
žœ
žœ5žœžœ
ž™mšžœ
žœžœ™,Kšœžœ™Kšœžœ™'K™—Kšžœ
™—K™—K˜Kš
œ0™0K™š 
œžœžœ#™Tšžœ
ž™Kš
œ1™1Kš
œ+™+Kš
œ1™1Kšžœ
™—K™K™—š 
œžœžœ#˜Tšžœ
ž˜Kš
œ2˜2Kš
œ,˜,Kš
œ2˜2Kšžœ
˜—K˜K˜K˜—š œžœžœ#˜Všžœ
ž˜Kš
œ0˜0Kš
œ*˜*Kš
œ0˜0Kšžœ
˜—K˜K˜—š œžœL˜aK™Bšžœ
ž˜Kšœ?žœ
˜MKšœ6žœ
˜DKšœ?žœ
˜MKšžœžœ
˜—K˜K˜—š œžœžœ
žœ2˜hšžœ
ž˜Kš
œ(˜(Kš
œ"˜"Kš
œ(˜(Kšžœžœ
˜—K˜—K˜K™K˜š œžœ
žœ
žœ
žœ0žœžœ™tKšžœžœ
ž™š
œ™Kšžœžœ
žœ™<šžœ
ž™Kšœ
žœ™.Kšœžœ™(Kšœ
žœ™.Kšžœžœ
™—K™—š
œ™K™Kš
œ,™,šžœCžœžœ
ž™YKš
žœ
žœ,žœ
žœ
žœ™EKšžœ
™—Kšžœ
žœ™
K™—š
œ™K™Kš
œ5™5Kš
žœžœ
žœ
žœ
žœ™ Kšžœ™#K™—Kšžœžœ
™K™K™—š
 œžœ
žœ>žœžœ˜mšœžœ
ž˜5Kš
œ$˜$Kš
œ˜Kš
œ$˜$Kšžœžœ
˜—Kš
žœžœ
žœ
žœ
žœ˜'Kšžœ*˜0K˜K˜—š œžœ
žœ
žœ
žœ0žœžœ˜pKš
œH™HKš
œ@™@Kš
œF™FKš
œ?™?Kš
œ=™=Kšžœžœ
ž˜š
œ˜K˜Kš
œ6˜6Kšžœ
žœ˜K˜—š
œ™K™Kš
œ<™<Kšžœžœ
™K™—š
œ˜Kš
œ˜Kš
œ5˜5Kšžœžœ˜K˜—š
œ˜Kš
œ˜Kš
œ<˜<Kšžœžœ
žœ
žœ˜"Kš
žœ
žœ
žœ
žœ
žœ˜#Kšžœ"˜(K˜—Kšžœžœ
˜K˜K™—š
 œžœ
žœ0žœžœ˜[šžœ
ž˜Kšœ
žœžœ˜.Kšœžœžœ˜(Kšœ
žœžœ˜.Kšžœžœ
˜—K˜K˜—š œžœ
žœ<žœ˜xšžœ
žœ
žœEžœžœ
ž˜uKš
œ+˜+šœžœ"žœ-˜[Kšžœ
žœ
˜	—Kšžœžœ
žœ
žœ˜Kšžœ
˜—Kšžœ
žœ˜K˜K˜—š œžœ
žœžœ
žœžœ˜ošžœ
žœ
žœ1žœžœ
ž˜aKš
œ+˜+šœžœ"žœ.˜\Kšžœ
žœ
˜	—Kšžœžœ
žœ
žœ˜Kšžœ
˜—Kšžœ
žœ˜K˜K˜—š œžœ
žœ0žœ ˜uKšœžœ
žœ
˜Kšœ	žœ˜#Kš
œ3˜3šžœ
žœ
žœEžœžœ
ž˜ušžœ,žœ˜4Kš
œ9˜9šžœžœ
žœžœžœ
ž˜CKš
œI˜IKšžœ
˜—K˜—Kšžœ
˜—K˜K˜—š œžœ
žœ0žœ*˜~Kšœžœ
˜ Kšœžœ
žœžœ
˜%Kšœ
žœ-˜:šžœ
žœ
žœEžœžœ
ž˜ušžœ,žœ˜4Kš
œN˜NK˜—Kšžœ
˜—K˜K˜—š œžœBžœ"™‹
šžœ
ž™Kšœžœžœ
žœ
žœ
žœ™dKšœžœžœ
žœ
žœ
žœ™[Kšœžœžœ
žœ
žœ
žœ™dKšžœžœ
™—K™K™—š œžœ
žœ>žœ˜
šžœ
ž˜Kš
œ-˜-Kš
œ'˜'Kš
œ-˜-Kšžœžœ
˜—Kš
œ˜K˜—š 
œžœ
žœ0žœ-™~Kšœžœ
žœžœ
™#Kšœžœ™0šžœ
žœ
žœEžœžœ
ž™uKš
œX™XKšžœ
™—K™K™—š œžœ
žœ0žœ-˜Kšœžœ
žœžœ
˜#Kšœžœ˜0šžœ
žœ
žœEžœžœ
ž˜uKš
œX˜XKšžœ
˜—K˜K˜—š œžœ
žœ0žœ-™Kšœžœ
™Kšœžœ
žœžœ
™#Kšœžœ™0šžœ
žœ
žœ
žœ
žœ5žœžœ
ž™mšžœ
žœ$žœ™3Kšœ	žœ™"Kš
œN™NK™—Kšžœ
™—K™K™—š œžœžœ˜bKš
žœ
žœ
žœ
žœ
žœ
˜ šžœ˜Kš
œ˜K˜K˜—Kš
œ˜K˜—š œžœ!žœ™hKš
žœ
žœ
žœ
žœ
žœ
™ šžœ™Kš
œ™K™K™—Kš
œ™—K˜š œžœ,žœ
žœžœžœ
žœ˜“
šžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—K˜K˜—š œžœ.žœ
žœžœžœ
žœ™›
šžœžœ
žœ™Kš
žœ
žœžœ
žœ
žœ
™#Kšœžœ	žœ™%Kšžœ
™K™
—šžœ™Kš
œ™Kšœžœ	žœ™Kš
œ™K™—K™—K˜Kšœžœžœ˜Gš œžœ
žœ0žœ*™Š
Kš
ŸC™CKšœžœ
žœ
™ Kšœžœ
žœ™#Kš
œ™Kš
œ™Jš
œ(™(Jšœ	žœ
žœ
™K™J™Kšœžœ™-Kš
œ9™9Jš
œ.™.šžœ	žœ
žœ@žœ
žœ
ž™hšžœžœ
ž™Jšœžœ
™ š
œ ™ Kšœžœ
™Kš
œ0™0Jš
œ1™1Kš
œ™šžœžœžœ™7Kš
œ™Kš
œ™K™—šžœžœ
žœžœžœ
ž™CKš
œC™CKšžœ
™—Kšœžœ
žœ
žœžœ
žœ*™]Kšœ
žœZ™jKš
œX™XJš
œ™—Jšžœžœ
™—Jšžœ
™—J™K™—š œžœ
žœ0žœ*˜†
Kš
ŸC™CKšœžœ
žœ
˜ Kšœžœ
žœ˜#Kš
œ˜Kš
œ˜Jš
œ'˜'Jšœ	žœ
žœ
˜K˜J˜Kšœžœ˜-Kš
œ9˜9Jš
œ2˜2šžœržœ
žœ
ž˜Š
šžœ!žœ˜+Kšœžœ
˜Kš
œ0˜0Jšœ œ
Ÿœ˜/Kš
œ˜šžœžœžœ˜7Kš
œ˜Kš
œ˜K˜—šžœžœ
žœžœžœ
ž˜CKš
œC˜CKšžœ
˜—Kšœžœ
žœ
žœžœ
žœ*˜]Kšœ
žœX˜hKš
œX˜XJš
œ˜—Jšžœ
˜—J˜K˜—š œžœ'žœ˜mKš
žœžœ
žœ
žœ
žœ˜)Kš
œ˜Kš
œ%˜%K˜—K˜š œžœ
žœ,žœ
žœžœžœ
žœ˜š
šžœžœ
žœ˜Kš
žœ
žœžœ
žœ
žœ
˜#Kšœžœ	žœ˜%Kšžœ
˜K˜
—šžœ˜Kš
œ˜Kšœžœ	žœ˜Kš
œ˜K˜—˜K˜——š œžœ
žœžœžœ
žœ˜_Kšœžœ
˜K˜—K˜K™1K˜š œžœ
žœPžœžœžœžœžœ˜΄
Kš
œ$˜$Kš
œ˜K˜Kšœ,Ÿœ˜4KšœŸœŸœ/˜XJšœ,Ÿœ˜4•StartOfExpansionΒ
[gargoyleData: 
GGInterfaceTypes.GargoyleData, point: 
GGBasicTypes.Point, attractor: 
GGModelTypes.Traj, onJoint: 
BOOL _ TRUE, attractorJointNum: 
NAT _ 999, attractorSegNum: 
NAT _ 999]šžœžœ
žœ™Jš
œ"™"Jšœžœ™J™—šžœžœ
žœ
‘#˜Ašžœežœ
žœ
ž˜}Jš
œ˜šžœžœ
žœ˜KšœŸœ
Ÿœ/˜RKš
œ1˜1Kšžœ˜K˜—šžœhžœžœ
ž˜
KšœŸœ
Ÿœ/˜QKš
œ1˜1Kšžœ˜Jšžœ
˜—š
ž˜˜Jšœ,Ÿœ˜4J˜——Jšžœ
˜—Jšžœ
˜—K˜K˜—K˜Kšœ	žœ˜!š
 œžœBžœžœžœ˜
Kšœ  œJ™{K™₯
Kš
œ˜Kš
œ˜Kšœ
žœ
˜K˜
Kšœ
žœ
žœ	˜K˜Kš
œ/˜/Kš
œ5˜5Kšžœžœ
˜,šžœ˜Kš
œ4˜4šžœžœ˜KšœŸœ‘#˜IKš
œ ˜ Kšžœ‘(˜0K˜—Kš
œ&˜&Kšžœžœ
žœ
žœ
˜K˜—K™6šžœžœžœ˜,Kšœ	Ÿœ˜šžœ
žœ
žœ˜KšœžœŸœ‘˜CKšžœžœžœŸœ˜=K˜—KšœŸ
œ˜<Kš
œ'˜'Kš
œ,˜,šžœžœ
žœ"žœžœ
ž˜FKš
œ9˜9Kšžœ
˜—K˜
—šžœ˜KšœŸœ‘#˜IKš
œ ˜ K˜—K˜K˜—š
 
œžœ0žœžœ
žœ"˜K™†
Kšžœ
žœ
žœ‘œ3˜Mšžœ˜Kšœ
Ÿœ˜'Kšœžœ˜#Kš
œ@˜@K–O[scene: 
GGModelTypes.Scene, outline: 
GGModelTypes.Outline, priority: 
INT]š
œ.˜.K˜—K˜K˜—š
 œžœ
žœžœ!žœ$˜†
J™΄
Kšœ
žœ
žœ	˜K˜BJ˜6J˜"J˜KšœŸ
œ˜?šžœžœ
žœ"žœžœ
ž˜FJ˜9Jšžœ
˜—J˜'K˜K˜—š œžœ
žœžœ"˜[Jš
œ&˜&Jš
œ&˜&Jš
œ
˜
Jš
œ)˜)šžœOžœžœ
ž˜dJš
œ,˜,šžœžœ
žœ)ž˜8Jš
œ>˜>Jšžœ
˜—Jšžœ
˜—Jš
œ)˜)šžœžœBžœž˜iJš
œ*˜*Jš
œ,˜,Jšžœ
˜—J˜K˜K˜—š
 œžœžœ
žœ
žœ˜QKš
œ!˜!šžœžœ
žœžœžœ
ž˜CK–<[bBox: 
GGBasicTypes.BoundBox, by: 
GGBasicTypes.BoundBox]š
œ=˜=Kšžœ
˜—K˜—K˜Kšœžœ˜%Kšœ
žœ˜)K˜š œžœ
žœI˜lKš
œL˜Lšžœ`žœ
žœ
ž˜xKš
œ˜Jšžœ
˜—K˜K˜—š œžœ
žœM™rKš
œK™Kšžœ^žœžœ
ž™xKš
œ™Kšžœ
™—K™K™—š œžœžœ
žœžœ
žœ
žœ˜iKšœžœ
žœžœ
˜%K˜	šžœžœ
ž˜šžœ
žœ˜Kš	žœžœ
žœ
žœ
‘˜@K˜Kšžœ˜
Kš
œ˜—K˜K˜Kšžœ
˜—Kšžœ˜Kš
œ˜K˜—š œžœ
žœ
žœžœ
žœ
žœ˜SKšœžœ
žœ˜ Kšžœžœ
žœ
žœ˜šžœ
žœ
ž˜Kš
œ˜Kšžœ
˜—K˜Kšžœ˜Kš
œ˜—K˜Kšžœ
˜K™K™K™
—…—WΜ²}