DIRECTORY
Feedback, FeedbackTypes, FS, GGBasicTypes, GGBoundBox, GGCoreOps, GGCoreTypes, GGHistoryTypes, GGInterfaceTypes, GGModelTypes, GGOutline, GGParent, GGParseIn, GGParseOut, GGScene, GGSegmentTypes, GGSequence, GGShapes, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, ImagerPath, ImagerTransformation, IO, Rope, TextNode, TiogaImager;

GGOutlineImplA: CEDAR PROGRAM
IMPORTS Feedback, FS, GGBoundBox, GGCoreOps, GGOutline, GGParent, GGParseIn, GGParseOut, GGScene, GGSequence, GGShapes, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, IO, Rope
EXPORTS GGSlice, GGOutline, GGParent = BEGIN 

AlignBag: TYPE = GGInterfaceTypes.AlignBag;
BitVector: TYPE = GGBasicTypes.BitVector;
BoundBox: TYPE = GGCoreTypes.BoundBox;
Camera: TYPE = GGModelTypes.Camera;
Circle: TYPE = GGBasicTypes.Circle;
Color: TYPE = Imager.Color;
ControlPointGenerator: TYPE = GGModelTypes.ControlPointGenerator;
DefaultData: TYPE = GGModelTypes.DefaultData;
EditConstraints: TYPE = GGModelTypes.EditConstraints;
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
MsgRouter: TYPE = FeedbackTypes.MsgRouter;
GGData: TYPE = GGInterfaceTypes.GGData;
HistoryEvent: TYPE = GGHistoryTypes.HistoryEvent;
HitType: TYPE = GGModelTypes.TrajPartType;
Joint: TYPE = GGSegmentTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Line: TYPE = GGCoreTypes.Line;
OutlineData: TYPE = GGOutline.OutlineData;
OutlineDataObj: TYPE = GGOutline.OutlineDataObj;
OutlineHitData: TYPE = GGOutline.OutlineHitData;
OutlineHitDataObj: TYPE = GGOutline.OutlineHitDataObj;
OutlineParts: TYPE = GGOutline.OutlineParts;
OutlinePartsObj: TYPE = GGOutline.OutlinePartsObj;
Point: TYPE = GGBasicTypes.Point;
PointAndDone: TYPE = GGModelTypes.PointAndDone;
PointGenerator: TYPE = GGModelTypes.PointGenerator;
PointGeneratorObj: TYPE = GGModelTypes.PointGeneratorObj;
PointPairAndDone: TYPE = GGModelTypes.PointPairAndDone;
PointPairGenerator: TYPE = GGModelTypes.PointPairGenerator;
PointPairGeneratorObj: TYPE = GGModelTypes.PointPairGeneratorObj;
PointWalkProc: TYPE = GGModelTypes.PointWalkProc;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SegmentGeneratorObj: TYPE = GGModelTypes.SegmentGeneratorObj;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
SelectMode: TYPE = GGModelTypes.SelectMode;
SequenceGenerator: TYPE = GGSequence.SequenceGenerator;
SequenceOfReal: TYPE = GGCoreTypes.SequenceOfReal;
Slice: TYPE = GGModelTypes.Slice;
SliceClass: TYPE = GGModelTypes.SliceClass;
SliceClassObj: TYPE = GGModelTypes.SliceClassObj;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceObj: TYPE = GGModelTypes.SliceObj;
SliceParts: TYPE = GGModelTypes.SliceParts;
StrokeEnd: TYPE = Imager.StrokeEnd;
StrokeJoint: TYPE = Imager.StrokeJoint;
Traj: TYPE = GGModelTypes.Traj;
TrajData: TYPE = GGModelTypes.TrajData;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajParts: TYPE = GGModelTypes.TrajParts;
TrajPartType: TYPE = GGModelTypes.TrajPartType;
Transformation: TYPE = ImagerTransformation.Transformation;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
Vector: TYPE = GGBasicTypes.Vector;
WalkProc: TYPE = GGModelTypes.WalkProc;

MoveToProc: TYPE = ImagerPath.MoveToProc;
LineToProc: TYPE = ImagerPath.LineToProc;
CurveToProc: TYPE = ImagerPath.CurveToProc;
ConicToProc: TYPE = ImagerPath.ConicToProc;
ArcToProc: TYPE = ImagerPath.ArcToProc;

ClusterData: TYPE = REF ClusterDataObj;
ClusterDataObj: TYPE = GGSlice.ClusterDataObj;

Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = Feedback.Problem;
BuildOutlineSliceClass: PUBLIC PROC [] RETURNS [class: SliceClass] = {
class _ NEW[SliceClassObj _ [
type: $Outline,
unlink: GGParent.Unlink,
getBoundBox: GGParent.GetBoundBox,
getTransformedBoundBox: GGSlice.GenericTransformedBoundBox,
getTightBox: GGParent.GetTightBox,
copy: OutlineCopy,
restore: GGParent.Restore,
buildPath: OutlineBuildPath,
drawBorder: OutlineDrawBorder,
drawParts: OutlineDrawParts,
drawTransform: OutlineDrawTransform,
drawSelectionFeedback: OutlineDrawSelectionFeedback,
drawAttractorFeedback: GGParent.DrawAttractorFeedback,
attractorFeedbackBoundBox: GGParent.AttractorFeedbackBoundBox,
saveSelections: GGParent.SaveSelections,
remakeSelections: GGParent.RemakeSelections,
transform: GGParent.Transform,
describe: OutlineDescribe,
describeHit: GGParent.DescribeHit,
fileout: OutlineFileout,
filein: OutlineFilein,
isEmptyParts: GGParent.IsEmptyParts,
isCompleteParts: GGParent.IsCompleteParts,
newParts: GGParent.NewParts,
unionParts: GGParent.UnionParts,
differenceParts: GGParent.DifferenceParts,
movingParts: OutlineMovingParts,
augmentParts: GGParent.AugmentParts,
alterParts: GGParent.AlterParts,
setSelectedFields: GGParent.SetSelectedFields,
pointsInDescriptor: GGParent.PointsInDescriptor,
walkPointsInDescriptor: GGParent.WalkPointsInDescriptor,
pointPairsInDescriptor: GGParent.PointPairsInDescriptor,
segmentsInDescriptor: GGParent.SegmentsInDescriptor,
walkSegments: GGParent.WalkSegments,
nextPoint: GGParent.NextPoint,
nextPointPair: GGParent.NextPointPair,
nextSegment: GGParent.NextSegment
<<,
closestPoint: GGParent.ClosestPoint,
closestJointToHitData: GGParent.ClosestJointToHitData,
closestPointAndTangent: GGSlice.NoOpClosestPointAndTangent,
closestSegment: GGParent.ClosestSegment,
lineIntersection: GGParent.LineIntersection,
circleIntersection: GGParent.CircleIntersection,
hitDataAsSimpleCurve: GGParent.HitDataAsSimpleCurve,
setDefaults: GGParent.SetDefaults,
setStrokeWidth: GGParent.SetStrokeWidth,
getStrokeWidth: GGParent.GetStrokeWidth,
setStrokeEnd: GGParent.SetStrokeEnd,
getStrokeEnd: GGParent.GetStrokeEnd,
setStrokeJoint: GGParent.SetStrokeJoint,
getStrokeJoint: GGParent.GetStrokeJoint,
setStrokeColor: GGParent.SetStrokeColor,
getStrokeColor: GGParent.GetStrokeColor,
setFillColor: GGParent.SetFillColor,
getFillColor: OutlineGetFillColor,
setArrows: GGSlice.NoOpSetArrows,
getArrows: GGSlice.NoOpGetArrows,
setDashed: GGParent.SetDashed,
getDashed: GGParent.GetDashed
>>
]];
GGSlice.BuildMoreOutlineSliceClass[class];
};

BuildClusterSliceClass: PUBLIC PROC [] RETURNS [class: SliceClass] = {
class _ NEW[SliceClassObj _ [
type: $Cluster,
unlink: GGParent.Unlink,
getBoundBox: GGParent.GetBoundBox,
getTransformedBoundBox: GGSlice.GenericTransformedBoundBox,
getTightBox: GGParent.GetTightBox,
copy: ClusterCopy,
restore: GGParent.Restore,
buildPath: GGSlice.NoOpBuildPath,
drawBorder: GGSlice.NoOpDrawBorder,
drawParts: GGParent.DrawParts,
drawTransform: GGParent.DrawTransform,
drawSelectionFeedback: ClusterDrawSelectionFeedback,
drawAttractorFeedback: DrawAttractorFeedback,
attractorFeedbackBoundBox: AttractorFeedbackBoundBox,
saveSelections: GGParent.SaveSelections,
remakeSelections: GGParent.RemakeSelections,
transform: GGParent.Transform,
describe: ClusterDescribe,
describeHit: GGParent.DescribeHit,
fileout: ClusterFileout,
filein: ClusterFilein,
isEmptyParts: GGParent.IsEmptyParts,
isCompleteParts: GGParent.IsCompleteParts,
newParts: GGParent.NewParts,
unionParts: GGParent.UnionParts,
differenceParts: GGParent.DifferenceParts,
movingParts: ClusterMovingParts,
augmentParts: GGParent.AugmentParts,
alterParts: GGParent.AlterParts,
setSelectedFields: GGParent.SetSelectedFields,
pointsInDescriptor: GGParent.PointsInDescriptor,
walkPointsInDescriptor: GGParent.WalkPointsInDescriptor,
pointPairsInDescriptor: GGParent.PointPairsInDescriptor,
segmentsInDescriptor: GGParent.SegmentsInDescriptor,
walkSegments: GGParent.WalkSegments,
nextPoint: GGParent.NextPoint,
nextPointPair: GGParent.NextPointPair,
nextSegment: GGParent.NextSegment
<<,
closestPoint: GGParent.ClosestPoint,
closestJointToHitData: GGParent.ClosestJointToHitData,
closestPointAndTangent: GGSlice.NoOpClosestPointAndTangent,
closestSegment: GGParent.ClosestSegment,
filledPathsUnderPoint: ClusterFilledPathsUnderPoint,
lineIntersection: GGParent.LineIntersection,
circleIntersection: GGParent.CircleIntersection,
hitDataAsSimpleCurve: GGParent.HitDataAsSimpleCurve,
setDefaults: GGParent.SetDefaults,
setStrokeWidth: GGParent.SetStrokeWidth,
getStrokeWidth: GGParent.GetStrokeWidth,
setStrokeEnd: GGParent.SetStrokeEnd,
getStrokeEnd: GGParent.GetStrokeEnd,
setStrokeJoint: GGParent.SetStrokeJoint,
getStrokeJoint: GGParent.GetStrokeJoint,
setStrokeColor: GGParent.SetStrokeColor,
getStrokeColor: GGParent.GetStrokeColor,
setFillColor: GGParent.SetFillColor,
getFillColor: GGParent.GetFillColor,
setArrows: GGSlice.NoOpSetArrows,
getArrows: GGSlice.NoOpGetArrows,
setDashed: GGParent.SetDashed,
getDashed: GGParent.GetDashed
>>
]];
GGSlice.BuildMoreClusterSliceClass[class];
};

OutlineFromChildList: PROC [childList: LIST OF Slice, fillColor: Color, oddWrap: BOOL _ TRUE, fillText: TextNode.Ref, screenStyle: BOOL, version: REAL] RETURNS [outline: Slice] =  {
data: OutlineData _ NEW[OutlineDataObj _ [oddWrap: oddWrap, fillColor: fillColor, children: childList] ];
outline _ NEW[SliceObj _ [
class: GGSlice.FetchSliceClass[$Outline],
parent: NIL,
data: data,
selectedInFull: [FALSE, FALSE, FALSE],
tightBox: GGBoundBox.NullBoundBox[],
boundBox: GGBoundBox.NullBoundBox[],
boxValid: FALSE]];
FOR tL: LIST OF Slice _ childList, tL.rest UNTIL tL=NIL DO
tL.first.parent _ outline;
ENDLOOP;
outline.nullDescriptor _ GGSlice.DescriptorFromParts[outline, NIL];
IF version<8802.04 THEN { -- have to calculate the forward bits from scratch. In older versions, trajectory direction was not important.
[] _ GGSliceOps.SetOrientation[childList.first, NIL, ccw, NIL]; -- first child is ccw by convention
FOR holeList: LIST OF Slice _ childList.rest, holeList.rest UNTIL holeList=NIL DO
[] _ GGSliceOps.SetOrientation[holeList.first, NIL, cw, NIL]; -- other children are cw by convention
ENDLOOP;
};
GGOutline.SetFillText[outline, fillText, screenStyle, NIL];
};

ClusterFromChildList: PROC [childList: LIST OF Slice, frozen: BOOL, version: REAL] RETURNS [parent: Slice] =  {
data: OutlineData _ NEW[OutlineDataObj _ [oddWrap: FALSE, fillColor: NIL, children: childList, subclassData: NEW[ClusterDataObj _ [frozen: frozen]] ]];
parent _ NEW[SliceObj _ [
class: GGSlice.FetchSliceClass[$Cluster],
parent: NIL,
data: data,
selectedInFull: [FALSE, FALSE, FALSE],
tightBox: GGBoundBox.NullBoundBox[],
boundBox: GGBoundBox.NullBoundBox[],
boxValid: FALSE]];
FOR tL: LIST OF Slice _ childList, tL.rest UNTIL tL=NIL DO
tL.first.parent _ parent;
ENDLOOP;
parent.nullDescriptor _ GGSlice.DescriptorFromParts[parent, NIL];
};
OutlineDescribe: PROC [sliceD: SliceDescriptor] RETURNS [rope: Rope.ROPE] = {
RETURN[GGParent.Describe[sliceD, "outline"]];
};
ClusterDescribe: PROC [sliceD: SliceDescriptor] RETURNS [rope: Rope.ROPE] = {
RETURN[GGParent.Describe[sliceD, "cluster"]];
};
ClusterCopy: PROC [slice: Slice, parts: SliceParts _ NIL] RETURNS [copy: LIST OF Slice] = {
DoCreateCluster: PROC [newSlice: Slice] RETURNS [parent: Slice] = {
newData: OutlineData;
parent _ GGSlice.CreateCluster[];
GGSlice.AddChildToCluster[parent, newSlice, -1];
newData _ NARROW[parent.data];
newData.subclassData _ NEW[ClusterDataObj _ [frozen: oldClusterData.frozen]];
};
outlineParts: OutlineParts _ NARROW[parts];
oldData: OutlineData _ NARROW[slice.data];
oldClusterData: ClusterData _ NARROW[oldData.subclassData];

copy _ Copy[slice, parts, DoCreateCluster];
};

ClusterDrawSelectionFeedback: PUBLIC PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: Camera, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
slowNormal, slowHot, completeNormal, completeHot: BOOL _ FALSE;
normalOutlineParts: OutlineParts _ NARROW[selectedParts];
hotOutlineParts: OutlineParts _ NARROW[hotParts];
boxDrawn: BOOL _ FALSE;

IF caretIsMoving OR dragInProgress THEN RETURN;
IF selectedParts=NIL AND hotParts=NIL THEN RETURN;

completeNormal _ normalOutlineParts#NIL AND IsComplete[normalOutlineParts];
completeHot _ hotOutlineParts#NIL AND IsComplete[hotOutlineParts];
slowNormal _ selectedParts#NIL AND NOT (quick AND completeNormal);
slowHot _ hotParts#NIL AND NOT (quick AND completeHot);

GGParent.DrawSelectionFeedback[slice, selectedParts, hotParts, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
IF NOT slowNormal AND completeNormal THEN {
boundBox: BoundBox _ GetBoundBox[slice, NIL];
GGShapes.DrawBoundBox[dc, boundBox, camera.cpScale];
GGShapes.DrawQuickSelectedJoint[dc, [boundBox.loX, boundBox.loY], normal, camera.cpScale];
boxDrawn _ TRUE;
};
IF NOT slowHot AND completeHot THEN {
boundBox: BoundBox _ GetBoundBox[slice, NIL];
GGShapes.DrawBoundBox[dc, boundBox, camera.cpScale];
GGShapes.DrawQuickSelectedJoint[dc, [boundBox.loX, boundBox.loY], hot, camera.cpScale];
boxDrawn _ TRUE;
};
IF NOT boxDrawn AND (NOT IsEmpty[normalOutlineParts] OR NOT IsEmpty[hotOutlineParts]) THEN {
boundBox: BoundBox _ GetBoundBox[slice, NIL];
GGShapes.DrawBoundBox[dc, boundBox, camera.cpScale];
};
};

ClusterFileout: PUBLIC PROC [slice: Slice, f: IO.STREAM] = {
outlineData: OutlineData _ NARROW[slice.data];
clusterData: ClusterData _ NARROW[outlineData.subclassData];
f.PutF["frozen: "]; GGParseOut.WriteBool[f, clusterData.frozen]; 
f.PutChar[IO.CR];
GGParent.Fileout[slice, f];
};

ClusterFilein: PUBLIC PROC [f: IO.STREAM, version: REAL, router: MsgRouter, camera: Camera] RETURNS [slice: Slice] = {
frozen, good: BOOL _ TRUE;
childList: LIST OF Slice;
GGParseIn.ReadWRope[f, "frozen:"];
[frozen, good] _ GGParseIn.ReadBool[f, version];
childList _ GGParent.Filein[f, version, router, camera];
IF childList#NIL THEN slice _ ClusterFromChildList[childList, frozen, version];
};

ClusterMovingParts: PROC [slice: Slice, selectedParts: SliceParts, editConstraints: EditConstraints, bezierDrag: GGInterfaceTypes.BezierDragRecord] RETURNS [background, overlay, rubber, drag: SliceDescriptor] = {
outlineData: OutlineData _ NARROW[slice.data];
RETURN GGParent.MovingParts[slice, selectedParts, TRUE, editConstraints, bezierDrag];
};


Unlink: PUBLIC PROC [slice: Slice] = {
IF slice.data#NIL THEN {
outlineData: OutlineData _ NARROW[slice.data];
GGSlice.UnlinkSlice[slice];
FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList=NIL DO
IF childList.first.data#NIL THEN GGSliceOps.Unlink[childList.first]; -- unlink circular structures.  IMPORTANT
ENDLOOP;
outlineData.children _ NIL;
};
};

GetBoundBox: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [box: BoundBox] = {
IF slice.boxValid AND parts=NIL THEN RETURN[slice.boundBox] -- fast case
ELSE {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
boundBoxList: LIST OF BoundBox;
thisBoundBox: BoundBox;
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
thisBoundBox _ GGSliceOps.GetBoundBox[childList.first];
boundBoxList _ CONS[thisBoundBox, boundBoxList];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
thisBoundBox _ GGSliceOps.GetBoundBox[list.first.slice, list.first.parts];
boundBoxList _ CONS[thisBoundBox, boundBoxList];
};
ENDLOOP;
box _ GGBoundBox.BoundBoxOfBoxes[boundBoxList];
IF parts=NIL THEN { -- set up cache for fast case next time around
GGSlice.KillBoundBoxOnly[slice.parent]; -- invalidate ancestor caches
slice.boundBox _ box;
slice.boxValid _ TRUE;
};
};
};

GetTightBox: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [box: BoundBox] = {
IF slice.tightBoxValid AND parts=NIL THEN RETURN[slice.tightBox] -- fast case
ELSE {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
boundBoxList: LIST OF BoundBox;
thisBoundBox: BoundBox;
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
thisBoundBox _ GGSliceOps.GetTightBox[childList.first];
boundBoxList _ CONS[thisBoundBox, boundBoxList];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
thisBoundBox _ GGSliceOps.GetTightBox[list.first.slice, list.first.parts];
boundBoxList _ CONS[thisBoundBox, boundBoxList];
};
ENDLOOP;
box _ GGBoundBox.BoundBoxOfBoxes[boundBoxList];
IF parts=NIL THEN { -- set up cache for fast case next time around
GGSlice.KillTightBoxOnly[slice.parent]; -- invalidate ancestor caches
slice.tightBox _ box;
slice.tightBoxValid _ TRUE;
};
};
};

OutlineCopy: PROC [slice: Slice, parts: SliceParts _ NIL] RETURNS [copy: LIST OF Slice] = {
DoCreateOutline: PROC [newSlice: Slice] RETURNS [parent: Slice] = {
newData: OutlineData;
parent _ GGOutline.CreateOutline[newSlice, GGCoreOps.CopyColor[oldData.fillColor]];
newData _ NARROW[parent.data];
newData.oddWrap _ oldData.oddWrap;
newData.fillText _ oldData.fillText;
newData.screenStyle _ oldData.screenStyle;
};
oldData: OutlineData _ NARROW[slice.data];
oldParts: OutlineParts _ NARROW[parts];
copy _ Copy[slice, parts, DoCreateOutline];
IF parts=NIL OR IsComplete[oldParts] THEN { -- if the whole thing is selected
GGOutline.SetFillText[copy.first, oldData.fillText, oldData.screenStyle, NIL];
};
};

Copy: PUBLIC PROC [slice: Slice, parts: SliceParts _ NIL, create: PROC [newSlice: Slice] RETURNS [parent: Slice]] RETURNS [copy: LIST OF Slice] = {
newParent, newSlice: Slice;
oldData, newData: OutlineData;
ptr, holeList: LIST OF Slice;
outlineParts: OutlineParts _ NARROW[parts];

IF parts=NIL OR IsComplete[outlineParts] THEN { -- if the whole thing is selected
AddChild: PROC [child: Slice] RETURNS [done: BOOL _ FALSE] = {
IF newSlice = NIL THEN {
newSlice _ GGSliceOps.Copy[child].first;
newParent _ create[newSlice];
newData _ NARROW[newParent.data];
}
ELSE {
newSlice _ GGSliceOps.Copy[child].first;
[holeList, ptr] _ GGUtility.AddSlice[newSlice, holeList, ptr];
newSlice.parent _ newParent;
};
};
oldData _ NARROW[slice.data];
[holeList, ptr] _ GGUtility.StartSliceList[];
[] _ GGParent.WalkChildren[slice, first, AddChild];
IF holeList#NIL
THEN newData.children _ GGUtility.AppendSliceList[newData.children, holeList];
copy _ LIST[newParent];
}
ELSE { -- each run of each selected child becomes a new slice.
CopyWholeTraj: PROC [child: Slice, enclose: BOOL _ FALSE] = {
thisFillColor: Imager.Color _ GGCoreOps.CopyColor[GGSliceOps.GetFillColor[slice, NIL].color];
newChild: Slice _ GGSliceOps.Copy[child].first;
IF enclose THEN newChild _ GGOutline.CreateOutline[newChild, thisFillColor];
copy _ GGUtility.AppendSliceList[copy, LIST[newChild]];
};
VisitChild: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
nextChild: Slice _ childD.slice;
childParts: SliceParts _ childD.parts;
IF GGSliceOps.GetType[nextChild]#$Traj THEN {
copy _ GGUtility.AppendSliceList[copy, GGSliceOps.Copy[nextChild, childParts]];
}
ELSE {
nextChildParts: TrajParts _ NARROW[childParts];
IF GGSequence.IsComplete[nextChildParts] THEN CopyWholeTraj[nextChild, TRUE]
ELSE {
nextRuns: GGSequence.SequenceGenerator _ GGSequence.RunsInSequence[nextChildParts].seqGen;
FOR nextSeq: TrajParts _ GGSequence.NextSequence[nextRuns], GGSequence.NextSequence[nextRuns] UNTIL nextSeq=NIL DO
IF NOT GGSequence.ContainsSomeSegment[nextSeq] THEN {
 Feedback.PutFByName[$Gargoyle, oneLiner, $Complaint, ". . . Cannot Fetch Joints or CPs by themselves"];
LOOP;
};
newSlice _ GGTraj.CopyTrajFromRun[nextChild, nextSeq];
newSlice _ GGOutline.CreateOutline[newSlice, fillColor];
copy _ GGUtility.AppendSliceList[copy, LIST[newSlice]];
ENDLOOP;
};
};
};
fillColor: Imager.Color _ GGCoreOps.CopyColor[GGSliceOps.GetFillColor[slice, NIL].color];
[] _ GGParent.WalkIncludedChildren[slice, parts, first, VisitChild];
};
};

Restore: PUBLIC PROC [from: Slice, to: Slice] = {
IF to=NIL OR from=NIL THEN ERROR;
IF to.class#from.class THEN ERROR;

<<IF to.class.type#$Outline THEN ERROR;
IF to.parent#NIL OR from.parent#NIL THEN ERROR;>>

BEGIN
fromSize: INT _ 0;
fromData: OutlineData _ NARROW[from.data];
fromChildren: LIST OF Slice _ fromData.children;
toSize: INT _ 0;
toData: OutlineData _ NARROW[to.data];
toChildren: LIST OF Slice _ toData.children;
lastToChildren: LIST OF Slice _ NIL;

toData.oddWrap _ fromData.oddWrap;
toData.fillColor _ fromData.fillColor;
toData.fillText _ fromData.fillText;
toData.screenStyle _ fromData.screenStyle;

FOR fromList: LIST OF Slice _ fromChildren, fromList.rest UNTIL fromList=NIL DO
fromSize _ fromSize+1;
ENDLOOP;
FOR toList: LIST OF Slice _ toChildren, toList.rest UNTIL toList=NIL DO
toSize _ toSize+1;
ENDLOOP;

IF GGSlice.copyRestore THEN
IF fromSize>=toSize THEN {
UNTIL toChildren=NIL DO
GGSliceOps.Restore[from: fromChildren.first, to: toChildren.first];
toChildren.first.parent _ to; -- must be restored in case it was reused at top level
lastToChildren _  toChildren;
fromChildren _ fromChildren.rest;
toChildren _ toChildren.rest;
ENDLOOP;
IF lastToChildren#NIL THEN { -- put back the remaining "from" children.
lastToChildren.rest _ fromChildren; -- hook up the lists
FOR adoptees: LIST OF Slice _ fromChildren, adoptees.rest UNTIL adoptees=NIL DO
adoptees.first.parent _ to;
ENDLOOP;
}
}
ELSE { -- fromSize<toSize
UNTIL fromChildren=NIL DO
GGSliceOps.Restore[from: fromChildren.first, to: toChildren.first];
toChildren.first.parent _ to; -- must be restored in case it was reused at top level
lastToChildren _  toChildren;
fromChildren _ fromChildren.rest;
toChildren _ toChildren.rest;
ENDLOOP;
IF lastToChildren#NIL THEN lastToChildren.rest _ NIL; -- cut off the remaining "to" children.  CAN THIS LEAD TO OBSOLETE DESCRIPTORS?? 
}

ELSE {
FOR adoptees: LIST OF Slice _ fromData.children, adoptees.rest UNTIL adoptees=NIL DO
adoptees.first.parent _ to;
ENDLOOP;
toData.children _ fromData.children; -- swing the pointer
};

to.selectedInFull _ from.selectedInFull; -- RECORD of BOOL
to.normalSelectedParts _ NIL; -- caller must reselect
to.hotSelectedParts _ NIL; -- caller must reselect
to.activeSelectedParts _ NIL; -- caller must reselect
to.matchSelectedParts _ NIL; -- caller must reselect
to.tightBox^ _ from.tightBox^;
to.tightBoxValid _ from.tightBoxValid;
to.boundBox^ _ from.boundBox^;
to.boxValid _ from.boxValid;
to.onOverlay _ from.onOverlay;
to.extraPoints _ from.extraPoints;
to.priority _ from.priority;
to.historyTop _ from.historyTop;
END;
};



OutlineBuildPath: PUBLIC PROC [slice: Slice, transformParts: SliceParts, transform: Transformation, moveTo: MoveToProc, lineTo: LineToProc, curveTo: CurveToProc, conicTo: ConicToProc, arcTo: ArcToProc, editConstraints: EditConstraints _ none] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineTransformParts: OutlineParts _ NARROW[transformParts];
noTransform: BOOL _ transform=NIL;
transformAll: BOOL _ transform#NIL AND transformParts=NIL;
pathTransformParts: LIST OF SliceDescriptor _ IF transformParts=NIL THEN NIL ELSE outlineTransformParts.descriptors;
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
isClosed: BOOL _ GGSliceOps.GetType[children.first]#$Traj OR NARROW[children.first.data, TrajData].role#open;
IF isClosed THEN { -- next child needs some path building
IF noTransform THEN GGSliceOps.BuildPath[children.first, NIL, NIL, moveTo, lineTo, curveTo, conicTo, arcTo, editConstraints]
ELSE IF transformAll THEN GGSliceOps.BuildPath[children.first, NIL, transform, moveTo, lineTo, curveTo, conicTo, arcTo, editConstraints]
ELSE GGSliceOps.BuildPath[children.first, IF pathTransformParts.first=NIL THEN NIL ELSE pathTransformParts.first.parts, IF pathTransformParts.first=NIL THEN NIL ELSE transform, moveTo, lineTo, curveTo, conicTo, arcTo, editConstraints];
};
IF pathTransformParts#NIL THEN pathTransformParts _ pathTransformParts.rest;
ENDLOOP;
};

OutlineDrawBorder: PUBLIC PROC [slice: Slice, drawParts: SliceParts, transformParts: SliceParts, transform: Transformation, dc: Imager.Context, camera: Camera, quick: BOOL _ FALSE, editConstraints: EditConstraints _ none] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineDrawParts: OutlineParts _ NARROW[drawParts];
outlineTransformParts: OutlineParts _ NARROW[transformParts];
noTransform: BOOL _ transform=NIL;
transformAll: BOOL _ transform#NIL AND transformParts=NIL;
drawAll: BOOL _ drawParts=NIL;
pathTransformParts: LIST OF SliceDescriptor _ IF transformParts=NIL THEN NIL ELSE outlineTransformParts.descriptors;
pathDrawParts: LIST OF SliceDescriptor _ IF drawAll THEN NIL ELSE outlineDrawParts.descriptors;
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
IF drawAll OR pathDrawParts.first#NIL THEN { -- next child needs some drawing
IF noTransform THEN GGSliceOps.DrawBorder[children.first, IF drawAll THEN NIL ELSE pathDrawParts.first.parts, NIL, NIL, dc, camera, quick, editConstraints]
ELSE IF transformAll THEN GGSliceOps.DrawBorder[children.first, IF drawAll THEN NIL ELSE pathDrawParts.first.parts, NIL, transform, dc, camera, quick, editConstraints]
ELSE GGSliceOps.DrawBorder[children.first, IF drawAll THEN NIL ELSE pathDrawParts.first.parts, IF pathTransformParts.first=NIL THEN NIL ELSE pathTransformParts.first.parts, IF pathTransformParts.first=NIL THEN NIL ELSE transform, dc, camera, quick, editConstraints];
};
IF pathTransformParts#NIL THEN pathTransformParts _ pathTransformParts.rest;
IF pathDrawParts#NIL THEN pathDrawParts _ pathDrawParts.rest;
ENDLOOP;
};

OutlineDrawParts: PUBLIC PROC [slice: Slice, parts: SliceParts, dc: Imager.Context, camera: Camera, quick: BOOL] = {
BuildOutline: Imager.PathProc = {
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
isOpen: BOOL _ GGSliceOps.IsOpen[children.first];
IF NOT isOpen THEN GGSliceOps.BuildPath[children.first, NIL, NIL, moveTo, lineTo, curveTo, conicTo, arcTo, none]; -- draw, without transforming
ENDLOOP;
};
outlineData: OutlineData _ NARROW[slice.data];
IF outlineData.fillColor#NIL THEN {
GGCoreOps.SetColor[dc, outlineData.fillColor];
Imager.MaskFill[dc, BuildOutline, outlineData.oddWrap];
};
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
GGSliceOps.DrawBorder[children.first, NIL, NIL, NIL, dc, camera, FALSE, none];
ENDLOOP;
BEGIN
RenderChild: PROC [child: Slice] RETURNS [ done: BOOL _ FALSE] = {
GGSlice.RenderText[dc, child, camera, quick];
};
[] _ GGParent.WalkChildren[slice, leaf, RenderChild, $Box];
END;
};

DrawParts: PUBLIC PROC [slice: Slice, parts: SliceParts, dc: Imager.Context, camera: Camera, quick: BOOL] = {
outlineData: OutlineData _ NARROW[slice.data];
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
GGSliceOps.DrawParts[children.first, NIL, dc, camera, quick];
ENDLOOP;
};
OutlineDrawTransform: PUBLIC PROC [slice: Slice, parts: SliceParts _ NIL, dc: Imager.Context, camera: Camera, transform: Transformation, editConstraints: EditConstraints] = {
BuildOutline: Imager.PathProc = {
pathParts: LIST OF SliceDescriptor;
transformParts: SliceParts;
pathParts _ IF outlineParts = NIL THEN NIL ELSE outlineParts.descriptors;
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
transformParts _ IF pathParts = NIL OR pathParts.first = NIL THEN NIL ELSE pathParts.first.parts;
t _ IF pathParts = NIL OR pathParts.first#NIL THEN transform ELSE NIL;
IF NOT GGSliceOps.IsOpen[children.first]
THEN GGSliceOps.BuildPath[children.first, transformParts, t, moveTo, lineTo, curveTo, conicTo, arcTo, editConstraints];
IF pathParts # NIL THEN pathParts _ pathParts.rest;
ENDLOOP;
};
outlineData: OutlineData _ NARROW[slice.data];
outlineParts: OutlineParts _ NARROW[parts];
borderParts: LIST OF SliceDescriptor;
t: Transformation;

borderParts _ IF outlineParts = NIL THEN NIL ELSE outlineParts.descriptors;
IF outlineData.fillColor#NIL THEN {
IF IsComplete[outlineParts] THEN GGCoreOps.SetColor[dc, outlineData.fillColor, transform]
ELSE GGCoreOps.SetColor[dc, outlineData.fillColor];
Imager.MaskFill[dc, BuildOutline, outlineData.oddWrap];
};
BEGIN
transformParts: SliceParts;
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
transformParts _ IF borderParts=NIL OR borderParts.first=NIL THEN NIL ELSE borderParts.first.parts;
t _ IF borderParts = NIL OR borderParts.first#NIL THEN transform ELSE NIL;
GGSliceOps.DrawBorder[children.first, NIL, transformParts, t, dc, camera, FALSE, editConstraints];
IF borderParts # NIL THEN borderParts _ borderParts.rest;
ENDLOOP;
END;
};

DrawTransform: PUBLIC PROC [slice: Slice, parts: SliceParts _ NIL, dc: Imager.Context, camera: Camera, transform: Transformation, editConstraints: EditConstraints] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineParts: OutlineParts _ NARROW[parts];
childrenD: LIST OF SliceDescriptor;
thisChild: Slice;
theseParts: SliceParts;
t: ImagerTransformation.Transformation;

childrenD _ IF outlineParts = NIL THEN NIL ELSE outlineParts.descriptors;
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children = NIL DO
thisChild _ children.first;
IF childrenD = NIL THEN { -- transform the whole cluster
theseParts _ NIL;
t _ transform;
}
ELSE IF childrenD.first#NIL THEN { -- transform this child
theseParts _ childrenD.first.parts;
t _ transform;
}
ELSE { -- don't transform this child
theseParts _ NIL;
t _ NIL;
};
GGSliceOps.DrawTransform[thisChild, theseParts, dc, camera, t, editConstraints];
IF childrenD # NIL THEN childrenD _  childrenD.rest;
ENDLOOP;
};

DrawSelectionFeedback: PUBLIC PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: Camera, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
normalList, hotList: LIST OF SliceDescriptor;
slowNormal, slowHot, completeNormal, completeHot: BOOL _ FALSE;
normalOutlineParts: OutlineParts _ NARROW[selectedParts];
hotOutlineParts: OutlineParts _ NARROW[hotParts];
completeNormal _ normalOutlineParts#NIL AND IsComplete[normalOutlineParts];
completeHot _ hotOutlineParts#NIL AND IsComplete[hotOutlineParts];
slowNormal _ selectedParts#NIL AND NOT (quick AND completeNormal);
slowHot _ hotParts#NIL AND NOT (quick AND completeHot);
IF slowNormal AND slowHot THEN {
hotList _ hotOutlineParts.descriptors;
FOR normalList _ normalOutlineParts.descriptors, normalList.rest UNTIL normalList=NIL DO
IF normalList.first#NIL THEN  -- normal parts. May also be hot parts. One call does it all
GGSliceOps.DrawSelectionFeedback[normalList.first.slice, normalList.first.parts, IF hotList.first=NIL THEN NIL ELSE hotList.first.parts, dc, camera, dragInProgress, caretIsMoving, hideHot, quick]
ELSE IF hotList.first#NIL THEN -- hot parts only. Need a different call
GGSliceOps.DrawSelectionFeedback[hotList.first.slice, NIL, hotList.first.parts, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
hotList _ hotList.rest;
ENDLOOP;
}
ELSE IF slowNormal THEN {
FOR normalList _ normalOutlineParts.descriptors, normalList.rest UNTIL normalList = NIL DO
IF normalList.first # NIL THEN GGSliceOps.DrawSelectionFeedback[normalList.first.slice, normalList.first.parts, NIL, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
ENDLOOP;
}
ELSE IF slowHot THEN {
FOR hotList _ hotOutlineParts.descriptors, hotList.rest UNTIL hotList = NIL DO
IF hotList.first # NIL THEN GGSliceOps.DrawSelectionFeedback[hotList.first.slice, NIL, hotList.first.parts, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
ENDLOOP;
};
};

OutlineDrawSelectionFeedback: PUBLIC PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: Camera, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
slowNormal, slowHot, completeNormal, completeHot: BOOL _ FALSE;
firstJoint: Point;
normalOutlineParts: OutlineParts _ NARROW[selectedParts];
hotOutlineParts: OutlineParts _ NARROW[hotParts];

IF caretIsMoving OR dragInProgress THEN RETURN;
IF selectedParts=NIL AND hotParts=NIL THEN RETURN;

completeNormal _ normalOutlineParts#NIL AND IsComplete[normalOutlineParts];
completeHot _ hotOutlineParts#NIL AND IsComplete[hotOutlineParts];
slowNormal _ selectedParts#NIL AND NOT (quick AND completeNormal);
slowHot _ hotParts#NIL AND NOT (quick AND completeHot);

GGParent.DrawSelectionFeedback[slice, selectedParts, hotParts, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
IF (NOT slowNormal AND completeNormal) OR (NOT slowHot AND completeHot) THEN {
firstChildD: SliceDescriptor _ IF completeNormal THEN normalOutlineParts.descriptors.first ELSE hotOutlineParts.descriptors.first;
pointGen: PointGenerator _ GGSliceOps.PointsInDescriptor[firstChildD];
firstJoint _ GGSliceOps.NextPoint[slice: firstChildD.slice, pointGen: pointGen].point;
};
IF NOT slowNormal AND completeNormal THEN
GGShapes.DrawQuickSelectedJoint[dc, firstJoint, normal, camera.cpScale];
IF NOT slowHot AND completeHot THEN
GGShapes.DrawQuickSelectedJoint[dc, firstJoint, hot, camera.cpScale];
};

DrawAttractorFeedback: PUBLIC PROC [slice: Slice, attractorParts: SliceParts, selectedParts: SliceParts, dragInProgress: BOOL, dc: Imager.Context, camera: Camera, editConstraints: EditConstraints] = {
success: BOOL _ FALSE;
childD: SliceDescriptor;
childSelectedParts: SliceParts;
childD _ GGParent.FirstIncludedChild[slice, attractorParts, first]; -- first level because ChildPartsFromParts only goes one level. Expect a recursive call to here.
IF childD = NIL THEN RETURN;
childSelectedParts _ ChildPartsFromParts[slice, selectedParts, childD.slice];
GGSliceOps.DrawAttractorFeedback[childD.slice, childD.parts, childSelectedParts, dragInProgress, dc, camera, editConstraints];
};

AttractorFeedbackBoundBox: PUBLIC PROC [slice: Slice, attractorParts: SliceParts, selectedParts: SliceParts, dragInProgress: BOOL, camera: Camera, editConstraints: EditConstraints] RETURNS [box: BoundBox] = {
success: BOOL _ FALSE;
childD: SliceDescriptor;
childSelectedParts: SliceParts;
childD _ GGParent.FirstIncludedChild[slice, attractorParts, first]; -- there should only be one child mentioned in the attractorParts
IF childD = NIL THEN RETURN;
childSelectedParts _ ChildPartsFromParts[slice, selectedParts, childD.slice];
box _ GGSliceOps.AttractorFeedbackBoundBox[childD.slice, childD.parts, childSelectedParts, dragInProgress, camera, editConstraints];
};

ChildPartsFromParts: PROC [slice: Slice, parts: SliceParts, child: Slice] RETURNS [childParts: SliceParts] = {
outlineParts: OutlineParts _ NARROW[parts];
IF child=NIL OR parts=NIL THEN RETURN[NIL];
FOR descriptors: LIST OF SliceDescriptor _ outlineParts.descriptors, descriptors.rest UNTIL descriptors=NIL DO
IF descriptors.first#NIL AND descriptors.first.slice=child THEN RETURN[descriptors.first.parts];
ENDLOOP;
};

SaveSelections: PUBLIC PROC [slice: Slice, parts: SliceParts, selectClass: SelectionClass] = {
children: LIST OF Slice _ NARROW[slice.data, OutlineData].children;
FOR nextChildList: LIST OF Slice _ children, nextChildList.rest UNTIL nextChildList=NIL DO
GGSliceOps.SaveSelections[nextChildList.first, NIL, selectClass];  -- clear every selection bit
ENDLOOP;
IF parts#NIL THEN { -- then ya gotta set them bits
outlineParts: OutlineParts _ NARROW[parts];
childrenParts: LIST OF SliceDescriptor;
IF outlineParts = NIL THEN RETURN;
childrenParts _  outlineParts.descriptors;
FOR nextChildParts: LIST OF SliceDescriptor _ childrenParts, nextChildParts.rest UNTIL nextChildParts=NIL DO
IF nextChildParts.first#NIL THEN GGSliceOps.SaveSelections[nextChildParts.first.slice, nextChildParts.first.parts, selectClass];
ENDLOOP;
};
};

RemakeSelections: PUBLIC PROC [slice: Slice, selectClass: SelectionClass] RETURNS [parts: SliceParts] = {
childD: SliceDescriptor;
outlineParts: OutlineParts _ NEW[OutlinePartsObj];
partsFound: BOOL _ FALSE;
ptr: LIST OF SliceDescriptor;
children: LIST OF Slice _ NARROW[slice.data, OutlineData].children;
[outlineParts.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR nextChildren: LIST OF Slice _ children, nextChildren.rest UNTIL nextChildren=NIL DO
nextChildPart: SliceParts _ GGSliceOps.RemakeSelections[nextChildren.first, selectClass];
IF nextChildPart=NIL THEN childD _ NIL
ELSE {
childD _ GGSlice.DescriptorFromParts[nextChildren.first, nextChildPart];
partsFound _ TRUE;
};
[outlineParts.descriptors, ptr] _
GGUtility.AddSliceDescriptor[childD, outlineParts.descriptors, ptr];
ENDLOOP;
IF partsFound THEN parts _ outlineParts ELSE parts _ NIL;
};

Transform: PUBLIC PROC [slice: Slice, parts: SliceParts _ NIL, transform: ImagerTransformation.Transformation, editConstraints: EditConstraints, history: HistoryEvent] = {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
IF outlineParts = NIL THEN {
FOR list: LIST OF Slice _ outlineData.children, list.rest UNTIL list = NIL DO
GGSliceOps.Transform[list.first, NIL, transform, editConstraints, NIL];
ENDLOOP;
}
ELSE {
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN GGSliceOps.Transform[list.first.slice, list.first.parts, transform, editConstraints, NIL];
ENDLOOP;
};
GGSlice.KillBoundBox[slice];
IF outlineParts = NIL OR IsComplete[outlineParts] THEN outlineData.fillColor _ GGCoreOps.TransformColor[outlineData.fillColor, transform];
IF outlineData.fillText # NIL THEN {
FirstChildProc: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = { -- walk every Box
[loc, screenStyle] _ GGSlice.GetBoxText[slice];
IF loc.node=NIL THEN RETURN [FALSE]; -- no fill.  Keep walking
GGSlice.SetBoxText[slice, loc, screenStyle, history]; -- reformat first filled child
recentlyFilledChild _ slice; -- remember most recently filled child
RETURN[TRUE]; -- and stop walking
};
RestChildProc: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = { -- walk every Box
IF slice#recentlyFilledChild THEN { -- skip the first (already reformatted) child
siblingNodes: TiogaImager.FormattedNodes _ GGSlice.GetBoxNodes[recentlyFilledChild];
resumeLoc: TextNode.Location _ siblingNodes.resume;
GGSlice.SetBoxText[slice, resumeLoc, screenStyle, history];
recentlyFilledChild _ slice;
};
};
recentlyFilledChild: Slice;
foundFilledBox, screenStyle: BOOL _ FALSE;
loc: TextNode.Location;

foundFilledBox _ GGParent.WalkChildren[slice, leaf, FirstChildProc, $Box];
IF foundFilledBox THEN [] _ GGParent.WalkChildren[slice, leaf, RestChildProc, $Box];
};
};


OneChildPartOnly: PROC [realParts: OutlineParts] RETURNS [theChild: SliceDescriptor] = {
FOR list: LIST OF SliceDescriptor _ realParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
IF theChild#NIL THEN RETURN[NIL] -- more than one child
ELSE theChild _ list.first;
};
ENDLOOP;
};

Describe: PUBLIC PROC [sliceD: SliceDescriptor, className: Rope.ROPE] RETURNS [rope: Rope.ROPE] = {
realParts: OutlineParts;
theChild: SliceDescriptor;
IF sliceD.parts = NIL THEN RETURN["a Slice"];
realParts _ NARROW[sliceD.parts];
IF (theChild _ OneChildPartOnly[realParts])#NIL THEN {
rope _ GGSliceOps.Describe[theChild];
}
ELSE {
FOR list: LIST OF SliceDescriptor _ realParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN RETURN[Rope.Concat["several parts of a multi-slice ", className]];
ENDLOOP;
rope _ Rope.Cat["No ", className, " parts to speak of."];
};
};

DescribeHit: PUBLIC PROC [slice: Slice, hitData: REF ANY] RETURNS [rope: Rope.ROPE] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineHitData: OutlineHitData _ NARROW[hitData];
count: NAT _ 0;
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children=NIL DO
child: Slice _ children.first;
IF child=outlineHitData.child THEN {
clusterRope: Rope.ROPE;
IF GGScene.IsTopLevel[slice] THEN clusterRope _ IO.PutFR["child %g", [integer[count]]]
ELSE clusterRope _ IO.PutFR["/%g", [integer[count]]];
IF NOT GGParent.IsParent[child] THEN clusterRope _ Rope.Concat[clusterRope, ": "];
rope _ Rope.Concat[clusterRope, GGSliceOps.DescribeHit[child, outlineHitData.childHitData]];
RETURN;
};
count _ count + 1;
ENDLOOP;
SIGNAL Problem["Unmatched outline and hitData in OutlineDescribeHit"];
};

Fileout: PUBLIC PROC [slice: Slice, f: IO.STREAM] = {
outlineData: OutlineData _ NARROW[slice.data];
count: NAT _ 0;
FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
count _ count + 1;
ENDLOOP;
f.PutF["Children: [%g]\n", [integer[count]]];
FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
GGSliceOps.FileoutSlice[f, childList.first]; -- not the class proc Fileout, but FileoutSlice
ENDLOOP;
};

Filein: PUBLIC PROC [f: IO.STREAM, version: REAL, router: MsgRouter, camera: Camera] RETURNS [children: LIST OF Slice] = {
count: NAT _ 0;
someChild, nextChild: Slice;
childList, ptr: LIST OF Slice;
IF version >= 8810.24 THEN GGParseIn.ReadWRope[f, "Children:"]
ELSE GGParseIn.ReadWRope[f, "Trajectories:"];
GGParseIn.ReadWRope[f, "["];
count _ GGParseIn.ReadWNAT[f];
GGParseIn.ReadWRope[f, "]"];
IF count>0 THEN {
[childList, ptr] _ GGUtility.StartSliceList[];
FOR i: NAT IN [0..count) DO
nextChild _ GGSliceOps.FileinSlice[f, version, router, camera, IF version>=8802.04 THEN NIL ELSE trajClass]; -- older files had only trajectories as children of outlines
IF someChild=NIL AND nextChild#NIL AND GGSliceOps.GetType[nextChild]=$Traj AND NARROW[nextChild.data, TrajData].role=circle THEN {
fillColor _ NIL; -- needed for the transition from circle/disc class
NARROW[nextChild.data, TrajData].role _ fence; -- fixup the kludge from TrajFilein
};
IF nextChild#NIL THEN {
someChild _ nextChild;
[childList, ptr] _ GGUtility.AddSlice[nextChild, childList, ptr];
}
ELSE ComplainAboutFile[f, "Parent", "NIL child detected", router];
ENDLOOP;
RETURN[childList];
}
ELSE ComplainAboutFile[f, "Parent", "parental object with no children detected", router];
};
OutlineFileout: PUBLIC PROC [slice: Slice, f: IO.STREAM] = {
outlineData: OutlineData _ NARROW[slice.data];
f.PutF["fillColor: "]; GGParseOut.WriteColor[f, outlineData.fillColor];
f.PutF[" ow: "]; GGParseOut.WriteBool[f, outlineData.oddWrap]; 
f.PutF[" fillText: "]; GGParseOut.WriteText[f, outlineData.fillText, outlineData.screenStyle]; 
f.PutChar[IO.CR];
GGParent.Fileout[slice, f];
};

OutlineFilein: PUBLIC PROC [f: IO.STREAM, version: REAL, router: MsgRouter, camera: Camera] RETURNS [slice: Slice] = {
oddWrap, good: BOOL _ TRUE;
fillColor: Color;
fillText: TextNode.Ref;
screenStyle: BOOL _ TRUE;
childList: LIST OF Slice;
IF trajClass=NIL THEN trajClass _ GGSlice.FetchSliceClass[$Traj];
GGParseIn.ReadWRope[f, "fillColor:"];
fillColor _ GGParseIn.ReadColor[f, version];
IF version>=8802.04 THEN {
GGParseIn.ReadWRope[f, "ow:"];
[oddWrap, good] _ GGParseIn.ReadBool[f, version];
};
IF version>=8803.24 THEN {
GGParseIn.ReadWRope[f, "fillText:"];
[fillText, screenStyle] _ GGParseIn.ReadText[f, version];
};
IF version < 8702.26 THEN { -- read and discard StrokeEnd from older formats
GGParseIn.ReadWRope[f, "strokeEnd:"];
[] _ GGParseIn.ReadStrokeEnd[f];
};
childList _ GGParent.Filein[f, version, router, camera];
IF childList#NIL THEN slice _ OutlineFromChildList[childList, fillColor, oddWrap, fillText, screenStyle, version];
};

ComplainAboutFile: PROC [f: IO.STREAM, className, complaint: Rope.ROPE, router: MsgRouter] = {
of: FS.OpenFile;
fileName: Rope.ROPE _ NIL;
of _ FS.OpenFileFromStream[f !
IO.Error => { fileName _ "not a file"; CONTINUE };
];
IF fileName=NIL THEN fileName _ FS.GetName[of].fullFName;
Feedback.PutF[router, oneLiner, $Complaint, "Filein Error for %g: %g slice, %g", [rope[fileName]], [rope[className]], [rope[complaint]] ];
};

IsEmptyParts: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [BOOL _ FALSE] = {
realParts: OutlineParts _ NARROW[sliceD.parts];
RETURN[IsEmpty[realParts]];
};

IsEmpty: PUBLIC PROC [realParts: OutlineParts] RETURNS [BOOL _ FALSE] = {
IF realParts=NIL THEN RETURN[TRUE]; -- NIL means Empty, Bier, June 29, 1990
FOR list: LIST OF SliceDescriptor _ realParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL AND NOT GGSliceOps.IsEmptyParts[list.first] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

IsCompleteParts: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [BOOL _ FALSE] = {
realParts: OutlineParts _ NARROW[sliceD.parts];
RETURN[IsComplete[realParts]];
};

IsComplete: PUBLIC PROC [realParts: OutlineParts] RETURNS [BOOL _ FALSE] = {
IF realParts=NIL THEN RETURN[FALSE]; -- NIL means empty, Bier, June 29, 1990
FOR list: LIST OF SliceDescriptor _ realParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first=NIL OR NOT GGSliceOps.IsCompleteParts[list.first] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

NewParts: PUBLIC PROC [slice: Slice, hitData: REF ANY, mode: SelectMode] RETURNS [sliceD: SliceDescriptor] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineHitData: OutlineHitData _ NARROW[hitData];
newParts: OutlineParts _ NEW[OutlinePartsObj];
SELECT mode FROM
none, slice, topLevel => { -- build a complete descriptor
ptr: LIST OF SliceDescriptor;
[newParts.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children=NIL DO
child: Slice _ children.first;
childD: SliceDescriptor _ IF mode=none THEN NIL ELSE GGSliceOps.NewParts[child, NIL, slice];
[newParts.descriptors, ptr] _ GGUtility.AddSliceDescriptor[childD, newParts.descriptors, ptr];
ENDLOOP;
sliceD _ GGSlice.DescriptorFromParts[slice, newParts]; -- empty or complete parts
};
ENDCASE => { -- all other cases need a legit hitData
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children=NIL DO
child: Slice _ children.first;
IF child=outlineHitData.child THEN {
childD: SliceDescriptor _ GGSliceOps.NewParts[child, outlineHitData.childHitData, mode];

sliceD _ GGParent.DescriptorFromChildDescriptor[slice, childD]; -- hit parts
RETURN;
};
ENDLOOP;
SIGNAL Problem["Unmatched outline and hitData in OutlineNewParts"];
};
};

UnionParts: PUBLIC PROC [partsA: SliceDescriptor, partsB: SliceDescriptor] RETURNS [aPlusB: SliceDescriptor] = {
realPartsA: OutlineParts _ NARROW[partsA.parts];
realPartsB: OutlineParts _ NARROW[partsB.parts];
IF partsA.parts = NIL THEN RETURN[partsB];
IF partsB.parts = NIL THEN RETURN[partsA];
IF IsEmpty[realPartsA] THEN RETURN[partsB];
IF IsEmpty[realPartsB] THEN RETURN[partsA];
IF IsComplete[realPartsA] THEN RETURN[partsA];
IF IsComplete[realPartsB] THEN RETURN[partsB];
BEGIN
ptr: LIST OF SliceDescriptor;
union: OutlineParts _ NEW[OutlinePartsObj];
listA: LIST OF SliceDescriptor _ realPartsA.descriptors;
listB: LIST OF SliceDescriptor _ realPartsB.descriptors;
[union.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
UNTIL listA = NIL DO
IF listA.first = NIL THEN [union.descriptors, ptr] _ GGUtility.AddSliceDescriptor[listB.first, union.descriptors, ptr]
ELSE IF listB.first = NIL THEN [union.descriptors, ptr] _ GGUtility.AddSliceDescriptor[listA.first, union.descriptors, ptr]
ELSE {
newSeq: SliceDescriptor _ GGSliceOps.UnionParts[listA.first, listB.first];
[union.descriptors, ptr] _ GGUtility.AddSliceDescriptor[IF GGSliceOps.IsEmptyParts[newSeq] THEN NIL ELSE newSeq, union.descriptors, ptr];
};
listA _ listA.rest;
listB _ listB.rest;
ENDLOOP;
aPlusB _ GGSlice.DescriptorFromParts[partsA.slice, union];
END;
};

DifferenceParts: PUBLIC PROC [partsA: SliceDescriptor, partsB: SliceDescriptor] RETURNS [aMinusB: SliceDescriptor] = {
realPartsA, realPartsB: OutlineParts;
diff: OutlineParts;
listA: LIST OF SliceDescriptor;
listB: LIST OF SliceDescriptor;
ptr: LIST OF SliceDescriptor;

IF partsA.parts = NIL OR partsB = NIL OR partsB.parts = NIL THEN RETURN[partsA];
realPartsA _ NARROW[partsA.parts];
realPartsB _ NARROW[partsB.parts];
listA _ realPartsA.descriptors;
listB _ realPartsB.descriptors;
diff _ NEW[OutlinePartsObj];
[diff.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
UNTIL listA = NIL DO
IF listA.first = NIL THEN [diff.descriptors, ptr] _ GGUtility.AddSliceDescriptor[NIL, diff.descriptors, ptr]
ELSE IF listB = NIL OR listB.first = NIL THEN [diff.descriptors, ptr] _ GGUtility.AddSliceDescriptor[listA.first, diff.descriptors, ptr]
ELSE {
newSeq: SliceDescriptor _ GGSliceOps.DifferenceParts[listA.first, listB.first];
[diff.descriptors, ptr] _ GGUtility.AddSliceDescriptor[IF GGSliceOps.IsEmptyParts[newSeq] THEN NIL ELSE newSeq, diff.descriptors, ptr];
};
listA _ listA.rest;
listB _ listB.rest;
ENDLOOP;
aMinusB _ GGSlice.DescriptorFromParts[partsA.slice, diff];
};

OutlineMovingParts: PROC [slice: Slice, selectedParts: SliceParts, editConstraints: EditConstraints, bezierDrag: GGInterfaceTypes.BezierDragRecord] RETURNS [background, overlay, rubber, drag: SliceDescriptor] = {
outlineData: OutlineData _ NARROW[slice.data];
filled: BOOL _ outlineData.fillColor#NIL OR outlineData.fillText#NIL;
RETURN GGParent.MovingParts[slice, selectedParts, filled, editConstraints, bezierDrag];
};

MovingParts: PUBLIC PROC [slice: Slice, selectedParts: SliceParts, treatAsAUnit: BOOL _ FALSE, editConstraints: EditConstraints, bezierDrag: GGInterfaceTypes.BezierDragRecord] RETURNS [background, overlay, rubber, drag: SliceDescriptor] = {
outlineData: OutlineData;
outlineParts: OutlineParts _ NARROW[selectedParts];
bkgdParts, overParts, rubberParts, dragParts: OutlineParts;
bkgdSeq, overSeq, rubberSeq, dragSeq: SliceDescriptor;
bkgdPtr, overPtr, rubberPtr, dragPtr: LIST OF SliceDescriptor;
children: LIST OF Slice;
nullD: SliceDescriptor _ slice.nullDescriptor;
forNow: BOOL _ TRUE;

IF IsEmpty[outlineParts] THEN {
background _ overlay _ rubber _ drag _ nullD;
RETURN;
};
IF IsComplete[outlineParts] THEN {
background _ overlay _ rubber _ nullD;
drag _ GGSlice.DescriptorFromParts[slice, selectedParts];
RETURN;
};

bkgdParts _ NEW[OutlinePartsObj];
overParts _ NEW[OutlinePartsObj];
rubberParts _ NEW[OutlinePartsObj];
dragParts _ NEW[OutlinePartsObj];

[bkgdParts.descriptors, bkgdPtr] _ GGUtility.StartSliceDescriptorList[];
[overParts.descriptors, overPtr] _ GGUtility.StartSliceDescriptorList[];
[rubberParts.descriptors, rubberPtr] _ GGUtility.StartSliceDescriptorList[];
[dragParts.descriptors, dragPtr] _ GGUtility.StartSliceDescriptorList[];

outlineData _ NARROW[slice.data];
children _ outlineData.children;
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first = NIL THEN {
[rubberParts.descriptors, rubberPtr] _ GGUtility.AddSliceDescriptor[NIL, rubberParts.descriptors, rubberPtr];
[dragParts.descriptors, dragPtr] _ GGUtility.AddSliceDescriptor[NIL, dragParts.descriptors, dragPtr];
IF treatAsAUnit THEN {
overSeq _ GGSliceOps.NewParts[children.first, NIL, slice]; -- complete descriptor
[overParts.descriptors, overPtr] _ GGUtility.AddSliceDescriptor[overSeq, overParts.descriptors, overPtr];
[bkgdParts.descriptors, bkgdPtr] _ GGUtility.AddSliceDescriptor[NIL, bkgdParts.descriptors, bkgdPtr];
}
ELSE {
bkgdSeq _ GGSliceOps.NewParts[children.first, NIL, slice]; -- complete descriptor
[bkgdParts.descriptors, bkgdPtr] _ GGUtility.AddSliceDescriptor[bkgdSeq, bkgdParts.descriptors, bkgdPtr];
[overParts.descriptors, overPtr] _ GGUtility.AddSliceDescriptor[NIL, overParts.descriptors, overPtr];
};
}
ELSE {
[bkgdSeq, overSeq, rubberSeq, dragSeq] _ GGSliceOps.MovingParts[list.first.slice, list.first.parts, editConstraints, bezierDrag]; -- for now bezierDrag is extra
IF treatAsAUnit OR forNow THEN {
[bkgdParts.descriptors, bkgdPtr] _ GGUtility.AddSliceDescriptor[NIL, bkgdParts.descriptors, bkgdPtr];
[overParts.descriptors, overPtr] _ GGUtility.AddSliceDescriptor[overSeq, overParts.descriptors, overPtr];
[rubberParts.descriptors, rubberPtr] _ GGUtility.AddSliceDescriptor[rubberSeq, rubberParts.descriptors, rubberPtr];
[dragParts.descriptors, dragPtr] _ GGUtility.AddSliceDescriptor[dragSeq, dragParts.descriptors, dragPtr];
}
ELSE {
[bkgdParts.descriptors, bkgdPtr] _ GGUtility.AddSliceDescriptor[overSeq, bkgdParts.descriptors, bkgdPtr];
[overParts.descriptors, overPtr] _ GGUtility.AddSliceDescriptor[NIL, overParts.descriptors, overPtr];
[rubberParts.descriptors, rubberPtr] _ GGUtility.AddSliceDescriptor[rubberSeq, rubberParts.descriptors, rubberPtr];
[dragParts.descriptors, dragPtr] _ GGUtility.AddSliceDescriptor[dragSeq, dragParts.descriptors, dragPtr];
};
};
children _ children.rest;
ENDLOOP;
background _ GGSlice.DescriptorFromParts[slice, bkgdParts];
overlay _ GGSlice.DescriptorFromParts[slice, overParts];
rubber _ GGSlice.DescriptorFromParts[slice, rubberParts];
drag _ GGSlice.DescriptorFromParts[slice, dragParts];
};

AugmentParts: PUBLIC PROC [sliceD: SliceDescriptor, selectClass: SelectionClass] RETURNS [more: SliceDescriptor] = {
ptr: LIST OF SliceDescriptor;
outlineParts: OutlineParts _ NARROW[sliceD.parts];
newParts: OutlineParts;
IF outlineParts = NIL THEN RETURN[sliceD];
newParts _ NEW[OutlinePartsObj];
[newParts.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR nextParts: LIST OF SliceDescriptor _ outlineParts.descriptors, nextParts.rest UNTIL nextParts=NIL DO
nextPart: SliceDescriptor _ nextParts.first;
[newParts.descriptors, ptr] _ GGUtility.AddSliceDescriptor[IF nextPart#NIL THEN GGSliceOps.AugmentParts[nextPart, selectClass] ELSE NIL, newParts.descriptors, ptr];
ENDLOOP;
more _ GGSlice.DescriptorFromParts[sliceD.slice, newParts];
};

AlterParts: PUBLIC PROC [sliceD: SliceDescriptor, action: ATOM] RETURNS [alteredD: SliceDescriptor] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
outlineData: OutlineData _ NARROW[sliceD.slice.data];
newParts: OutlineParts _ NEW[OutlinePartsObj];
childD: SliceDescriptor _ GGParent.FirstIncludedChild[sliceD.slice, sliceD.parts, first];
child: Slice _ childD.slice;
BEGIN
SELECT action FROM
$Forward, $Backward => {
IF IsComplete[outlineParts] THEN RETURN[NIL];
IF GGSliceOps.IsCompleteParts[childD] THEN {
beforeEnt, ent, afterEnt: LIST OF Slice;
[beforeEnt, ent, afterEnt, ----] _ GGUtility.FindSliceAndNeighbors[child, outlineData.children];
IF action = $Forward THEN
alteredD _ IF afterEnt = NIL THEN NIL
ELSE GGParent.DescriptorFromChild[sliceD.slice, afterEnt.first]
ELSE
alteredD _ IF beforeEnt = NIL THEN NIL
ELSE GGParent.DescriptorFromChild[sliceD.slice, beforeEnt.first];
}
ELSE GOTO Recurse;
};
$Grow => {
IF IsComplete[outlineParts] THEN RETURN[NIL];
IF GGSliceOps.IsCompleteParts[childD] THEN
alteredD _ GGSliceOps.NewParts[sliceD.slice, NIL, slice]
ELSE GOTO Recurse;
};
$ShrinkForward => {
IF IsComplete[outlineParts] THEN
alteredD _ GGParent.DescriptorFromChild[sliceD.slice, OutlineLastChild[sliceD.slice]]
ELSE GOTO Recurse;
};
$ShrinkBackward => {
IF IsComplete[outlineParts] THEN
alteredD _ GGParent.DescriptorFromChild[sliceD.slice, OutlineFirstChild[sliceD.slice]]
ELSE GOTO Recurse;
};
ENDCASE => ERROR;
EXITS
Recurse => {
alteredChildD: SliceDescriptor _ GGSliceOps.AlterParts[childD, action];
alteredD _ IF alteredChildD = NIL THEN NIL
ELSE GGParent.DescriptorFromChildDescriptor[sliceD.slice, alteredChildD];
};
END;
};

OutlineFirstChild: PROC [slice: Slice] RETURNS [child: Slice] = {
outlineData: OutlineData _ NARROW[slice.data];
child _ outlineData.children.first;
};

OutlineLastChild: PROC [slice: Slice] RETURNS [child: Slice] = {
outlineData: OutlineData _ NARROW[slice.data];
FOR list: LIST OF Slice _ outlineData.children, list.rest UNTIL list = NIL DO
child _ list.first;
ENDLOOP;
};

SetSelectedFields: PUBLIC PROC [sliceD: SliceDescriptor, selected: BOOL, selectClass: SelectionClass] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
IF outlineParts = NIL THEN RETURN;
FOR nextParts: LIST OF SliceDescriptor _ outlineParts.descriptors, nextParts.rest UNTIL nextParts=NIL DO
nextPart: SliceDescriptor _ nextParts.first;
IF nextPart#NIL THEN GGSliceOps.SetSelectedFields[nextPart, selected, selectClass];
ENDLOOP;
};

PointGeneratorData: TYPE = REF PointGeneratorDataObj;
PointGeneratorDataObj: TYPE = RECORD [
seqPtr: LIST OF SliceDescriptor,
pointGen: PointGenerator -- the point generator for the first sequence of seqPtr
];

PointPairGeneratorData: TYPE = REF PointPairGeneratorDataObj;
PointPairGeneratorDataObj: TYPE = RECORD [
seqPtr: LIST OF SliceDescriptor,
pointGen: PointPairGenerator -- the pair generator for first sequence of seqPtr
];

SegmentGeneratorData: TYPE = REF SegmentGeneratorDataObj;
SegmentGeneratorDataObj: TYPE = RECORD [
seqPtr: LIST OF SliceDescriptor,
segGen: SegmentGenerator -- the point generator for the first sequence of seqPtr
];

PointsInDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [pointGen: PointGenerator] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
descriptors: LIST OF SliceDescriptor;
childPointGen: PointGenerator;
pointGenData: PointGeneratorData;
descriptors _ IF outlineParts = NIL THEN NIL ELSE outlineParts.descriptors;
childPointGen _ IF descriptors = NIL OR descriptors.first = NIL THEN NIL ELSE GGSliceOps.PointsInDescriptor[descriptors.first];
pointGenData _ NEW[PointGeneratorDataObj _ [descriptors, childPointGen]];
pointGen _ NEW[PointGeneratorObj _ [sliceD, 0, 0, pointGenData]];
};

WalkPointsInDescriptor: PUBLIC PROC [sliceD: SliceDescriptor, walkProc: PointWalkProc] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
descriptors: LIST OF SliceDescriptor;
IF outlineParts = NIL THEN RETURN;
descriptors _ outlineParts.descriptors;
FOR descriptors: LIST OF SliceDescriptor _ outlineParts.descriptors, descriptors.rest UNTIL descriptors = NIL DO
IF descriptors.first # NIL THEN GGSliceOps.WalkPointsInDescriptor[descriptors.first, walkProc];
ENDLOOP;
};

PointPairsInDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [pointPairGen: GGModelTypes.PointPairGenerator] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
descriptors: LIST OF SliceDescriptor;
childPointPairGen: PointPairGenerator;
pointPairGenData: PointPairGeneratorData;
descriptors _ IF outlineParts = NIL THEN NIL ELSE outlineParts.descriptors;
childPointPairGen _ IF descriptors = NIL OR descriptors.first = NIL THEN NIL ELSE GGSliceOps.PointPairsInDescriptor[descriptors.first];
pointPairGenData _ NEW[PointPairGeneratorDataObj _ [descriptors, childPointPairGen]];
pointPairGen _ NEW[PointPairGeneratorObj _ [sliceD, 0, 0, pointPairGenData]];
};

SegmentsInDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [segGen: SegmentGenerator] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
descriptors: LIST OF SliceDescriptor _ IF outlineParts = NIL THEN NIL ELSE outlineParts.descriptors;
IF descriptors#NIL THEN {
segGenData: SegmentGeneratorData _ NEW[SegmentGeneratorDataObj _ [
seqPtr: descriptors, -- one descriptor per child in outline, including NILs for unincluded descriptors
segGen: IF descriptors.first=NIL THEN NIL ELSE GGSliceOps.SegmentsInDescriptor[descriptors.first] -- segGen for first child
]];
segGen _ NEW[SegmentGeneratorObj _ [
toGo: 9999, -- for debugging
sliceD: sliceD,
completeSeq: FALSE,
classSpecific: segGenData
]];
};
};

NextSegment: PUBLIC PROC [slice: Slice, segGen: SegmentGenerator] RETURNS [seg: Segment, transform: ImagerTransformation.Transformation] = {
segGenData: SegmentGeneratorData _ NARROW[segGen.classSpecific];
descriptors: LIST OF SliceDescriptor _ segGenData.seqPtr;
IF segGen.toGo#9999 THEN ERROR; -- for debugging
WHILE TRUE DO
IF descriptors.first # NIL THEN { -- maybe some seg left in this child
[seg, transform] _ GGSliceOps.NextSegment[descriptors.first.slice, segGenData.segGen];
IF seg#NIL THEN {
segGenData.seqPtr _ descriptors;
RETURN;
};
descriptors _ descriptors.rest; -- on to the next child
};
UNTIL descriptors = NIL OR descriptors.first # NIL DO descriptors _ descriptors.rest ENDLOOP;
IF descriptors = NIL THEN RETURN[NIL, NIL];
segGenData.segGen _ GGSliceOps.SegmentsInDescriptor[descriptors.first]; -- segGen for next child
ENDLOOP;
};

WalkSegments: PUBLIC PROC [slice: Slice, walkProc: WalkProc] RETURNS [sliceD: SliceDescriptor] = {
ptr: LIST OF SliceDescriptor;
outlineData: OutlineData _ NARROW[slice.data];
newParts: OutlineParts _ NEW[OutlinePartsObj];
[newParts.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR children: LIST OF Slice _ outlineData.children, children.rest UNTIL children=NIL DO
child: Slice _ children.first;
childD: SliceDescriptor _ GGSliceOps.WalkSegments[child, walkProc];
[newParts.descriptors, ptr] _ GGUtility.AddSliceDescriptor[childD, newParts.descriptors, ptr];
ENDLOOP;
sliceD _ GGSlice.DescriptorFromParts[slice, newParts];
};

NextPoint: PUBLIC PROC [slice: Slice, pointGen: PointGenerator] RETURNS [pointAndDone: GGModelTypes.PointAndDone] = {
pgd: PointGeneratorData _ NARROW[pointGen.classSpecific];
descriptors: LIST OF SliceDescriptor _ pgd.seqPtr;
IF descriptors = NIL THEN RETURN[[[0,0], TRUE]];
WHILE TRUE DO
IF descriptors.first # NIL THEN { -- maybe some point left in this child
pointAndDone _ GGSliceOps.NextPoint[descriptors.first.slice, pgd.pointGen];
IF NOT pointAndDone.done THEN {
pgd.seqPtr _ descriptors;
RETURN;
};
descriptors _ descriptors.rest; -- on to the next child
};
UNTIL descriptors = NIL OR descriptors.first # NIL DO descriptors _ descriptors.rest ENDLOOP;
IF descriptors = NIL THEN RETURN[[[0,0], TRUE]];
pgd.pointGen _ GGSliceOps.PointsInDescriptor[descriptors.first]; -- pointGen for next child
ENDLOOP;
};

NextPointPair: PUBLIC PROC [slice: Slice, pointPairGen: PointPairGenerator] RETURNS [pointPairAndDone: PointPairAndDone] = {
pgd: PointPairGeneratorData _ NARROW[pointPairGen.classSpecific];
descriptors: LIST OF SliceDescriptor _ pgd.seqPtr;
IF descriptors = NIL THEN RETURN[[[0,0], [0,0], TRUE]];
WHILE TRUE DO
IF descriptors.first # NIL THEN { -- maybe some pair left in this child
pointPairAndDone _ GGSliceOps.NextPointPair[descriptors.first.slice, pgd.pointGen];
IF NOT pointPairAndDone.done THEN {
pgd.seqPtr _ descriptors;
RETURN;
};
descriptors _ descriptors.rest; -- on to the next child
};
UNTIL descriptors = NIL OR descriptors.first # NIL DO descriptors _ descriptors.rest ENDLOOP;
IF descriptors = NIL THEN RETURN[[[0,0], [0,0], TRUE]];
pgd.pointGen _ GGSliceOps.PointPairsInDescriptor[descriptors.first];
ENDLOOP;
};

fillColor: PUBLIC Imager.Color _ Imager.MakeGray[0.5];
trajClass: SliceClass; -- filled in by OutlineFilein

END.

ฦGGOutlineImplA.mesa
Contents: Implementations of the Parent Meta-Class and the Outline class.
Copyright ำ 1986, 1987, 1988, 1989 by Xerox Corporation.  All rights reserved.
Pier, August 15, 1991 9:36 pm PDT
Eisenman, October 2, 1987 9:22:03 pm PDT
Bier, June 1, 1992 3:38 pm PDT
Doug Wyatt, December 18, 1989 2:48:02 pm PST

The Outline Class

Fundamentals
Drawing
Transforming
Textual Description
Parts
Part Generators
Hit Testing
Hit Testing moved to GGOutlineImplB
Style
Style moved to GGOutlineImplB
Fundamentals
Drawing
Transforming
Textual Description
Parts
Part Generators
Hit Testing
Hit Testing moved to GGOutlineImplB
Style
Style moved to GGOutlineImplB

Textual Description
The Cluster Class
Fundamentals
Drawing
Draw the big boxes for speed, if you can.
Textual Description
Parts
The Parent Meta-Class

Fundamentals
GGModelTypes.SliceBoundBoxProc
bound box of all the children
GGModelTypes.SliceBoundBoxProc
bound box of all the children
This PROC assumes that only Trajs can be copied in part.  All other classes are copied in entirety.
Since outlineParts represents a complete cluster or outline, copying a given child produces a single slice.
Creates the parent and adds the child to its list of children.
Since outlineParts represents a complete cluster or outline, copying a given child produces a single slice.
Add the rest of the children to the list.
GGModelTypes.SliceRestoreProc
from and to must be nearly identically structured slices, probably because from was made as a copy of to.  Restore the contents of "to", getting all non-REF values from "from".  Good luck.
CAN THIS LEAD TO OBSOLETE DESCRIPTORS??
Reparent !!
Reparent !!
to.nullDescriptor is always valid
to.fullDescriptor is unused


Drawing
GGModelTypes.SliceBuildPathProc
transformParts=NIL => complete parts. transform=NIL => don't transform any parts
GGModelTypes.SliceDrawBorderProc
drawParts=NIL => draw ALL parts.  transformParts=NIL => transform ALL parts.  transform=NIL => don't transform any parts.
This routine assumes it is called without needing to transform any of its parts or needing to take EditConstraints into account.
Currently draws entire outline.
Draw the fill.
Draw the strokes.
Draw the fill text.
Currently draws entire cluster.
Draw children back to front.

"parts" describes which children of slice are to be transformed (and which are to be drawn in place).  If parts is NIL, then all children are to be transformed (or not if transform = NIL);
Fill in the outline if appropriate.
Draw the strokes.
parts=NIL => transform entire slice
If some joints are both normal and hot selected, a special symbol is drawn at them, and separate symbols are drawn at other joints.  If the parent is entirely selected or entirely hot, and we are allowed to try fast feedback, a single large box is drawn for that selection type for the entire slice.
IF caretIsMoving OR dragInProgress THEN RETURN;
IF selectedParts=NIL AND hotParts=NIL THEN RETURN;
Draw the big boxes for speed, if you can.
The selectedParts are a hint as to what is being dragged.  Attractor feedback for the moving part is suppressed if the attractor is part of something that is moving.
Find out which parts of the child should not be highlighted (because they are moving).
The selectedParts are a hint as to what is being dragged.  Attractor feedback for the moving part is suppressed if the attractor is part of something that is moving.
Find out which parts of the child should not be highlighted (because they are moving).
Return which parts of child are mentioned in parts.
GGModelTypes.SliceSaveSelectionsProc
Ya gotta clear out them bits first because there may have been NO SELECTION!
GGModelTypes.SliceRemakeSelectionsProc

Transforming
Call GGSliceOps.Transform on each child, with history=NIL so the children will not make history list entries.  The outline will make one instead.
This proc assumes that every Box in the outline is filled if any are filled
This proc assumes that every Box in the outline is filled if any are filled
Textual Description
IF realParts describes exactly one child, return that child.  Otherwise return NIL.
An outlineHitData is now [child: Slice, childHitData: REF ANY];
Filein: PUBLIC PROC [f: IO.STREAM, version: REAL, router: MsgRouter, camera: Camera] RETURNS [children: LIST OF Slice] = {
8803.24, 8810.24
count: NAT _ 0;
class: SliceClass;
className: Rope.ROPE;
someChild, nextChild: Slice;
childList, ptr: LIST OF Slice;
IF version >= 8810.24 THEN GGParseIn.ReadWRope[f, "Children:"]
ELSE GGParseIn.ReadWRope[f, "Trajectories:"];
GGParseIn.ReadWRope[f, "["];
count _ GGParseIn.ReadWNAT[f];
GGParseIn.ReadWRope[f, "]"];
IF count>0 THEN {
[childList, ptr] _ GGUtility.StartSliceList[];
FOR i: NAT IN [0..count) DO
IF version>=8802.04 THEN {
className _ GGParseIn.ReadWWord[f];
class _ IF className=NIL THEN NIL ELSE GGSlice.FetchSliceClass[Atom.MakeAtom[className]];
IF class=NIL THEN {ComplainAboutFile[f, "unknown class", "NIL child detected", feedback]; LOOP;};
}
ELSE {
className _ "Traj";
class _ trajClass;
};
nextChild _ class.filein[f, version, feedback, camera];
IF someChild=NIL AND nextChild#NIL AND class.type=$Traj AND NARROW[nextChild.data, TrajData].role=circle THEN {
I think this is a bug (changing the global fillColor) but I don't know what its about and it is probably never happening so ...  KAP. January 4, 1989
fillColor _ NIL; -- needed for the transition from circle/disc class
NARROW[nextChild.data, TrajData].role _ fence; -- fixup the kludge from TrajFilein
};
IF nextChild#NIL THEN {
someChild _ nextChild;
[childList, ptr] _ GGUtility.AddSlice[nextChild, childList, ptr];
}
ELSE ComplainAboutFile[f, className, "NIL child detected", feedback];
ENDLOOP;
RETURN[childList];
}
ELSE ComplainAboutFile[f, "Parent", "parental object with no children detected", feedback];
};

I think this is a bug (changing the global fillColor) but I don't know what its about and it is probably never happening so ...  KAP. January 4, 1989

8803.24, 8810.24

Parts
An outlineHitData is now [child: Slice, childHitData: REF ANY];
Filled outlines have the property that if any of their subparts are on the overlay plane, then all of their parts are on the overlay plane.
(For now, all outline children are either completely on the overlay or completely off -- Bier, March 14, 1988)
Some parts are selected, but not all (the hard case)
This trajectory is not at all selected.  If this parent is to be treated as a unit, put it on the overlay.  Otherwise, leave it in the background.
Some or all of this trajectory is selected.  If the outline is treatAsAUnit, put all on overlay.  Otherwise, put non-moving parts on background.
Like, if you (normal) select a segment, you should select its end joints as well.  This PROC gives new classes a chance to invent their own rules for augmenting selections.
Set the selected fields of all of the joints and segments mentioned in sliceD.

Hit Testing

It looks like GGSliceOps.WalkPointsInDescriptor has to return a "done" BOOLEAN for this to work properly.
on to next non-NIL child
end of the line ??
Takes a slice and calls the walkProc for each segment in the slice with the segment data and possibly an associated transformation.  It returns a slice descriptor which describes all segments of the slice for which the walkProc returned TRUE.
on to next non-NIL child
on to next non-NIL child
สCŠ–

"cedar" style•NewlineDelimiter

˜Icodeš
œ™šฯbœA™IKš
œN™NKš
œ!™!Kš
œ(™(K™K™,—K™š
ฯk	˜	Jšœžœ‘žœ˜ฬ—K˜šฯnœžœ
ž˜Jšžœžœ”
žœ˜ฐ
Kšžœ ž˜-K˜Kšœ
žœ˜+Kšœžœ˜)Kšœ
žœ˜&Kšœžœ˜#Kšœžœ˜#Kšœžœ˜Kšœžœ&˜AKšœ
žœ˜-Kšœžœ ˜5Kšœ
žœ ˜1Jšœžœ˜*Kšœžœ˜'Kšœžœ˜1Kšœ	žœ˜*Kšœžœ˜#Kšœžœ˜3Kšœžœ˜Kšœ
žœž
œ˜*Kšœžœ˜0Kšœžœ˜0Kšœžœ˜6Kšœžœ˜,Kšœžœ˜2Kšœžœ˜!Kšœžœ˜/Kšœžœ˜3Kšœžœ"˜9Kšœžœ!˜7Kšœžœ#˜;Kšœžœ&˜AKšœžœ˜1Kšœžœ˜!Kšœ	žœ˜'Kšœžœ!˜7Kšœžœ$˜=Kšœžœ!˜5Kšœžœ˜+Kšœžœ ˜7Kšœžœ˜2Kšœžœ˜!Kšœžœ˜+Kšœžœ˜1Kšœžœ ˜5Kšœžœ)˜GKšœžœ˜3Kšœ
žœ˜'Kšœžœ˜+Iprocšœžœ˜#Kšœ
žœ˜'Kšœžœ˜Kšœ
žœ˜'Kšœ	žœ˜%Kšœžœ˜)Kšœžœ˜/Kšœžœ'˜;Kšœžœ˜/Kšœžœ˜#Kšœ
žœ˜'K˜Kšœžœ˜)Kšœžœ˜)Kšœ
žœ˜+Kšœ
žœ˜+Kšœžœ˜'K˜Lšœ
žœžœ˜'Lšœžœ˜.K˜KšŸœžœ
žœžœ˜;—
head1š
œ™K™—šŸœžœ
žœžœ˜Fšœžœ˜Kš
œ˜Kš
œ˜Kš
™Kš
œ"˜"Kšœ Ÿœ
˜;Kš
œ"˜"Kš
œ˜K˜Kš
™K˜K˜Kš
œ˜Kš
œ$˜$Kš
œ4˜4Kš
œ6˜6Kš
œ>˜>K˜(Kš
œ,˜,Kš
™Kš
œ˜Kš
™Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œ˜Kš
™Kš
œ$˜$Kš
œ*˜*Kš
œ˜Kš
œ ˜ Kš
œ*˜*Kš
œ ˜ Kš
œ$˜$Kš
œ ˜ Kš
œ.˜.Kš
™Kš
œ0˜0K˜8Kš
œ8˜8Kš
œ4˜4Kš
œ$˜$Kš
œ˜Kš
œ&˜&Kš
œ!˜!š
ฯi˜Kš
ะbi™Kš
ก#™#—Kš
 $˜$Kš
 6˜6Kš
 ;˜;Kš
 (˜(Kš
 ,˜,Kš
 0˜0š
 4˜4Kš
ก™Kš
ก™—Kš
 "˜"Kš
 (˜(Kš
 (˜(Kš
 $˜$Kš
 $˜$Kš
 (˜(Kš
 (˜(Kš
 (˜(Kš
 (˜(Kš
 $˜$Kš
 "˜"Kš
 !˜!Kš
 !˜!Kš
 ˜Kš
 ˜Kš
 ˜K˜—KšŸ"œ˜*K˜K˜—šŸœžœ
žœžœ˜Fšœžœ˜Kš
œ˜Kš
œ˜Kš
™Kš
œ"˜"Kšœ Ÿœ
˜;Kš
œ"˜"Kš
œ˜K˜Kš
™K˜!K˜#Kš
œ˜Kš
œ&˜&Kš
œ4˜4Kš
œ-˜-K˜5K˜(Kš
œ,˜,Kš
™Kš
œ˜Kš
™Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œ˜Kš
™Kš
œ$˜$Kš
œ*˜*Kš
œ˜Kš
œ ˜ Kš
œ*˜*Kš
œ ˜ Kš
œ$˜$Kš
œ ˜ Kš
œ.˜.Kš
™Kš
œ0˜0K˜8Kš
œ8˜8Kš
œ4˜4Kš
œ$˜$Kš
œ˜Kš
œ&˜&Kš
œ!˜!š
 ˜Kš
ก™Kš
ก#™#—Kš
 $˜$Kš
 6˜6Kš
 ;˜;Kš
 (˜(Kš
 4˜4Kš
 ,˜,Kš
 0˜0š
 4˜4Kš
ก™Kš
ก™—Kš
 "˜"Kš
 (˜(Kš
 (˜(Kš
 $˜$Kš
 $˜$Kš
 (˜(Kš
 (˜(Kš
 (˜(Kš
 (˜(Kš
 $˜$Kš
 $˜$Kš
 !˜!Kš
 !˜!Kš
 ˜Kš
 ˜K˜K˜—KšŸ"œ˜*K˜K˜—šŸœžœ
žœ
žœ#žœžœ'žœžœžœ˜ต
KšœžœR˜išœ
žœ
˜Kš
œ)˜)Kšœžœ
˜K˜Kšœžœžœžœ˜&Kš
œ$˜$Kš
œ$˜$Kšœ
žœ˜—šžœžœ
žœžœžœ
ž˜:Kš
œ˜Kšžœ
˜—Kšœ>žœ˜Cšžœžœฯcn˜ˆ
Kšœ0žœœžœข#˜cšžœžœ
žœ'žœ
žœ
ž˜QKšœ/žœœžœข&˜dKšžœ
˜—K˜—Kšœ6žœ˜;Kš
œ˜K˜—šŸœžœ
žœ
žœžœžœžœ˜oKš	œžœžœ
žœ%žœ'˜—
šœ	žœ
˜Kš
œ)˜)Kšœžœ
˜K˜Kšœžœžœžœ˜&Kš
œ$˜$Kš
œ$˜$Kšœ
žœ˜—šžœžœ
žœžœžœ
ž˜:Kš
œ˜Kšžœ
˜—Kšœ<žœ˜AKš
œ˜—K™Kš
œ™šŸœžœžœ
žœ˜MKšžœ'˜-K˜—šŸœžœžœ
žœ˜MKšžœ'˜-K˜—M™Kš
œ™šŸœžœ$žœžœžœ
žœ˜[šŸœžœžœ˜CKš
œ˜Kš
œ!˜!Kš
œ0˜0Kšœ
žœ˜Kšœžœ3˜MK˜—Lšœžœ˜+Kšœžœ
˜*Kšœžœ˜;L˜Kš
œ+˜+K˜—K˜Kš
œ™šŸœžœ”
žœ˜ฦ
Kšœ2žœžœ
˜?Kšœ#žœ˜9Kšœ žœ˜1Kšœ
žœžœ
˜K˜Kšžœžœžœ
žœ
˜/Kšžœžœ
žœ
žœ
žœ
žœ
˜2K˜Kšœ$žœ
žœ ˜KKšœžœ
žœ˜BKš	œžœ
žœ
žœžœ˜BKš	œžœ
žœ
žœžœ˜7K˜Kš
œz˜zKš
)™)šžœ
žœžœžœ˜+Kšœ(žœ˜-Kš
œ4˜4Kš
œZ˜ZKšœžœ
˜K˜—šžœ
žœ	žœ
žœ˜%Kšœ(žœ˜-Kš
œ4˜4Kš
œW˜WKšœžœ
˜K˜—šžœ
žœ
žœžœžœ
žœžœ˜\Kšœ(žœ˜-Kš
œ4˜4K˜—K˜—K˜Kš
œ™šŸœžœžœ
žœ˜<Lšœžœ
˜.Lšœžœ˜<Lš
œA˜ALšœ
žœ
žœ˜Lš
œ˜Lš
œ˜L˜—šŸ
œžœžœ
žœžœ%žœ˜vLšœžœžœ
˜Lšœžœ
žœ˜Lš
œ"˜"Lš
œ0˜0Lš
œ8˜8Kšžœžœ
žœ:˜OLš
œ˜—L˜Kš
œ™šŸœžœ|žœ9˜ิ
Kšœžœ
˜.Kšžœ,žœ˜UK˜—K˜M™K™š
œ™K˜—šŸœžœ˜&šžœžœ
žœ˜Kšœžœ
˜.Kš
œ˜šžœžœ
žœ.žœžœ
ž˜ZKšžœžœ%ข)˜nKšžœ
˜—Kšœžœ
˜K˜—K˜K˜—•StartOfExpansion# -- [cluster: GGModelTypes.Cluster]šŸœžœ#žœ˜VKš
œ™Kšžœžœžœ
žœ
žœข˜Hšžœ˜Kšœžœ˜+Kšœžœ
˜.Kšœžœ
žœ
˜Kš
œ˜šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pJš
œ™Jš
œ7˜7Jšœžœ˜0Jš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`šžœžœ
žœ˜Jš
œJ˜JJšœžœ˜0J˜—Jšžœ
˜—Jš
œ/˜/šžœžœ
žœข.˜BKšœ(ข˜EKš
œ˜Kšœžœ
˜K˜—K˜—K˜K˜—–# -- [cluster: GGModelTypes.Cluster]šŸœžœ#žœ˜VKš
œ™Kšžœžœžœ
žœ
žœข˜Mšžœ˜Kšœžœ˜+Kšœžœ
˜.Kšœžœ
žœ
˜Kš
œ˜šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pJš
œ™Jšœœ˜7Jšœžœ˜0Jš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`šžœžœ
žœ˜Jšœœ%˜JJšœžœ˜0J˜—Jšžœ
˜—Jš
œ/˜/šžœžœ
žœข.˜BKšœ(ข˜EKš
œ˜Kšœžœ
˜K˜—J˜—K˜K˜—šŸœžœ$žœžœžœ
žœ˜[šŸœžœžœ˜CKš
œ˜Kš
œS˜SKšœ
žœ˜Kš
œ"˜"Kš
œ$˜$Kš
œ*˜*K˜—Kšœžœ
˜*Kšœžœ˜'Kšœžœ$˜+š	žœžœ
žœžœข!˜MKšœIžœ˜NK˜—K˜K˜—šŸœžœ
žœ$žœ
žœžœžœžœ
žœ˜“
K™cKš
œ˜Kš
œ˜Lšœžœ
žœ˜Lšœžœ˜+L˜š	žœžœ
žœžœข!˜Qš
Ÿœžœžœžœžœ˜>šžœžœ
žœ˜š
œ(˜(Kš
œk™k—š
œ˜K™>—Kšœ
žœ˜!K˜
—šžœ˜š
œ(˜(Kš
œk™k—Kš
œ>˜>Kš
œ˜K˜—K˜—Kšœ
žœ
˜Lš
œ-˜-Kš
œ3˜3šžœ
ž˜KšžœJ˜N—Kš
œ)™)Kšœžœ˜K˜
—šžœข7˜>šŸ
œžœžœžœ˜=KšœQžœ	˜]Kš
œ/˜/Kšžœ	žœ=˜LJšœ'žœ˜7Kš
œ˜—š
Ÿ
œžœžœžœžœ˜KKš
œ ˜ Kš
œ&˜&šžœ%žœ˜-Jšœ'œ˜OK˜
—šžœ
ž
˜Kšœžœ
˜/Kšžœ'žœžœ
˜Lšžœ˜Jš
œZ˜Zšžœ[žœ	žœ
ž˜ršžœ
žœ)žœ˜5Kš
œh˜hKšžœ
˜Kš
œ˜—Jš
œ6˜6Jš
œ8˜8Jšœ'žœ˜7Jšžœ
˜—J˜—J˜—J˜—KšœMžœ	˜YJš
œD˜DJ˜—K˜K˜—šŸœžœž
œ˜1Kš
œ™K™ผ
Kšžœžœ
žœžœ
žœ
žœ
˜!Kšžœžœ
žœ
˜"K˜Kšœžœžœ
žœ
˜'Kšžœžœ
žœ
žœ
žœ
žœ˜1K˜š
ž˜Kšœ
žœ˜Kšœžœ˜*Kšœžœ
žœ˜0Kšœžœ˜Kšœžœ
˜&Kšœžœ
žœ˜,Kšœžœ
žœ	žœ
˜$K˜Kšœฯtœฃ
˜"Kšœฃœ	ฃ
˜&Kšœฃœฃ
˜$Kšœฃœฃ
˜*K˜š	žœžœ
žœ%žœž˜OK˜Kšžœ
˜—š	žœ	žœ
žœ!žœž˜GKš
œ˜Kšžœ
˜—K˜šัbklœ	œ
ค˜šžœžœ˜šžœžœ
ž˜Kšœœ1˜CKšœข6˜TKš
œ˜Kš
œ!˜!Kš
œ˜Kšžœ
˜—šžœžœ
žœข*˜GKš
ข'™'šœ$ข˜8K™—šžœžœ
žœ%žœ
žœ
ž˜OKš
œ˜Kšžœ
˜—K˜
—K˜
—šžœข˜šžœžœ
ž˜Kšœœ1˜CKšœข6˜TKš
œ˜Kš
œ!˜!Kš
œ˜Kšžœ
˜—Kš	žœžœ
žœžœขQ˜‡
K˜
K˜——šคœ˜K™šžœžœ
žœ*žœ
žœ
ž˜TKš
œ˜Kšžœ
˜—Kšœ%ข˜9K˜—K˜Kšœ)ข˜:Kšœžœข˜5Kšœžœข˜2Kšœžœข˜5Kšœžœข˜4K™!K™K˜Kš
œ&˜&Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œ ˜ K™Kšžœ
˜—K˜K˜K˜—K™š
œ™K˜—šŸœžœู
˜๖
Kš
œ™Kš
œP™PKšœžœ
˜.Kšœ&žœ˜=Kšœ
žœ
žœ
˜"Kš	œžœ
žœ
žœžœ
˜:Kšœžœ
žœžœžœ
žœ
žœ
žœ#˜tšžœžœ
žœ-žœžœ
ž˜YKšœ
žœ,žœ
žœ*˜mšžœ
žœข&˜9Kšžœ
žœ&žœžœ;˜|Kšžœ
žœžœ&žœF˜ˆ
Kšžœ&žœžœ
žœ
žœ
žœ!žœžœ
žœ
žœ
žœF˜๋
K˜—Kšžœžœ
žœ.˜LKšžœ
˜—K˜K˜—šŸœžœ‰
žœžœ.˜แ
Kš
œ ™ Kš
œy™yKšœžœ
˜.Kšœ!žœ˜3Kšœ&žœ˜=Kšœ
žœ
žœ
˜"Kš	œžœ
žœ
žœžœ
˜:Kšœ	žœ
žœ
˜Kšœžœ
žœžœžœ
žœ
žœ
žœ#˜tKš
œžœ
žœžœ	žœ
žœ
žœ˜_šžœžœ
žœ-žœžœ
ž˜Yš	žœ	žœžœ
žœข ˜MKšžœ
žœ'žœ	žœ
žœ
žœžœžœ%˜›
Kšžœ
žœžœ'žœ	žœ
žœ
žœžœ0˜ง
Kšžœ'žœ	žœ
žœ
žœžœžœ
žœ
žœ
žœ!žœžœ
žœ
žœ
žœ0˜ŠK˜—Kšžœžœ
žœ.˜LKšžœžœ
žœ$˜=Kšžœ
˜—K˜—K˜šŸœžœNžœ˜tK™€
K™šŸœ˜!šžœžœ
žœ-žœžœ
ž˜YKšœžœ%˜1Kš
žœ
žœžœ
œžœžœ2ข˜
Kšžœ
˜—K˜—Kšœžœ
˜.Kš
™šžœžœ
žœ˜#Kš
œ.˜.Kš
œ7˜7K˜—Kš
™šžœžœ
žœ-žœžœ
ž˜YKš
œžœžœžœžœ˜NKšžœ
˜—Kš
™š
ž˜š
Ÿœžœžœ	žœžœ˜BKš
œ-˜-K˜—K˜;Kšžœ
˜—K˜K˜—šŸ	œžœ
žœNžœ˜mK™K™Kšœžœ
˜.šžœžœ
žœ-žœžœ
ž˜YKšœ%žœ˜=Kšžœ
˜—K˜K™—šŸœžœ$žœf˜ฎ
Kš
œผ
™ผ
šŸœ˜!Kšœžœ
žœ˜#Kš
œ˜Kšœžœžœ
žœ
žœ
žœ˜Išžœžœ
žœ-žœžœ
ž˜YKšœžœžœ
žœžœ
žœ
žœ
žœ˜aKšœžœ
žœ
žœžœ
žœžœ
žœ
˜F
defaultšžœ
žœ"˜(Nšžœs˜w—Kšžœ
žœ
žœ˜3Kšžœ
˜—K˜—Kšœžœ
˜.Kšœžœ˜+Kšœ
žœ
žœ˜%Kš
œ˜K˜Kšœžœžœ
žœ
žœ
žœ˜KKš
#™#šžœžœ
žœ˜#Kšžœžœ9˜YKšžœ/˜3Kš
œ7˜7K˜—Kš
™š
ž˜Kš
œ˜šžœžœ
žœ-žœžœ
ž˜YNšœžœ
žœ
žœžœ
žœ
žœ
žœ˜cNšœžœžœ
žœžœ
žœžœ
žœ
˜JNšœ&žœ!žœ˜bKšžœžœ
žœ ˜9Kšžœ
˜—Kšžœ
˜—K˜K˜—šŸ
œžœ
žœ$žœf˜ง
Kšœžœ™#Kšœžœ
˜.Kšœžœ˜+Kšœžœ
žœ˜#K˜Kš
œ˜K˜'K˜Kšœžœžœ
žœ
žœ
žœ˜Išžœžœ
žœ-žœžœ
ž˜YKš
œ˜šžœ
žœ
žœข˜8Kšœ
žœ
˜Kš
œ˜K˜
—š	žœ
žœžœ
žœข˜:Kš
œ#˜#Kš
œ˜K˜
—šžœข˜$Kšœ
žœ
˜Kšœžœ
˜K˜—Kš
œP˜PKšžœ
ž	œž
œ˜4Kšžœ
˜—K˜K˜—šŸœžœ”
žœ˜ฟ
K™ซKšœžœ
žœ˜-Kšœ2žœžœ
˜?Kšœ#žœ˜9Kšœ žœ˜1Kšžœžœžœ
žœ
™/Kšžœžœ
žœ
žœ
žœ
žœ
™2Kšœ$žœ
žœ ˜KKšœžœ
žœ˜BKš	œžœ
žœ
žœžœ˜BKš	œžœ
žœ
žœžœ˜7šžœžœ	žœ˜ Kš
œ&˜&šžœ>žœžœ
ž˜Xšžœžœ
žœข<˜ZKš
œœ1žœžœ
žœ
žœ
žœP˜ร
—š	žœ
žœžœ
žœ
ข(˜GKšœœžœR˜‹
—Kš
œ˜Kšžœ
˜—K˜
—šžœ
žœžœ˜šžœ>žœžœ
ž˜ZKš
žœžœ
žœœ1žœ=˜ฐ
Kšžœ
˜—K˜
—šžœ
žœ	žœ˜šžœ5žœžœ
ž˜NKš
žœžœ
žœœžœR˜ง
Kšžœ
˜—K˜—K˜K˜—šŸœžœ”
žœ˜ฦ
Kšœ2žœžœ
˜?Kš
œ˜Kšœ#žœ˜9Kšœ žœ˜1K˜Kšžœžœžœ
žœ
˜/Kšžœžœ
žœ
žœ
žœ
žœ
˜2K˜Kšœ$žœ
žœ ˜KKšœžœ
žœ˜BKš	œžœ
žœ
žœžœ˜BKš	œžœ
žœ
žœžœ˜7K˜Kš
œz˜zKš
)™)šžœžœžœžœžœ	žœžœ˜NKšœžœžœ&žœ#˜‚
K–([sliceD: 
GGModelTypes.SliceDescriptor]š
œF˜FK–F[slice: 
GGModelTypes.Slice, pointGen: 
GGModelTypes.PointGenerator]š
œV˜VKš
œ˜—šžœ
žœžœž˜)Kš
œH˜H—šžœ
žœ	žœ
ž˜#Kš
œE˜E—K˜K˜—šะbnœžœWžœK˜ศ
J™ฅ
Jšœ	žœžœ
˜Jš
œ˜Jš
œ˜JšœDข`˜ค
Kšžœ
žœ
žœ
žœ
˜K™VKšœŸœ%˜MKš
œ~˜~K˜K˜—šŸœžœWžœ4žœ˜ะ
J™ฅ
Jšœ	žœžœ
˜Jš
œ˜Jš
œ˜JšœDขA˜…
Kšžœ
žœ
žœ
žœ
˜K™VKšœŸœ%˜MKš
œ„
˜„
K˜K˜—šŸœžœ1žœ˜nKš
œ3™3Kšœžœ˜+Kšžœžœ
žœžœ
žœ
žœ˜+šžœžœ
žœ>žœ
žœ
ž˜nKš
žœžœ
žœžœ
žœ˜`Kšžœ
˜—K˜K˜—šŸœžœC˜^Kš
œ$™$K™LKšœ
žœ
žœ	žœ#˜Cšžœžœ
žœ&žœžœ
ž˜ZKšœ/žœข˜_Kšžœ
˜—šžœžœ
žœข˜2Kšœžœ˜+Kšœžœ
žœ˜'Kšžœžœ
žœ
žœ
˜"Kš
œ*˜*šžœžœ
žœ6žœžœ
ž˜lKšžœžœ
žœœF˜€
Kšžœ
˜—K˜—K˜K˜—šฅœžœ-žœ˜iKš
œ&™&Kš
œ˜Kšœžœ˜2Kšœžœžœ
˜Kšœžœ
žœ˜Kšœ
žœ
žœ	žœ#˜CKš
œG˜Gšžœžœ
žœ%žœžœ
ž˜WKšœ'œ"˜YKšžœžœ
žœ
ž˜&šžœ˜Kš
œH˜HKšœ
žœ
˜K˜—š
œ!˜!Kš
œD˜D—Jšžœ
˜—Kšžœžœžœ	žœ
˜9K˜—K™š
œ™K˜—šŸ	œžœ$žœn˜ซ
Kšœžœ˜+Kšœžœ
˜.Kš
œ‘
™‘
šžœžœ
žœ˜šžœžœ
žœ)žœžœ
ž˜MKšœ!žœะbkœ˜GKšžœ
˜—K˜
—šžœ˜šžœžœ
žœ7žœžœ
ž˜[Kšžœžœ
žœVฆœ˜qKšžœ
˜—K˜—Kš
œ˜Kšžœžœ
žœžœT˜Š
šžœžœ
žœ˜$šŸœžœžœžœžœข˜VK™KKš
œ/˜/Kšžœ
žœ
žœ
žœžœข˜>Kšœ6ข˜TKšœข&˜CKšžœ
žœข˜!K˜—šŸ
œžœžœžœžœข˜UK™Kšžœžœข-˜QKš
œT˜TKš
œ3˜3Kš
œ;˜;Kš
œ˜K˜—K˜—Kš
œ˜Kšœžœžœ
˜*K˜K˜Kš
œJ˜JKšžœžœ>˜TKš
œ˜—K˜—K˜š
œ™K˜—šŸœžœžœ ˜XKš
œS™Sšžœžœ
žœ4žœžœ
ž˜Xšžœžœ
žœ˜Kšžœ
žœ
žœ
žœ
žœข˜7Kšžœ˜K˜—Kšžœ
˜—K˜K˜—šŸœžœ
žœ+žœžœ
žœ˜cKš
œ˜Kš
œ˜Kšžœžœ
žœ
žœ˜-Kšœžœ˜!šžœ*žœ
žœ˜6Kš
œ%˜%K˜
—šžœ˜šžœžœ
žœ4žœžœ
ž˜XJšžœžœ
žœ
žœ<˜YJšžœ
˜—Jš
œ9˜9J˜—K˜K˜—šŸœžœžœ
žœžœ
žœ˜WKšœžœ
˜.Kšœ!žœ
˜1Kšœžœ˜K™?šžœžœ
žœ-žœ
žœ
ž˜WKš
œ˜šžœžœ˜$Kšœžœ
˜Kšžœžœžœ$˜VKšžœžœ ˜5Kšžœ
žœžœ.˜RKš
œ\˜\Kšžœ
˜K˜—Kš
œ˜Kšžœ
˜—Kšžœ@˜FK˜K˜—šŸœžœžœ
žœ˜5Lšœžœ
˜.Lšœžœ˜šžœžœ
žœ.žœ
žœ
ž˜\Lš
œ˜Lšžœ
˜—Lš
œ-˜-šžœžœ
žœ.žœ
žœ
ž˜\Lšœ-ข/˜\Lšžœ
˜—Lš
œ˜L˜—šŸœžœ
žœžœ
žœžœ%žœžœ
žœ™zLš
œ™Lšœžœ™Lš
œ™Kšœžœ
™L™Lšœžœ
žœ™Lšžœžœ$™>Lšžœ)™-Lš
œ™Lš
œ™Lš
œ™šžœžœ™Lš
œ.™.šžœžœ
žœž™šžœžœ™Kš
œ#™#Kšœžœžœ
žœ
žœ
žœ3™YKšžœžœ
žœIฆœ™aK™
—šžœ™Kš
œ™Kš
œ™K™—Lš
œ7™7šžœžœ
žœžœ
žœžœ
žœ'žœ™oKš
ϥ
™•
Kšœžœข3™DKšžœ)ข#™RK™—šžœžœ
žœ™Kš
œ™Kš
œA™AK™
—KšžœA™ELšžœ
™—Lšžœ™L™
—LšžœW™[L™K™—šŸœžœ
žœžœ
žœžœ%žœžœ
žœ˜zLšœžœ˜L˜Lšœžœ
žœ˜Lšžœžœ$˜>Lšžœ)˜-Lš
œ˜Lš
œ˜Lš
œ˜šžœžœ˜Lš
œ.˜.šžœžœ
žœž˜Lš
œ?žœžœ
žœ
žœ
ข<˜ฉ
–[slice: 
GGModelTypes.Slice]šžœžœ
žœžœ
žœ%žœ
žœ'žœ˜‚
Kš
ϥ
™•
Kšœžœข3˜DKšžœ)ข#˜RK˜—šžœžœ
žœ˜Kš
œ˜Kš
œA˜AK˜
—K–[atom: 
ATOM]šžœ>˜BLšžœ
˜—Lšžœ˜L˜
—LšžœU˜YL˜K™—šŸœžœžœ
žœ˜<Lšœžœ
˜.Lš
œG˜GLš
œ?˜?Lš
œ_˜_Lšœ
žœ
žœ˜Lš
œ˜Lš
œ˜L˜—šŸ
œžœžœ
žœžœ%žœ˜vLš
œ™Lšœžœžœ
˜Lš
œ˜Lš
œ˜Lšœ
žœžœ
˜Lšœžœ
žœ˜Kšžœžœ
žœ,˜ALš
œ%˜%Lš
œ,˜,šžœžœ˜Lš
œ˜Lš
œ1˜1L˜—šžœžœ˜Lš
œ$˜$Lš
œ9˜9L˜—šžœžœข0˜LLš
œ%˜%Lš
œ ˜ Lš
œ˜—Lš
œ8˜8Lšžœžœ
žœ]˜rL˜L˜—š
Ÿœžœžœ
žœžœ˜^Kšœžœ
˜Kšœžœžœ
˜šœžœ˜Kšžœ%žœ˜2Kš
œ˜—Kšžœ
žœ
žœžœ˜9Kš
œŠ
˜Š
K˜—K™š
œ™K˜—šŸœžœžœžœ˜NKšœžœ˜/Kšžœ˜K˜K˜—šŸœžœžœžœ˜IKšžœžœ
žœ
žœ
žœข'˜Kšžœžœ
žœ4žœžœ
ž˜XKšžœžœ
žœ
žœ%žœ
žœ
žœ˜QKšžœ
˜—Kšžœ
žœ˜
K˜K˜—šŸœžœžœžœ˜QKšœžœ˜/Kšžœ˜K˜K˜—šŸ
œžœžœžœ˜LKšžœžœ
žœ
žœ
žœข'˜Lšžœžœ
žœ4žœžœ
ž˜XKšžœžœ
žœ'žœ
žœ
žœ˜SKšžœ
˜—Kšžœ
žœ˜
K˜K˜—š
Ÿœžœžœ
žœžœ˜nKšœžœ
˜.Kšœ!žœ
˜1K™?Kšœžœ˜.šžœž˜šœข˜9Kšœžœ
žœ˜Kšœ(œ˜Cšžœžœ
žœ-žœ
žœ
ž˜WKš
œ˜Kšœžœžœ
žœ
žœžœ	˜\Kšœ(Ÿœ$˜^Kšžœ
˜—Kšœ7ข˜QK˜—šžœข'˜4šžœžœ
žœ-žœ
žœ
ž˜WKš
œ˜šžœžœ˜$Kšœ%œ+˜XK˜Kšœ@ข˜LKšžœ
˜K˜—Kšžœ
˜—Kšžœ=˜CK˜——K˜K˜—šŸ
œžœ4žœ˜pKšœžœ˜0Kšœžœ˜0Kšžœžœ
žœ
žœ	˜*Kšžœžœ
žœ
žœ	˜*Kšžœžœ
žœ	˜+Kšžœžœ
žœ	˜+Kšžœžœ
žœ	˜.Kšžœžœ
žœ	˜.š
ž˜Kšœžœ
žœ˜Kšœžœ˜+Kšœžœ
žœ*˜8Kšœžœ
žœ*˜8Kšœ%œ˜@šžœ	žœ
ž˜Kšžœžœ
žœ]˜vKšžœ
žœžœ
žœ]˜{šžœ˜Kš
œJ˜JKšœ%œ
žœ!žœ
žœ
žœ!˜‰
K˜—Kš
œ˜K˜Kšžœ
˜—Kš
œ:˜:Kšžœ
˜—K˜K˜—šŸœžœ4žœ˜vKš
œ%˜%Kš
œ˜Kšœžœ
žœ˜Kšœžœ
žœ˜Kšœžœ
žœ˜K˜Kšžœžœ
žœ
žœ
žœžœ
žœ
žœ	˜PKšœ
žœ˜"Kšœ
žœ˜"Kš
œ˜Kš
œ˜Kšœžœ˜Kšœ$œ˜?šžœ	žœ
ž˜Kš
žœžœ
žœ%Ÿœ
žœ˜lKšžœ
žœ	žœ
žœžœ
žœ[˜ˆ
šžœ˜Kš
œO˜OKšœ$Ÿœ
žœ!žœ
žœ
žœ ˜‡
K˜—Kš
œ˜K˜Kšžœ
˜—Kš
œ:˜:K˜K˜—šŸœžœ|žœ9˜ิ
Kšœžœ
˜.Kš	œžœžœ
žœžœ
˜EKšžœQ˜WK˜K˜—šŸœžœ
žœ9žœžœSžœ9˜๐
K™‹
K™nK˜Kšœžœ˜3Kš
œ;˜;Kš
œ6˜6Kšœ&žœ
žœ˜>Kšœ
žœ
žœ˜Kš
œ.˜.Kšœžœžœ
˜K˜šžœžœ˜Kš
œ-˜-Kšžœ
˜K˜—šžœžœ˜"Kš
œ&˜&Kš
œ9˜9Kšžœ
˜K˜K˜—Kš
4™4Kšœžœ˜!Kšœžœ˜!Kšœžœ˜#Kšœžœ˜!K˜Kš
œH˜HKš
œH˜HKš
œL˜LKš
œH˜HK˜Kšœžœ
˜!Kš
œ ˜ šžœžœ
žœ7žœžœ
ž˜[šžœžœ
žœ˜Jš
’
™’
JšœDžœ&˜mJšœ@žœ"˜ešžœžœ˜Jšœ.žœ
ข˜QJš
œi˜iJšœ@žœ"˜eJ˜
—šžœ˜Jšœ.žœ
ข˜QJš
œi˜iJšœ@žœ"˜eJ˜—J˜
—šžœ˜Jš

™
Jšœ‚
ข˜ 
šžœžœžœ˜ Jšœ@žœ"˜eJš
œi˜iJš
œs˜sJš
œi˜iJ˜
—šžœ˜Jš
œi˜iJšœ@žœ"˜eJš
œs˜sJš
œi˜iJ˜—J˜—J˜Jšžœ
˜—Jš
œ;˜;Jš
œ8˜8Jš
œ9˜9Jš
œ5˜5J˜J˜—šŸœžœ8žœ˜tK™ฌ
Kšœžœ
žœ˜Kšœžœ˜2Kš
œ˜Kšžœžœ
žœ
žœ	˜*Kšœžœ˜ Kš
œC˜Cšžœžœ
žœ<žœžœ
ž˜hKš
œ,˜,Kš
œ;žœ
žœ
žœœžœ
žœ˜ค
Kšžœ
˜—Kš
œ;˜;K˜K˜—š
Ÿ
œžœ
žœ#žœžœ ˜gKšœžœ˜2Kšœžœ˜5Kšœžœ˜.Kš
œY˜YKš
œ˜š
ž˜šžœž˜˜Kšžœžœ
žœ
žœ˜-šžœ$žœ˜,Kšœžœ
žœ˜(KšœขœA˜`šžœž˜šœžœžœ
žœ
ž˜%Kšžœ;˜?——š
ž˜šœžœ
žœ
žœ
ž˜&Kšžœ=˜A——K˜
—Kšžœ
žœ	˜K˜—˜
Kšžœžœ
žœ
žœ˜-šžœ$ž˜*Kšœ-žœ˜8—Kšžœ
žœ	˜K˜—˜šžœž˜ Kš
œU˜U—Kšžœ
žœ	˜K˜—˜šžœž˜ Kš
œV˜V—Kšžœ
žœ	˜K˜—Kšžœžœ
˜—š
ž˜˜Kš
œG˜Gšœžœžœ
žœ
ž˜*KšžœE˜I—K˜——Kšžœ
˜—K˜K˜—šŸœžœžœ˜AKšœžœ
˜.Kš
œ#˜#K˜K˜—šŸœžœžœ˜@Kšœžœ
˜.šžœžœ
žœ)žœžœ
ž˜MJš
œ˜Jšžœ
˜—K˜K˜—šŸœžœ%žœ"˜iKš
œN™NK™Kšœžœ˜2Kšžœžœ
žœ
žœ
˜"šžœžœ
žœ<žœžœ
ž˜hKš
œ,˜,Kšžœ
žœ
žœœ"˜SKšžœ
˜—K˜—K˜™K™—Kšœžœžœ˜5šœžœžœ˜&Kšœžœ
žœ˜ Kšœข7˜PKš
œ˜K˜—Kšœžœžœ˜=šœžœžœ˜*Kšœžœ
žœ˜ Kšœข2˜OKš
œ˜K˜—Kšœžœžœ˜9šœžœžœ˜(Kšœžœ
žœ˜ Kšœข7˜PKš
œ˜—K˜šฅœžœžœ˜`Kšœžœ˜2Kšœ
žœ
žœ˜%Kš
œ˜Kš
œ!˜!Kšœžœžœ
žœ
žœ
žœ˜KKšœžœžœ
žœžœ
žœ
žœ
žœ2˜Kšœžœ7˜IKšœžœ3˜AK˜K˜—šŸœžœ7˜ZKšœžœ˜2Kšœ
žœ
žœ˜%Kšžœžœ
žœ
žœ
˜"Kš
œ'˜'šžœžœ
žœ>žœžœ
ž˜pKšžœžœ
žœœ˜_KšœGžœ™iKšžœ
˜—K˜K˜—šฅœžœžœ4˜yKšœžœ˜2Kšœ
žœ
žœ˜%Kš
œ&˜&Kš
œ)˜)Kšœžœžœ
žœ
žœ
žœ˜KKšœžœžœ
žœžœ
žœ
žœ
žœ6˜‡
Kšœžœ?˜UKšœžœ;˜MK˜K˜—šฅœžœžœ˜bKšœžœ˜2Kšœ
žœ
žœžœžœ
žœ
žœ
žœ˜d–[seq: 
GGModelTypes.Sequence]šžœ
žœ
žœ˜šœ#žœ˜BKšœขQ˜fKšœžœžœ
žœ
žœ
žœœข˜{Kš
œ˜—šœ	žœ˜$Kšœข˜Kš
œ˜Kšœ
žœ
˜Kš
œ˜Kš
œ˜—K˜—K˜K˜—šŸœžœ*žœC˜Œ
Kšœ#žœ˜@Kšœ
žœ
žœ%˜9Kšžœžœ
žœข˜0šžœ
žœ
ž˜
šžœžœ
žœข$˜FK–)[segGen: 
GGModelTypes.SegmentGenerator]šœœ-˜Všžœžœ
žœ˜Kš
œ ˜ Kšžœ
˜K˜—Kšœ ข˜7K˜—K™Kšžœžœ
žœžœ
žœ žœ
˜]K™Kšžœžœ
žœ
žœ
žœžœ˜+K–[seq: 
GGModelTypes.Sequence]šœœข˜`Kšžœ
˜—K˜K˜—šŸœžœ$žœ˜bKšœํ
žœ
™๒
Kšœžœ
žœ˜Kšœžœ
˜.Kšœžœ˜.Kš
œC˜Cšžœžœ
žœ-žœ
žœ
ž˜WKš
œ˜Kšœ%œ˜CKš
œ^˜^Kšžœ
˜—Kš
œ6˜6K˜K˜—šฅ	œžœ*žœ.˜uKšœžœ˜9Kšœ
žœ
žœ˜2Kš
žœžœ
žœ
žœ	žœ˜0šžœ
žœ
ž˜
šžœžœ
žœข&˜HKšœ	œ(˜Kšžœ
žœžœ˜Kš
œ˜Kšžœ
˜K˜—Kšœ ข˜7K˜—K™Kšžœžœ
žœžœ
žœ žœ
˜]Kš
žœžœ
žœ
žœ	žœ˜0Kšœœข˜[Kšžœ
˜—K˜K˜—šฅ
œžœ2žœ)˜|Kšœžœ˜AKšœ
žœ
žœ˜2Kš
žœžœ
žœ
žœžœ˜7šžœ
žœ
ž˜
šžœžœ
žœข%˜GKšœ
œ(˜Sšžœ
žœžœ˜#Kš
œ˜Kšžœ
˜K˜—Kšœ ข˜7K˜—K™Kšžœžœ
žœžœ
žœ žœ
˜]Kš
žœžœ
žœ
žœžœ˜7Kšœœ˜DKšžœ
˜—K˜—K˜Kšœžœ%˜6Kšœข˜4K˜Kšžœ
˜J˜—…—๑ฬR