DIRECTORY
Basics, Feedback, GGBasicTypes, GGBoundBox, GGCoreOps, GGCoreTypes, GGHistoryTypes, GGInterfaceTypes, GGModelTypes, GGOutline, GGParent, GGScene, GGSegmentTypes, GGSelect, GGSequence, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, List, Rope, TextNode, TiogaImager;

GGOutlineImplB: CEDAR PROGRAM
IMPORTS Basics, Feedback, GGBoundBox, GGCoreOps, GGOutline, GGParent, GGScene, GGSelect, GGSequence, GGSlice, GGSliceOps, GGTraj, GGUtility, List, TextNode
EXPORTS GGSlice, GGOutline, GGParent  = BEGIN

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;
GGData: TYPE = GGInterfaceTypes.GGData;
HistoryEvent: TYPE = GGHistoryTypes.HistoryEvent;
HitType: TYPE = GGModelTypes.TrajPartType;
Joint: TYPE = GGSegmentTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Line: TYPE = GGCoreTypes.Line;
Orientation: TYPE = GGModelTypes.Orientation;
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;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SegmentGeneratorObj: TYPE = GGModelTypes.SegmentGeneratorObj;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
SelectMode: TYPE = GGModelTypes.SelectMode;
SequenceOfReal: TYPE = GGCoreTypes.SequenceOfReal;
Slice: TYPE = GGModelTypes.Slice;
SliceClass: TYPE = GGModelTypes.SliceClass;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceDescriptorGeneratorObj: TYPE = GGModelTypes.SliceDescriptorGeneratorObj;
SliceDescriptorTallyProc: TYPE = GGModelTypes.SliceDescriptorTallyProc;
SliceDescriptorWalkProc: TYPE = GGModelTypes.SliceDescriptorWalkProc;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceGeneratorObj: TYPE = GGModelTypes.SliceGeneratorObj;
SliceObj: TYPE = GGModelTypes.SliceObj;
SliceParts: TYPE = GGModelTypes.SliceParts;
SlicePartsWalkProc: TYPE = GGModelTypes.SlicePartsWalkProc;
SliceTallyProc: TYPE = GGModelTypes.SliceTallyProc;
SliceWalkProc: TYPE = GGModelTypes.SliceWalkProc;
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;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
Vector: TYPE = GGBasicTypes.Vector;
WalkLevel: TYPE = GGModelTypes.WalkLevel;

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

ClusterData: TYPE = REF ClusterDataObj;
ClusterDataObj: TYPE = GGSlice.ClusterDataObj;
BuildMoreOutlineSliceClass: PUBLIC PROC [class: SliceClass]  = {
class.closestPoint _ GGParent.ClosestPoint;
class.closestJointToHitData _ GGParent.ClosestJointToHitData;
class.closestPointAndTangent _ GGSlice.NoOpClosestPointAndTangent;
class.closestSegment _ GGParent.ClosestSegment;
class.filledPathsUnderPoint _ OutlineFilledPathsUnderPoint;
class.lineIntersection _ GGParent.LineIntersection;
class.circleIntersection _ GGParent.CircleIntersection;
class.hitDataAsSimpleCurve _ GGParent.HitDataAsSimpleCurve;
class.setDefaults _ GGParent.SetDefaults;
class.setStrokeWidth _ GGParent.SetStrokeWidth;
class.getStrokeWidth _ GGParent.GetStrokeWidth;
class.setStrokeEnd _ GGParent.SetStrokeEnd;
class.getStrokeEnd _ GGParent.GetStrokeEnd;
class.setStrokeJoint _ GGParent.SetStrokeJoint;
class.getStrokeJoint _ GGParent.GetStrokeJoint;
class.setStrokeColor _ GGParent.SetStrokeColor;
class.getStrokeColor _ GGParent.GetStrokeColor;
class.setFillColor _ GGParent.SetFillColor;
class.getFillColor _ OutlineGetFillColor;
class.setArrows _ GGSlice.NoOpSetArrows;
class.getArrows _ GGSlice.NoOpGetArrows;
class.setDashed _ GGParent.SetDashed;
class.getDashed _ GGParent.GetDashed;
class.setOrientation _ GGParent.SetOrientation;
class.getOrientation _ GGParent.GetOrientation;
};

BuildMoreClusterSliceClass: PUBLIC PROC [class: SliceClass]  = {
class.closestPoint _ GGParent.ClosestPoint;
class.closestJointToHitData _ GGParent.ClosestJointToHitData;
class.closestPointAndTangent _ GGSlice.NoOpClosestPointAndTangent;
class.closestSegment _ GGParent.ClosestSegment;
class.filledPathsUnderPoint _ ClusterFilledPathsUnderPoint;
class.lineIntersection _ GGParent.LineIntersection;
class.circleIntersection _ GGParent.CircleIntersection;
class.hitDataAsSimpleCurve _ GGParent.HitDataAsSimpleCurve;
class.setDefaults _ GGParent.SetDefaults;
class.setStrokeWidth _ GGParent.SetStrokeWidth;
class.getStrokeWidth _ GGParent.GetStrokeWidth;
class.setStrokeEnd _ GGParent.SetStrokeEnd;
class.getStrokeEnd _ GGParent.GetStrokeEnd;
class.setStrokeJoint _ GGParent.SetStrokeJoint;
class.getStrokeJoint _ GGParent.GetStrokeJoint;
class.setStrokeColor _ GGParent.SetStrokeColor;
class.getStrokeColor _ GGParent.GetStrokeColor;
class.setFillColor _ GGParent.SetFillColor;
class.getFillColor _ GGParent.GetFillColor;
class.setArrows _ GGSlice.NoOpSetArrows;
class.getArrows _ GGSlice.NoOpGetArrows;
class.setDashed _ GGParent.SetDashed;
class.getDashed _ GGParent.GetDashed;
class.setOrientation _ GGParent.SetOrientation;
class.getOrientation _ GGParent.GetOrientation;
};

ClosestPoint: PUBLIC PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance: REAL] RETURNS [bestPoint: Point _ [0.0, 0.0], bestDist: REAL _ 0.0, bestNormal: Vector _ [0,-1], hitData: REF ANY, success: BOOL _ FALSE] = {
IF sliceD=NIL THEN RETURN ELSE {
parts: OutlineParts _ NARROW[sliceD.parts];
outlineHitData: OutlineHitData;
thisPoint: Point;
thisDist: REAL;
thisNormal: Vector;
thisHitData, bestHitData: REF ANY;
thisSuccess: BOOL _ FALSE;
bestChild: Slice;

IF NOT GGBoundBox.PointIsInGrownBox[testPoint, GGSliceOps.GetTightBox[sliceD.slice], tolerance]
THEN RETURN;

bestDist _ GGUtility.plusInfinity;
FOR list: LIST OF SliceDescriptor _ parts.descriptors, list.rest UNTIL list = NIL DO
IF list.first=NIL THEN LOOP;
[thisPoint, thisDist, thisNormal, thisHitData, thisSuccess] _ list.first.slice.class.closestPoint[list.first, testPoint, tolerance];
IF thisSuccess AND thisDist < bestDist THEN {
bestChild _ list.first.slice;
bestPoint _ thisPoint;
bestDist _ thisDist;
bestNormal _ thisNormal;
bestHitData _ thisHitData;
success _ TRUE;
};
ENDLOOP;
IF success THEN {
hitData _ outlineHitData _ NEW[OutlineHitDataObj _ [
bestChild, bestHitData]];
};
};
};

ClosestJointToHitData: PUBLIC PROC [sliceD: SliceDescriptor, mapPoint, testPoint: Point, hitData: REF ANY] RETURNS [jointD: SliceDescriptor, point: Point, normal: Vector _ [0,-1]] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
child: Slice _ outlineHitData.child;
childHitData: REF ANY _ outlineHitData.childHitData;
childD: SliceDescriptor _ GGParent.ChildDescriptorFromDescriptor[sliceD, child];
newChildD: SliceDescriptor;
[newChildD, point, normal] _ GGSliceOps.ClosestJointToHitData[childD, mapPoint, testPoint, childHitData];
jointD _ GGParent.DescriptorFromChildDescriptor[sliceD.slice, newChildD];
};

ClosestSegment: PUBLIC PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance: REAL] RETURNS [bestPoint: Point _ [0.0, 0.0], bestDist: REAL _ 0.0, bestNormal: Vector _ [0,-1], hitData: REF ANY, success: BOOL _ FALSE] = {
IF sliceD=NIL THEN RETURN ELSE {
parts: OutlineParts _ NARROW[sliceD.parts];
outlineHitData: OutlineHitData;
thisPoint: Point;
thisDist: REAL;
thisNormal: Vector;
thisHitData, bestHitData: REF ANY;
thisSuccess: BOOL _ FALSE;
bestChild: Slice;

IF NOT GGBoundBox.PointIsInGrownBox[testPoint, GGSliceOps.GetTightBox[sliceD.slice], tolerance]
THEN RETURN; -- success=FALSE, added February 24, 1988 by Bier

bestDist _ GGUtility.plusInfinity;
FOR list: LIST OF SliceDescriptor _ parts.descriptors, list.rest UNTIL list = NIL DO
IF list.first=NIL THEN LOOP;
[thisPoint, thisDist, thisNormal, thisHitData, thisSuccess] _ list.first.slice.class.closestSegment[list.first, testPoint, tolerance];
IF thisSuccess AND thisDist < bestDist THEN {
bestChild _ list.first.slice;
bestPoint _ thisPoint;
bestDist _ thisDist;
bestNormal _ thisNormal;
bestHitData _ thisHitData;
success _ TRUE;
};
ENDLOOP;
IF success THEN {
hitData _ outlineHitData _ NEW[OutlineHitDataObj _ [
bestChild, bestHitData]];
};
};
};

ClusterFilledPathsUnderPoint: PROC [slice: Slice, point: Point, tolerance: REAL] RETURNS [hitData: REF ANY _ NIL, moreHitDatas: LIST OF REF ANY _ NIL] = {
outlineData: OutlineData _ NARROW[slice.data];
clusterData: ClusterData _ NARROW[outlineData.subclassData];
thisChild: Slice;
thisHitData: REF ANY;
childHitDatas: LIST OF REF ANY;
thisSuccess: BOOL _ FALSE;
success: BOOL _ FALSE;

FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList=NIL DO
thisChild _ childList.first;
[thisHitData, childHitDatas] _ GGSliceOps.FilledPathsUnderPoint[thisChild, point, tolerance];
IF thisHitData # NIL THEN {
FOR list: LIST OF REF ANY _ List.DReverse[childHitDatas], list.rest UNTIL list = NIL DO
IF NOT success THEN {
success _ TRUE;
hitData _ NEW[OutlineHitDataObj _ [thisChild, list.first]];
}
ELSE {
moreHitDatas _ CONS[hitData, moreHitDatas];
hitData _ NEW[OutlineHitDataObj _ [thisChild, list.first]];
};
ENDLOOP;
IF NOT success THEN {
success _ TRUE;
hitData _ NEW[OutlineHitDataObj _ [thisChild, thisHitData]];
}
ELSE {
moreHitDatas _ CONS[hitData, moreHitDatas];
hitData _ NEW[OutlineHitDataObj _ [thisChild, thisHitData]];
};
};
ENDLOOP;
};

OutlineFilledPathsUnderPoint: PROC [slice: Slice, point: Point, tolerance: REAL] RETURNS [hitData: REF ANY _ NIL, moreHitDatas: LIST OF REF ANY _ NIL] = {
outlineData: OutlineData _ NARROW[slice.data];
thisHole: Slice;
thisHitData, holeHitData: REF ANY;
childHitDatas: LIST OF REF ANY;
thisSuccess: BOOL _ FALSE;
success: BOOL _ FALSE;
fence: Slice _ outlineData.children.first;
pointInSomeHole: BOOL _ FALSE;

IF outlineData.fillColor = NIL THEN RETURN;
IF NOT GGBoundBox.PointIsInGrownBox[point, GGSliceOps.GetTightBox[slice], tolerance]
THEN RETURN;

FOR childList: LIST OF Slice _ outlineData.children.rest, childList.rest UNTIL childList=NIL DO
thisHole _ childList.first;
[holeHitData, childHitDatas] _ GGSliceOps.FilledPathsUnderPoint[thisHole, point, tolerance];
IF holeHitData # NIL THEN {
pointInSomeHole _ TRUE;
EXIT;
};
ENDLOOP;
[thisHitData, ] _ GGSliceOps.FilledPathsUnderPoint[fence, point, tolerance];
IF thisHitData # NIL THEN { -- is in the fence
IF pointInSomeHole THEN RETURN[NIL, NIL]
ELSE hitData _ NEW[OutlineHitDataObj _ [fence, thisHitData]];
}
ELSE IF pointInSomeHole
THEN hitData _ NEW[OutlineHitDataObj _ [thisHole, holeHitData]]
ELSE RETURN[NIL, NIL];
};

LineIntersection: PUBLIC PROC [sliceD: SliceDescriptor, line: Line] RETURNS [points: LIST OF Point, pointCount: NAT _ 0] = {
segGen: GGModelTypes.SegmentGenerator;
outlineParts: OutlineParts _ NARROW[sliceD.parts];
thesePoints: LIST OF Point;
thisCount: NAT;
FOR descriptors: LIST OF SliceDescriptor _ outlineParts.descriptors, descriptors.rest UNTIL descriptors = NIL DO
childD: SliceDescriptor _ descriptors.first;
IF childD = NIL THEN LOOP;
segGen _ GGSliceOps.SegmentsInDescriptor[childD];
FOR seg: Segment _ GGSliceOps.NextSegment[childD.slice, segGen].seg, GGSliceOps.NextSegment[childD.slice, segGen].seg UNTIL seg = NIL DO
[thesePoints, thisCount] _ seg.class.lineIntersection[seg, line];
FOR list: LIST OF Point _ thesePoints, list.rest UNTIL list = NIL DO
points _ CONS[list.first, points];
ENDLOOP;
pointCount _ pointCount + thisCount;
ENDLOOP;
ENDLOOP;
};

CircleIntersection: PUBLIC PROC [sliceD: SliceDescriptor, circle: Circle] RETURNS [points: LIST OF Point, pointCount: NAT _ 0] = {
segGen: GGModelTypes.SegmentGenerator;
outlineParts: OutlineParts _ NARROW[sliceD.parts];
thesePoints: LIST OF Point;
thisCount: NAT;
FOR descriptors: LIST OF SliceDescriptor _ outlineParts.descriptors, descriptors.rest UNTIL descriptors = NIL DO
childD: SliceDescriptor _ descriptors.first;
IF childD = NIL THEN LOOP;
segGen _ GGSliceOps.SegmentsInDescriptor[childD];
FOR seg: Segment _ GGSliceOps.NextSegment[childD.slice, segGen].seg, GGSliceOps.NextSegment[childD.slice, segGen].seg UNTIL seg = NIL DO
[thesePoints, thisCount] _ seg.class.circleIntersection[seg, circle];
FOR list: LIST OF Point _ thesePoints, list.rest UNTIL list = NIL DO
points _ CONS[list.first, points];
ENDLOOP;
pointCount _ pointCount + thisCount;
ENDLOOP;
ENDLOOP;
};

HitDataAsSimpleCurve: PUBLIC PROC [slice: Slice, hitData: REF ANY] RETURNS [simpleCurve: REF ANY] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
simpleCurve _ GGSliceOps.HitDataAsSimpleCurve[outlineHitData.child, outlineHitData.childHitData];
};

PathOfHitData: PUBLIC PROC [slice: Slice, hitData: REF ANY] RETURNS [path: Slice, pathHitData: REF ANY] = {
path _ slice;
pathHitData _ hitData;
UNTIL NOT GGParent.IsParent[path] DO
outlineHitData: OutlineHitData _ NARROW[pathHitData];
path _ outlineHitData.child;
pathHitData _ outlineHitData.childHitData;
ENDLOOP;
};


SetDefaults: PUBLIC PROC [slice: Slice, parts: SliceParts, defaults: DefaultData, history: HistoryEvent] = {
ChildSetDefaults: PROC [child: Slice, parts: SliceParts] = {
[] _ GGSliceOps.SetStrokeWidth[child, parts, defaults.strokeWidth, NIL];
GGSliceOps.SetStrokeEnd[child, parts, defaults.strokeEnd, NIL];
GGSliceOps.SetStrokeJoint[child, parts, defaults.strokeJoint, NIL];
GGSliceOps.SetDashed[child, parts, defaults.dashed, GGUtility.CopyPattern[defaults.pattern], defaults.offset, defaults.length, NIL];
GGSliceOps.SetStrokeColor[child, parts, defaults.strokeColor, $Set, NIL]; -- should this copy the Color??
GGSliceOps.SetFillColor[child, parts, defaults.fillColor, $Set, NIL]; -- should this copy the Color??
};

outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
outlineData.fillColor _ defaults.fillColor;
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
ChildSetDefaults[childList.first, NIL];
ENDLOOP
ELSE FOR partsList: LIST OF SliceDescriptor _ outlineParts.descriptors, partsList.rest UNTIL partsList = NIL DO
IF partsList.first#NIL THEN ChildSetDefaults[partsList.first.slice, partsList.first.parts];
ENDLOOP;
};

SetStrokeWidth: PUBLIC PROC [slice: Slice, parts: SliceParts, strokeWidth: REAL, history: HistoryEvent] RETURNS [box: BoundBox] = {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetStrokeWidth[childList.first, NIL, strokeWidth, NIL];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
[] _ GGSliceOps.SetStrokeWidth[list.first.slice, list.first.parts, strokeWidth, NIL];
};
ENDLOOP;
box _ GGSliceOps.GetBoundBox[slice, parts];
};

GetStrokeWidth: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [strokeWidth: REAL _ -1.0, isUnique: BOOL _ TRUE] = {
found: BOOL _ FALSE;
DoCheckStrokeWidth: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisWidth: REAL;
[thisWidth, thisIsUnique] _ GGSliceOps.GetStrokeWidth[child, childParts];
IF NOT thisIsUnique THEN {
strokeWidth _ thisWidth;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF thisWidth # strokeWidth THEN RETURN[TRUE];
}
ELSE {
strokeWidth _ thisWidth;
found _ TRUE;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckStrokeWidth] AND found;
};

SetStrokeEnd: PUBLIC PROC [slice: Slice, parts: SliceParts, strokeEnd: StrokeEnd, history: HistoryEvent] = {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetStrokeEnd[childList.first, NIL, strokeEnd, NIL];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN [] _ GGSliceOps.SetStrokeEnd[list.first.slice, list.first.parts, strokeEnd, NIL];
ENDLOOP;
};

GetStrokeEnd: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [strokeEnd: StrokeEnd _ round, isUnique: BOOL _ TRUE] = {
found: BOOL _ FALSE;
DoCheckStrokeEnd: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisEnd: StrokeEnd;
[thisEnd, thisIsUnique] _ GGSliceOps.GetStrokeEnd[child, childParts];
IF NOT thisIsUnique THEN {
strokeEnd _ thisEnd;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF thisEnd # strokeEnd THEN RETURN[TRUE];
}
ELSE {
strokeEnd _ thisEnd;
found _ TRUE;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckStrokeEnd] AND found;
};

SetStrokeJoint: PUBLIC PROC [slice: Slice, parts: SliceParts, strokeJoint: StrokeJoint, history: HistoryEvent] = {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetStrokeJoint[childList.first, NIL, strokeJoint, NIL];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN [] _ GGSliceOps.SetStrokeJoint[list.first.slice, list.first.parts, strokeJoint, NIL];
ENDLOOP;
};

GetStrokeJoint: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [strokeJoint: StrokeJoint _ round, isUnique: BOOL _ TRUE] = {
found: BOOL _ FALSE;
DoCheckStrokeJoint: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisJoint: StrokeJoint;
[thisJoint, thisIsUnique] _ GGSliceOps.GetStrokeJoint[child, childParts];
IF NOT thisIsUnique THEN {
strokeJoint _ thisJoint;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF thisJoint # strokeJoint THEN RETURN[TRUE];
}
ELSE {
strokeJoint _ thisJoint;
found _ TRUE;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckStrokeJoint] AND found;
};

SetStrokeColor: PUBLIC PROC [slice: Slice, parts: SliceParts, color: Color, setHow: ATOM, history: HistoryEvent] = {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetStrokeColor[childList.first, NIL, color, setHow, NIL];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
[] _ GGSliceOps.SetStrokeColor[list.first.slice, list.first.parts, color, setHow, NIL];
};
ENDLOOP;
};

GetStrokeColor: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [color: Color, isUnique: BOOL _ TRUE] = {
found: BOOL _ FALSE;
DoCheckStrokeColor: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisColor: Color;
[thisColor, thisIsUnique] _ GGSliceOps.GetStrokeColor[child, childParts];
IF NOT thisIsUnique THEN {
color _ thisColor;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF NOT GGCoreOps.EquivalentColors[thisColor, color] THEN RETURN[TRUE];
}
ELSE {
color _ thisColor;
found _ TRUE;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckStrokeColor] AND found;
};

SetFillColor: PUBLIC PROC [slice: Slice, parts: SliceParts, color: Color, setHow: ATOM, history: HistoryEvent] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineParts: OutlineParts _ NARROW[parts];
SELECT setHow FROM
$Set => outlineData.fillColor _ color;
$ChangeHue => {
newColor: Color _ GGUtility.ChangeHue[outlineData.fillColor, color];
outlineData.fillColor _ newColor;
};
ENDCASE => ERROR;
IF parts = NIL THEN {
FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetFillColor[childList.first, NIL, color, setHow, NIL];
ENDLOOP;
}
ELSE {
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
[] _ GGSliceOps.SetFillColor[list.first.slice, list.first.parts, color, setHow, NIL];
};
ENDLOOP;
};
};

OutlineGetFillColor: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [color: Color, isUnique: BOOL _ TRUE] = {
outlineData: OutlineData _ NARROW[slice.data];
color _ outlineData.fillColor;
};

GetFillColor: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [color: Color, isUnique: BOOL _ TRUE] = {
found: BOOL _ FALSE;
DoCheckFillColor: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisColor: Color;
[thisColor, thisIsUnique] _ GGSliceOps.GetFillColor[child, childParts];
IF NOT thisIsUnique THEN {
color _ thisColor;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF NOT GGCoreOps.EquivalentColors[thisColor, color] THEN RETURN[TRUE];
}
ELSE {
color _ thisColor;
found _ TRUE;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckFillColor] AND found;
};

SetDashed: PUBLIC PROC [slice: Slice, parts: SliceParts, dashed: BOOL, pattern: SequenceOfReal _ NIL, offset: REAL _ 0.0, length: REAL _ -1.0, history: HistoryEvent] = {
outlineParts: OutlineParts _ NARROW[parts];
outlineData: OutlineData _ NARROW[slice.data];
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetDashed[childList.first, NIL, dashed, pattern, offset, length, NIL];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
[] _ GGSliceOps.SetDashed[list.first.slice, list.first.parts, dashed, pattern, offset, length, NIL];
};
ENDLOOP;
};

GetDashed: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [dashed: BOOL _ FALSE, pattern: SequenceOfReal, offset, length: REAL _ 0.0, isUnique: BOOL _ TRUE] = {
found: BOOL _ FALSE;
DoCheckDashes: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisDashed: BOOL _ FALSE;
thisPattern: SequenceOfReal;
thisOffset, thisLength: REAL;
[thisDashed, thisPattern, thisOffset, thisLength, thisIsUnique] _ GGSliceOps.GetDashed[child, childParts];
IF NOT thisIsUnique THEN {
dashed _ thisDashed; pattern _ thisPattern; offset _ thisOffset; length _ thisLength;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF
thisDashed # dashed OR (thisDashed AND
(thisOffset # offset OR
thisLength # length OR
NOT GGUtility.EquivalentPatterns[thisPattern, pattern]))
THEN RETURN[TRUE];
}
ELSE {
found _ TRUE;
dashed _ thisDashed;
pattern _ thisPattern;
offset _ thisOffset;
length _ thisLength;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckDashes] AND found;
};

SetOrientation: PUBLIC PROC [slice: Slice, parts: SliceParts, orientation: Orientation, history: HistoryEvent] RETURNS [success: BOOL _ FALSE] = {
outlineData: OutlineData _ NARROW[slice.data];
outlineParts: OutlineParts _ NARROW[parts];
IF parts = NIL THEN FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
[] _ GGSliceOps.SetOrientation[childList.first, NIL, orientation, NIL];
ENDLOOP
ELSE FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL THEN {
[] _ GGSliceOps.SetOrientation[list.first.slice, list.first.parts, orientation, NIL];
};
ENDLOOP;
};

GetOrientation: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [orientation: Orientation _ ccw, isUnique: BOOL _ TRUE] = {
outlineData: OutlineData _ NARROW[slice.data];
found: BOOL _ FALSE;
DoCheckOrientation: PROC [child: Slice, childParts: SliceParts] RETURNS [done: BOOL _ FALSE] = {
thisIsUnique: BOOL _ TRUE;
thisOrient: Orientation;
[thisOrient, thisIsUnique] _ GGSliceOps.GetOrientation[child, childParts];
IF NOT thisIsUnique THEN {
orientation _ thisOrient;
RETURN[TRUE];
}
ELSE {
IF found THEN {
IF thisOrient # orientation THEN RETURN[TRUE];
}
ELSE {
orientation _ thisOrient;
found _ TRUE;
};
};
};
isUnique _ NOT WalkIncludedParts[slice, parts, first, DoCheckOrientation] AND found;
};

CreateOutline: PUBLIC PROC [child: Slice, fillColor: Imager.Color] RETURNS [parent: Slice] =  {
data: OutlineData _ NEW[OutlineDataObj _ [oddWrap: TRUE, fillColor: fillColor, children: LIST[child]] ];
parent _ NEW[SliceObj _ [
class: GGSlice.FetchSliceClass[$Outline],
data: data,
selectedInFull: [FALSE, FALSE, FALSE],
tightBox: GGBoundBox.NullBoundBox[],
boundBox: GGBoundBox.NullBoundBox[],
boxValid: FALSE]];
parent.nullDescriptor _ GGSlice.DescriptorFromParts[parent, NIL];
child.parent _ parent;
IF GGSliceOps.GetType[child]=$Traj THEN {
trajData: TrajData _ NARROW[child.data];
IF trajData.role=hole THEN trajData.role _ fence;
};
};

AddChild: PUBLIC PROC [outline: Slice, child: Slice] RETURNS [holier: Slice] = {
holyData: OutlineData;
holier _ GGSliceOps.Copy[outline].first; -- copy the outline
holyData _ NARROW[holier.data]; -- get the copy's children list
holyData.children _ GGUtility.AppendSliceList[holyData.children, LIST[child]]; -- and append the new hole
child.parent _ holier; -- make the new hole's parent the new copy
IF GGSliceOps.GetType[child]=$Traj THEN GGTraj.SetTrajRole[child, hole];
GGSlice.KillBoundBox[holier];
};

ReplaceFirstChild: PUBLIC PROC [outline: Slice, newChild: Slice] RETURNS [newOutline: Slice] = {
isClosed: BOOL _ FALSE;
holeList: LIST OF Slice _ GGOutline.ListHoles[outline]; -- all but the first child
newData: OutlineData;
newFirstChild: Slice;
IF newChild#NIL THEN newFirstChild _ newChild
ELSE {
IF holeList = NIL THEN newFirstChild _ NIL
ELSE {
newFirstChild _ holeList.first;
holeList _ holeList.rest;
};
};
IF newFirstChild=NIL THEN RETURN[NIL];
isClosed _ GGSliceOps.GetType[newFirstChild]#$Traj OR NARROW[newFirstChild.data, TrajData].role#open;
IF NOT isClosed THEN ERROR;
newOutline _ GGOutline.CreateOutline[newFirstChild, GGSliceOps.GetFillColor[outline, NIL].color];
newData _ NARROW[newOutline.data];
FOR list: LIST OF Slice _ holeList, list.rest UNTIL list = NIL DO
hole: Slice _ list.first;
newSlice: Slice _ GGSliceOps.Copy[hole].first; -- Copy should keep role=hole if Traj
newData.children _ GGUtility.AppendSliceList[newData.children, LIST[newSlice]];
newSlice.parent _ newOutline;
ENDLOOP;
GGSlice.KillBoundBox[newOutline];
};

ReplaceChild: PUBLIC PROC [outline: Slice, oldChild, newChild: Slice] RETURNS [newOutline: Slice] = {
newSlice: Slice;
newData: OutlineData;
holeList: LIST OF Slice;
oldData: OutlineData _ NARROW[outline.data];
IF oldChild=NIL THEN RETURN [outline];
IF oldChild=oldData.children.first THEN RETURN [ReplaceFirstChild[outline, newChild]];
newSlice _ GGSliceOps.Copy[oldData.children.first].first;
newOutline _ GGOutline.CreateOutline[newSlice, oldData.fillColor];
newData _ NARROW[newOutline.data];
holeList _ GGOutline.ListHoles[outline]; -- all but the first child
FOR list: LIST OF Slice _ holeList, list.rest UNTIL list = NIL DO
hole: Slice _ list.first;
IF hole=oldChild AND newChild#NIL THEN { -- replace a matching child unless newChild=NIL
newSlice _ GGSliceOps.Copy[newChild].first;
newData.children _ GGUtility.AppendSliceList[newData.children, LIST[newSlice]];
newSlice.parent _ newOutline;
}
ELSE IF hole#oldChild THEN { -- copy any hole that does not match
newSlice _ GGSliceOps.Copy[hole].first;
newData.children _ GGUtility.AppendSliceList[newData.children, LIST[newSlice]];
newSlice.parent _ newOutline;
};
ENDLOOP;
GGSlice.KillBoundBox[newOutline];
};


SetWrapRule: PUBLIC PROC [outline: Slice, oddWrap: BOOL] = {
NARROW[outline.data, OutlineData].oddWrap _ oddWrap;
};

GetWrapRule: PUBLIC PROC [outline: Slice] RETURNS [oddWrap: BOOL] = {
RETURN[NARROW[outline.data, OutlineData].oddWrap];
};

SetFillText: PUBLIC PROC [slice: Slice, node: TextNode.Ref, screenStyle: BOOL _ FALSE, history: HistoryEvent] = {
IF GGSliceOps.GetType[slice]#$Outline THEN ERROR -- debug check
ELSE {
PutTextInBox: PROC [thisChild: Slice] RETURNS [done: BOOL _ FALSE] = {
IF previousChild#NIL THEN {
siblingNodes _ GGSlice.GetBoxNodes[previousChild];
resumeLoc _ siblingNodes.resume;
};
GGSlice.SetBoxText[thisChild, resumeLoc, screenStyle, history];
previousChild _ thisChild;
};

siblingNodes: TiogaImager.FormattedNodes;
resumeLoc: TextNode.Location _ [NIL, 0];
previousChild: Slice _ NIL;
IF GGParent.FirstChild[slice, first, $Box] # NIL THEN {
outlineData: OutlineData _ NARROW[slice.data];
outlineData.fillText _ node; -- complete document to outline (parent)
outlineData.screenStyle _ screenStyle;
resumeLoc.node _ TextNode.FirstChild[node]; -- Remove root node for first child
[] _ GGParent.WalkChildren[slice, first, PutTextInBox, $Box];
};
};
};

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

DescriptorFromChild: PUBLIC PROC [slice: Slice, child: Slice] RETURNS [sliceD: SliceDescriptor] = {
childD: SliceDescriptor _ GGSliceOps.NewParts[child, NIL, slice];
sliceD _ DescriptorFromChildDescriptor[slice, childD];
};

TopLevelDescriptorFromChildDescriptor: PUBLIC PROC [childD: SliceDescriptor] RETURNS [ancestorD: SliceDescriptor] = {
IF GGScene.IsTopLevel[childD.slice] THEN RETURN[childD] ELSE RETURN [TopLevelDescriptorFromChildDescriptor[GGParent.DescriptorFromChildDescriptor[GGParent.GetParent[childD.slice], childD]]];
};

ChildDescriptorFromDescriptor: PUBLIC PROC [sliceD: SliceDescriptor, child: Slice] RETURNS [childD: SliceDescriptor] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
IF child=NIL THEN RETURN[NIL];
IF outlineParts=NIL THEN RETURN[GGSlice.DescriptorFromParts[child, NIL]];
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list=NIL DO
IF list.first#NIL AND list.first.slice=child THEN RETURN[list.first];
ENDLOOP;
RETURN[NIL];
};

RemoveTraj: PUBLIC PROC [sliceD: SliceDescriptor, traj: Slice] RETURNS [newD: SliceDescriptor] = {
SELECT GGSliceOps.GetType[sliceD.slice] FROM
$Cluster => {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
newChildD: SliceDescriptor;
newParts: OutlineParts;
newChildDList, ptr: LIST OF SliceDescriptor;
[newChildDList, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list=NIL DO
newChildD _ IF list.first = NIL THEN NIL
ELSE RemoveTraj[list.first, traj];
[newChildDList, ptr] _ GGUtility.AddSliceDescriptor[newChildD, newChildDList, ptr];
ENDLOOP;
newParts _ NEW[OutlinePartsObj _ [newChildDList]];
newD _ GGSlice.DescriptorFromParts[sliceD.slice, newParts];
};
$Outline => {
newD _ OutlineRemoveTraj[sliceD, traj];
};
ENDCASE => {
newD _ sliceD;
};
};

OutlineRemoveTraj: PROC [outlineD: SliceDescriptor, traj: Traj] RETURNS [newD: SliceDescriptor] = {
outlineParts: OutlineParts _ NARROW[outlineD.parts];
seq: SliceDescriptor;
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first#NIL AND list.first.slice = traj THEN {
seq _ list.first;
GOTO Done;
};
REPEAT
Done => {
newSeqs: LIST OF SliceDescriptor _ GGUtility.SequenceSubst[new: NIL, old: seq, expr: outlineParts.descriptors];
newParts: SliceParts _ NEW[OutlinePartsObj _ [newSeqs]];
newD _ GGSlice.DescriptorFromParts[outlineD.slice, newParts];
};
FINISHED => newD _ outlineD;
ENDLOOP;
};

DeleteControlPoints: PUBLIC PROC [outlineD: SliceDescriptor, scene: Scene] RETURNS [bBox: BoundBox] =  {
DoDelete: PROC [nextPartsD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGBoundBox.EnlargeByBox[bBox, GGTraj.DeleteControlPoints[nextPartsD, scene]];	
};
bBox _ GGBoundBox.NullBoundBox[]; -- start with empty refresh box, and increase size
[] _ GGParent.WalkIncludedChildren[outlineD.slice, outlineD.parts, leaf, DoDelete, $Traj];
};

SaveSelectionsInOutlineAllClasses: PUBLIC PROC [outline: Slice] = {
SaveSelectionsAux: PROC [selectClass: SelectionClass] = {
outlineD: SliceDescriptor _ GGSelect.FindSelectedSlice[outline, selectClass];
IF outlineD#NIL THEN {
DoSaveSelections: PROC [nextPart: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSliceOps.SaveSelections[nextPart.slice, nextPart.parts, selectClass];
};
[] _ GGParent.WalkIncludedChildren[outlineD.slice, outlineD.parts, first, DoSaveSelections];
};
};
outlineData: OutlineData _ NARROW[outline.data];
children: LIST OF Slice _ outlineData.children;
FOR nextChildren: LIST OF Slice _ children, nextChildren.rest UNTIL nextChildren=NIL DO
nextChild: Slice _ nextChildren.first; -- clear every selection bit in every child
GGSliceOps.SaveSelections[nextChild, NIL, normal]; -- clear
GGSliceOps.SaveSelections[nextChild, NIL, hot]; -- clear
GGSliceOps.SaveSelections[nextChild, NIL, active]; -- clear
GGSliceOps.SaveSelections[nextChild, NIL, match]; -- clear
ENDLOOP;
SaveSelectionsAux[normal];
SaveSelectionsAux[hot];
SaveSelectionsAux[active];
SaveSelectionsAux[match];
};

UnpackHitData: PUBLIC PROC [hitData: REF ANY] RETURNS [child: Slice, hitType: TrajPartType _ none, segNum, cpNum, jointNum: INT _ -999, hitPoint: Point] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
child _ outlineHitData.child;
IF GGSliceOps.GetType[child]=$Traj THEN [hitType, segNum, cpNum, jointNum, hitPoint] _ GGTraj.UnpackHitData[outlineHitData.childHitData];
};

UnpackOneSegmentDescriptor: PUBLIC PROC [outlineD: SliceDescriptor] RETURNS [childDescriptor: SliceDescriptor, segNum: NAT _ 999] = {
outlineParts: OutlineParts;
IF outlineD=NIL OR GGSliceOps.GetType[outlineD.slice]#$Outline THEN RETURN[NIL, 999];
outlineParts _ NARROW[outlineD.parts];
FOR descriptors: LIST OF SliceDescriptor _ outlineParts.descriptors, descriptors.rest UNTIL descriptors = NIL DO
IF descriptors.first#NIL THEN {
childDescriptor _ descriptors.first;
IF GGSliceOps.GetType[childDescriptor.slice]=$Traj THEN segNum _ GGSequence.UnpackOneSegmentSequence[NARROW[childDescriptor.parts]];
RETURN;
};
ENDLOOP;
};

UnpackSimpleDescriptor: PUBLIC PROC [outlineD: SliceDescriptor] RETURNS [success: BOOL _ FALSE, hitType: TrajPartType _ none, childDescriptor: SliceDescriptor _ NIL, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point _ [0,0], cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = {
outlineParts: OutlineParts;
IF outlineD=NIL OR GGSliceOps.GetType[outlineD.slice]#$Outline THEN RETURN;
outlineParts _ NARROW[outlineD.parts];
FOR descriptors: LIST OF SliceDescriptor _ outlineParts.descriptors, descriptors.rest UNTIL descriptors = NIL DO
IF descriptors.first#NIL THEN {
success _ TRUE; -- questionable if child is not a Traj
childDescriptor _ descriptors.first;
IF GGSliceOps.GetType[childDescriptor.slice]=$Traj THEN 
[success, hitType, ----, joint, jointNum, cp, cpNum, seg, segNum] _ GGSequence.UnpackSimpleSequence[childDescriptor.slice, childDescriptor.parts];
RETURN;
};
ENDLOOP;
};

FindTrajShapeInOutline: PUBLIC PROC [traj: Slice, outline: Slice] RETURNS [oldTrajs: LIST OF Slice] = {
outlineData: OutlineData _ NARROW[outline.data];
tail: LIST OF Slice;
MatchTraj: PROC [oldTraj: Slice] RETURNS [done: BOOL _ FALSE] = {
IF GGTraj.MatchShape[traj, oldTraj] THEN [oldTrajs, tail] _ GGUtility.AddSlice[oldTraj, oldTrajs, tail];
};
[] _ GGParent.WalkChildren[outline, first, MatchTraj, $Traj];
};

TrajsInOutline: PUBLIC PROC [outline: Slice] RETURNS [trajGen: SliceGenerator] =  {
outlineData: OutlineData _ NARROW[outline.data];
partsList: LIST OF Slice _ TrajectoriesOfOutline[outline];
trajGen _ NEW[SliceGeneratorObj _ [partsList]];
};

TrajectoriesOfOutline: PUBLIC PROC [outline: Slice] RETURNS [trajs: LIST OF Slice _ NIL] = {
outlineData: OutlineData _ NARROW[outline.data];
ptr: LIST OF Slice;
[trajs, ptr] _ GGUtility.StartSliceList[];
FOR list: LIST OF Slice _ outlineData.children, list.rest UNTIL list = NIL DO
IF GGSliceOps.GetType[list.first]=$Traj THEN [trajs, ptr] _ GGUtility.AddSlice[list.first, trajs, ptr];
ENDLOOP;
};

ListHoles: PUBLIC PROC [outline: Slice] RETURNS [holesList: LIST OF Slice] = {
data: OutlineData _ NARROW[outline.data];
holesList _ data.children.rest;
};

HasHoles: PUBLIC PROC [outline: Slice] RETURNS [BOOL _ FALSE] =  {
data: OutlineData _ NARROW[outline.data];
RETURN[data.children.rest#NIL];
};
Parts: PUBLIC PROC [outlineD: SliceDescriptor] RETURNS [partsGen: SliceDescriptorGenerator] = {
partsGen _ Parts2[outlineD.slice, outlineD.parts];
};
PartsList: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [partsList: LIST OF SliceDescriptor] = {
outlineParts: OutlineParts _ NARROW[sliceD.parts];
ptr: LIST OF SliceDescriptor;
[partsList, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN [partsList, ptr] _ GGUtility.AddSliceDescriptor[list.first, partsList, ptr];
ENDLOOP;
};

Parts2: PUBLIC PROC [outline: Slice, parts: SliceParts] RETURNS [partsGen: SliceDescriptorGenerator] = {
partsGen _ NEW[SliceDescriptorGeneratorObj _ [] ];
IF parts=NIL THEN RETURN -- empty parts
ELSE {
outlineParts: OutlineParts _ NARROW[parts];
partsList, ptr: LIST OF SliceDescriptor;
[partsList, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN [partsList, ptr] _ GGUtility.AddSliceDescriptor[list.first, partsList, ptr];
ENDLOOP;
partsGen.list _ partsList;
};
};

Children: PUBLIC PROC [outline: Slice] RETURNS [children: SliceGenerator] =  {
data: OutlineData _ NARROW[outline.data];
children _ NEW[SliceGeneratorObj _ [
list: data.children
]];
};

ChildList: PUBLIC PROC [outline: Slice] RETURNS [childList: LIST OF Slice] =  {
data: OutlineData _ NARROW[outline.data];
childList _ data.children;
};



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

WalkIncludedChildren: PUBLIC PROC [parent: Slice, parts: SliceParts, level: WalkLevel, walkProc: SliceDescriptorWalkProc, classType: ATOM _ NIL] RETURNS [aborted: BOOL _ FALSE] = {
type: ATOM _ GGSliceOps.GetType[parent];
IF GGParent.IsParentType[type] THEN {
outlineParts: OutlineParts _ NARROW[parts];
IF outlineParts = NIL THEN RETURN;
FOR childDList: LIST OF SliceDescriptor _ outlineParts.descriptors, childDList.rest UNTIL childDList = NIL DO
thisChildD: SliceDescriptor _ childDList.first;
IF thisChildD # NIL AND NOT GGSliceOps.IsEmptyParts[thisChildD] THEN {
thisType: ATOM _ GGSliceOps.GetType[thisChildD.slice];
IF (level # leaf OR GGParent.IsLeafOfClass[thisChildD.slice, classType]) AND (classType = NIL OR GGSliceOps.GetType[thisChildD.slice] = classType) THEN {
aborted _  walkProc[thisChildD];
IF aborted THEN RETURN;
};
IF (level = all OR level = leaf OR (level = highest AND thisType # classType)) AND GGParent.IsParent[thisChildD.slice] THEN {
aborted _ WalkIncludedChildren[thisChildD.slice, thisChildD.parts, level, walkProc, classType];
IF aborted THEN RETURN;
};
};
ENDLOOP;
};
};

WalkIncludedParts: PROC [parent: Slice, parts: SliceParts, level: WalkLevel, walkProc: SlicePartsWalkProc, classType: ATOM _ NIL] RETURNS [aborted: BOOL _ FALSE] = {
type: ATOM _ GGSliceOps.GetType[parent];
IF GGParent.IsParentType[type] THEN {
IF parts = NIL THEN {
outlineData: OutlineData _ NARROW[parent.data];
FOR childList: LIST OF Slice _ outlineData.children, childList.rest UNTIL childList = NIL DO
thisChild: Slice _ childList.first;
thisType: ATOM _ GGSliceOps.GetType[thisChild];
IF (level # leaf OR GGParent.IsLeafOfClass[thisChild, classType]) AND (classType = NIL OR GGSliceOps.GetType[thisChild] = classType) THEN {
aborted _  walkProc[thisChild, NIL];
IF aborted THEN RETURN;
};
IF (level = all OR level = leaf OR (level = highest AND thisType # classType)) AND GGParent.IsParent[thisChild] THEN {
aborted _ WalkIncludedParts[thisChild, NIL, level, walkProc, classType];
IF aborted THEN RETURN;
};
ENDLOOP;
}
ELSE {
outlineParts: OutlineParts _ NARROW[parts];
IF outlineParts = NIL THEN RETURN;
FOR childDList: LIST OF SliceDescriptor _ outlineParts.descriptors, childDList.rest UNTIL childDList = NIL DO
thisChildD: SliceDescriptor _ childDList.first;
IF thisChildD # NIL AND NOT GGSliceOps.IsEmptyParts[thisChildD] THEN {
thisType: ATOM _ GGSliceOps.GetType[thisChildD.slice];
IF (level # leaf OR GGParent.IsLeafOfClass[thisChildD.slice, classType]) AND (classType = NIL OR GGSliceOps.GetType[thisChildD.slice] = classType) THEN {
aborted _  walkProc[thisChildD.slice, thisChildD.parts];
IF aborted THEN RETURN;
};
IF (level = all OR level = leaf OR (level = highest AND thisType # classType)) AND GGParent.IsParent[thisChildD.slice] THEN {
aborted _ WalkIncludedParts[thisChildD.slice, thisChildD.parts, level, walkProc, classType];
IF aborted THEN RETURN;
};
};
ENDLOOP;
};
};
};

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

ListIncludedChildren: PUBLIC PROC [parent: Slice, parts: SliceParts, level: WalkLevel, classType: ATOM _ NIL] RETURNS [selectedList: LIST OF SliceDescriptor] = {
ptr: LIST OF SliceDescriptor;
DoAppendSlice: PROC [childD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
[selectedList, ptr] _ GGUtility.AddSliceDescriptor[childD, selectedList, ptr];
};
[selectedList, ptr] _ GGUtility.StartSliceDescriptorList[];
[] _ WalkIncludedChildren[parent, parts, level, DoAppendSlice, classType];
};

FirstChild: PUBLIC PROC [parent: Slice, level: WalkLevel, classType: ATOM _ NIL] RETURNS [firstChild: Slice] = {
StopAtFirstSlice: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
firstChild _ slice;
RETURN[TRUE];
};
[] _ WalkChildren[parent, level, StopAtFirstSlice, classType];
};

FirstIncludedChild: PUBLIC PROC [parent: Slice, parts: SliceParts, level: WalkLevel, classType: ATOM _ NIL] RETURNS [childD: SliceDescriptor] = {
StopAtFirstSlice: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
childD _ sliceD;
RETURN[TRUE];
};
[] _ WalkIncludedChildren[parent, parts, level, StopAtFirstSlice, classType];
};

TallyChildren: PUBLIC PROC [parent: Slice, tallyProc: SliceTallyProc] RETURNS [tallyD: SliceDescriptor, aborted: BOOL _ FALSE] = {
visitChildren, keep, done, keepFound: BOOL _ FALSE;
[visitChildren, keep, done] _ tallyProc[parent];
IF GGParent.IsParent[parent] AND visitChildren THEN {
outlineData: OutlineData _ NARROW[parent.data];
ptr: LIST OF SliceDescriptor;
newParts: OutlineParts _ NEW[OutlinePartsObj];
[newParts.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR list: LIST OF Slice _ outlineData.children, list.rest UNTIL list = NIL DO
thisD: SliceDescriptor;
IF NOT aborted THEN {
[thisD, aborted] _ TallyChildren[list.first, tallyProc];
IF thisD # NIL THEN keepFound _ TRUE;
}
ELSE thisD _ NIL;
[newParts.descriptors, ptr] _ GGUtility.AddSliceDescriptor[thisD, newParts.descriptors, ptr];
ENDLOOP;
IF keepFound THEN tallyD _ GGSlice.DescriptorFromParts[parent, newParts]
ELSE tallyD _ NIL;
}
ELSE {
IF keep THEN tallyD _ GGSliceOps.NewParts[parent, NIL, slice]
ELSE tallyD _ NIL;
aborted _ done;
};
};
TallyIncludedChildren: PUBLIC PROC [parent: Slice, parts: SliceParts, tallyProc: SliceDescriptorTallyProc] RETURNS [tallyD: SliceDescriptor, aborted: BOOL _ FALSE] = {
visitChildren, done, keepFound: BOOL _ FALSE;
keepD: SliceDescriptor;
parentD: SliceDescriptor _ GGSlice.DescriptorFromParts[parent, parts];
[visitChildren, keepD, done] _ tallyProc[parentD];
IF GGParent.IsParent[parent] AND visitChildren THEN {
outlineParts: OutlineParts _ NARROW[parts];
ptr: LIST OF SliceDescriptor;
newParts: OutlineParts _ NEW[OutlinePartsObj];
[newParts.descriptors, ptr] _ GGUtility.StartSliceDescriptorList[];
FOR list: LIST OF SliceDescriptor _ outlineParts.descriptors, list.rest UNTIL list = NIL DO
thisD: SliceDescriptor;
IF NOT aborted THEN {
IF list.first # NIL THEN {
[thisD, aborted] _ TallyIncludedChildren[list.first.slice, list.first.parts, tallyProc];
IF thisD # NIL THEN keepFound _ TRUE;
};
}
ELSE thisD _ NIL;
[newParts.descriptors, ptr] _ GGUtility.AddSliceDescriptor[thisD, newParts.descriptors, ptr];
ENDLOOP;
IF keepFound THEN tallyD _ GGSlice.DescriptorFromParts[parent, newParts]
ELSE tallyD _ NIL;
}
ELSE {
tallyD _ keepD;
aborted _ done;
};
};

IsParent: PUBLIC PROC [slice: Slice] RETURNS [BOOL] = {
RETURN[slice.class.type = $Outline OR slice.class.type = $Cluster];
};

IsParentType: PUBLIC PROC [classType: ATOM] RETURNS [BOOL] = {
RETURN[classType = $Outline OR classType = $Cluster];
};

GetParent: PUBLIC PROC [child: Slice] RETURNS [parent: Slice] = {
RETURN[child.parent];
};

GetTopLevelAncestor: PUBLIC PROC [slice: Slice] RETURNS [ancestor: Slice] = {
ancestor _ slice;
UNTIL GGScene.IsTopLevel[ancestor] DO ancestor _ GGParent.GetParent[ancestor]; ENDLOOP;
};

IsLeafOfClass: PUBLIC PROC [slice: Slice, classType: ATOM _ NIL] RETURNS [BOOL] = {
NoteSameClassChild: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
done _ TRUE;
};
IF classType=NIL THEN RETURN [NOT IsParent[slice]];
IF classType = $Cluster THEN
RETURN[NOT GGParent.WalkChildren[slice, first, NoteSameClassChild, $Cluster]];
IF classType = $Outline THEN
RETURN[NOT GGParent.WalkChildren[slice, first, NoteSameClassChild, $Outline]];
RETURN[GGSliceOps.GetType[slice] = classType];
};

CreateCluster: PUBLIC PROC [frozen: BOOL _ TRUE] RETURNS [parent: Slice] =  {
data: OutlineData _ NEW[OutlineDataObj _ [oddWrap: TRUE, fillColor: NIL, children: NIL, subclassData: NEW[ClusterDataObj _ [frozen: frozen]] ] ];
parent _ NEW[SliceObj _ [
class: GGSlice.FetchSliceClass[$Cluster],
data: data,
selectedInFull: [FALSE, FALSE, FALSE],
tightBox: GGBoundBox.NullBoundBox[],
boundBox: GGBoundBox.NullBoundBox[],
boxValid: FALSE]];
parent.nullDescriptor _ GGSlice.DescriptorFromParts[parent, NIL];
};

AddChildToCluster: PUBLIC PROC [parent: Slice, child: Slice, priority: INT] = {
parentData: OutlineData _ NARROW[parent.data];

IF child = NIL THEN RETURN;
child.parent _ parent;
IF priority = -1 OR GGParent.TopPriority[parent]<priority THEN AppendSlice[parent, child]
ELSE IF priority = 0 THEN {
parentData.ptrValid _ FALSE;
parentData.prioritiesValid _ FALSE;
parentData.children _ CONS[child, parentData.children];
}
ELSE GGParent.PutBehind[parent, GGParent.GetAtPriority[parent, priority], LIST[child]];
GGSlice.KillBoundBox[parent];
};

AddChildrenToCluster: PUBLIC PROC [parent: Slice, children: LIST OF Slice, priority: INT] = {
parentData: OutlineData _ NARROW[parent.data];

IF children=NIL THEN RETURN;
FOR list: LIST OF Slice _ children, list.rest UNTIL list = NIL DO
list.first.parent _ parent;
ENDLOOP;
IF priority = -1 OR TopPriority[parent]<priority THEN {
FOR list: LIST OF Slice _ children, list.rest UNTIL list = NIL DO
AppendSlice[parent, list.first];
ENDLOOP;
}
ELSE IF priority = 0 THEN {
parentData.ptrValid _ FALSE;
parentData.prioritiesValid _ FALSE;
parentData.children _ GGUtility.AppendSliceList[children, parentData.children];
}
ELSE {
copiedSlices: LIST OF Slice _ GGUtility.CopySliceList[children];
GGParent.PutBehind[parent, GGParent.GetAtPriority[parent, priority], copiedSlices];
};
GGSlice.KillBoundBox[parent];
};

RemoveChild: PUBLIC PROC [parent: Slice, child: Slice] RETURNS [newParent: Slice] = {
parentData: OutlineData _ NARROW[parent.data];
parentData.ptrValid _ FALSE;
parentData.prioritiesValid _ FALSE;
parentData.children _ GGUtility.DeleteSliceFromList[child, parentData.children];
GGSlice.KillBoundBox[parent];
newParent _ IF parentData.children = NIL THEN NIL ELSE parent;
};

PruneNullClusters: PUBLIC PROC [scene: Scene, cluster: Slice] = {
clusterData: OutlineData _ NARROW[cluster.data];
IF clusterData.children = NIL THEN {
parent: Slice _ GetParent[cluster];
IF parent = NIL THEN {
GGScene.DeleteSlice[scene, cluster];
}
ELSE {
smallerParent: Slice _ RemoveChild[parent, cluster];
IF smallerParent = NIL THEN PruneNullClusters[scene, parent];
};
};
};

SetFrozen: PUBLIC PROC [cluster: Slice, frozen: BOOL] = {
parentData: OutlineData _ NARROW[cluster.data];
clusterData: ClusterData _ NARROW[parentData.subclassData];
clusterData.frozen _ frozen;
};

GetFrozen: PUBLIC PROC [cluster: Slice] RETURNS [frozen: BOOL] = {
parentData: OutlineData _ NARROW[cluster.data];
clusterData: ClusterData _ NARROW[parentData.subclassData];
frozen _ clusterData.frozen;
};

AppendSlice: PROC [parent: Slice, slice: Slice] = {
parentData: OutlineData _ NARROW[parent.data];

parentData.prioritiesValid _ FALSE;
IF NOT parentData.ptrValid THEN UpdatePtr[parentData];
[parentData.children, parentData.ptr] _ GGUtility.AddSlice[slice, parentData.children, parentData.ptr];
};

TopPriority: PUBLIC PROC [parent: Slice] RETURNS [priority: INT] = {
parentData: OutlineData _ NARROW[parent.data];

IF NOT parentData.prioritiesValid THEN UpdatePriorities[parent];
IF NOT parentData.ptrValid THEN UpdatePtr[parentData];
RETURN[IF parentData.ptr=NIL THEN 0 ELSE parentData.ptr.first.priority];
};

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

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

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

GetChildPriority: PUBLIC PROC [parent: Slice, child: Slice] RETURNS [priority: INT] = {
parentData: OutlineData _ NARROW[parent.data];
IF NOT parentData.prioritiesValid THEN UpdatePriorities[parent];
priority _ child.priority;
};

ComparePriorities: PUBLIC PROC [slice1, slice2: Slice] RETURNS [Basics.Comparison] = {
slice1List, slice2List: LIST OF INT;
parent1, parent2, child1, child2: Slice;
compare: Basics.Comparison;
child1 _ slice1;
child2 _ slice2;
UNTIL GGScene.IsTopLevel[child1] DO
parent1 _ GGParent.GetParent[child1];
slice1List _ CONS[GGParent.GetChildPriority[parent1, child1], slice1List];
child1 _ parent1;
ENDLOOP;
UNTIL GGScene.IsTopLevel[child2] DO
parent2 _ GGParent.GetParent[child2];
slice2List _ CONS[GGParent.GetChildPriority[parent2, child2], slice2List];
child2 _ parent2;
ENDLOOP;
UNTIL slice1List = NIL OR slice2List = NIL DO
compare _ Basics.CompareInt[slice1List.first, slice2List.first];
IF compare # equal THEN RETURN[compare];
slice1List _ slice1List.rest;
slice2List _ slice2List.rest;
ENDLOOP;
RETURN[equal];
};

UpdatePriorities: PROC [parent: Slice] = {
parentData: OutlineData _ NARROW[parent.data];
DoUpdate: PROC [child: Slice] RETURNS [done: BOOL _ FALSE] = {
child.priority _ index;
index _ index + 1;
};
index: NAT _ 0;
[] _ GGParent.WalkChildren[parent, first, DoUpdate];
parentData.prioritiesValid _ TRUE;
};

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


END.
.GGOutlineImplB.mesa
Contents:  The second half of the $Outline class procs, plus Outline utility procs.
Copyright Σ 1986, 1987, 1988 by Xerox Corporation.  All rights reserved.
Pier, September 20, 1990 10:36 am PDT
Bier, June 26, 1989 9:48:05 pm PDT
Kurlander, August 20, 1987 11:41:43 pm PDT

The Outline Class
Style
Hit Testing
Style
Hit Testing
Not called through GGSliceOps because the procedure overhead is deadly.  This procedure is particularly expensive because it has so many parameters.
Not called through GGSliceOps because the procedure overhead is deadly.  This procedure is particularly expensive because it has so many parameters.
Eventually, clusters should return an ordered list of the paths that are under the given point.  For now, clusters will just return the frontmost such path.
For now, return a hitData if the point is in the fence and not in any holes, or if the point is in some hole but not in the fence.
Test for point inclusion in the holes

Test for point inclusion in the fence
Finds the intersection of the line with those slice parts mentioned in sliceD.  Is this routine really useful anymore?
Finds the intersection of the circle with those slice parts mentioned in sliceD.  Is this routine really useful anymore?
simpleCurve will be of type Edge, Arc, etc.  There will be Conic and Bezier types as well.
Style
Call GGSliceOps.Set* on each child, with history=NIL so the children will not make history list entries.  The outline will make one instead.
parts=NIL => do for all children
Sets the stroke width of the named parts of slice to be strokeWidth.
parts=NIL => do for all children
Call GGSliceOps.SetStrokeWidth on each child, with history=NIL so the children will not make history list entries.  The parent will make one instead.
Sets the stroke end of the named parts of slice to be strokeEnd.
parts=NIL => do for all children
call GGSliceOps.SetStrokeEnd on each child, with history=NIL so the children will not make history list entries.  The outline will make one instead.
Sets the stroke Joint of the named parts of slice to be strokeJoint.
parts=NIL => do for all children
call GGSliceOps.SetStrokeJoint on each child, with history=NIL so the children will not make history list entries.  The outline will make one instead.
Sets the stroke color of the named parts of slice to be color.
parts=NIL => do for all children
Call GGSliceOps.SetStrokeColor on each child, with history=NIL so the children will not make history list entries.  The outline will make one instead.
Sets the fill color of the named parts of slice to be color.
parts=NIL => do for all children
Call GGSliceOps.SetFillColor on each child, with history=NIL so the children will not make history list entries.  The parent will make one instead.
Get the fill color of the slice.
Sets the dash pattern of the named parts of slice.
parts=NIL => do for all children
call GGSliceOps.SetDashed on each child, with history=NIL so the children will not make history list entries.  The outline will make one instead.
Define the orientation of an outline to be the orientation of its first child.
Outline Utility operations.

Should check for duplicates. -- Bier, February 20
IF newChild = NIL, this routine removes the first child.
oldChild=NIL => RETURN[outline]
newChild=NIL => delete oldChild
First call: previousChild=NIL, resumeLoc=FirstChild[node]
Rest calls: previousChild#NIL
initialize resumeLoc for first call of PutTextInBox
sliceD.slice is a cluster.  For each child, if its descriptor contains traj, remove traj from the descriptor.  Otherwise leave the descriptor alone.  Build a new cluster descriptor from the results.
Used by GGSelect to do a DeselectTraj.
This routine could simply call GGSliceOps.SaveSelections for each selection class.  It is slightly more optimized for the common case.
Now save the appropriate bits in the selected children.
This will go away when the Caret machinery is revised.
hitType, segNum, cpNum, jointNum, hitPoint only valid if GetType[child] is Traj
outlineD describes a single segment.  Return the segNum.

Queries about Outlines

Looks through the children of outline to see if any of the shapes match, control point for control point and coordinate for the coordinate, the traj entry.  If so, return all such trajectories that match.
Generates only the trajectory parts of the outline
Like TrajsInOutline but returns a list (used by MatchTool).
The Parent Meta-Class
Parent Meta-Class Utility operations.


Built-in classes include: $Cluster, $Outline, $Traj, $Box, $Circle, $Text, and $IP.  This routine finds all such slices, even within clusters.  class=NIL => all classes.  Use level=all to walk every slice of a given class.
Top level classes
Depth first walk
Built-in classes include: $Cluster, $Outline, $Traj, $Box, $Circle, $Text, and $IP.  This routine finds all such slices, even within clusters.  class=NIL => all classes.  Use level=all to walk every selected slice of a given class.
Depth first walk:  First walk yourself ...
... then walk your children.
Depth first walk:  First walk yourself ...
... then walk your children.
Depth first walk:  First walk yourself ...
... then walk your children.
Walk through the children (and, if requested recursively through the children's children, etc.) building up a descriptor of all parts of parent that meet the criterion defined by the tallyProc.
Walk through the children (and, if requested recursively through the children's children, etc.) building up a descriptor of all parts of parent that meet the criterion defined by the tallyProc.
A slice is a leaf if it is not a Parent slice and class doesn't matter.
Return TRUE if a cluster has no cluster child => it is a leaf cluster
Return TRUE if a outline has no outline child => it is a leaf outline
Return TRUE if any other type matches the class
Should check for duplicates.
Copy incoming list to avoid mutations by PutBehind
Disconnects the named child from parent (to which it presumably belongs).  Does not affect selections.
Priority order

Returns the priority of the frontmost position in the scene.
Destructively splices slices into scene
Destructively splices slices into scene
or off the scale
If returned priority is 0, the child is the back-most entity.
THIS CODE SHOULD POST AN ERROR IF slice is not in scene !!
slice1 and slice2 must be descendents of the same parent slice.  However, they can be at different levels within the parent slice's tree.
Κ?‘˜Icodeš
œ™šΟnœK™SKš
œH™HKš
œ%™%K™"K™*—K™š
Οk	˜	Jš
œŠ˜ŠK˜—šœžœ
ž˜Jšžœ”
˜›
Kšžœ!ž˜-K˜Kšœ
žœ˜&Kšœžœ˜#Kšœžœ˜#Kšœžœ˜Kšœžœ&˜AKšœ
žœ˜-Kšœžœ ˜5Kšœ
žœ ˜1Kšœžœ˜'Kšœžœ˜1Kšœ	žœ˜*Kšœžœ˜#Kšœžœ˜3Kšœžœ˜Kšœ
žœ˜-Kšœ
žœ˜*Kšœžœ˜0Kšœžœ˜0Kšœžœ˜6Kšœžœ˜,Kšœžœ˜2Kšœžœ˜!Kšœžœ˜/Kšœžœ˜3Kšœžœ"˜9Kšœžœ!˜7Kšœžœ#˜;Kšœžœ&˜AKšœžœ˜!Kšœ	žœ˜'Kšœžœ!˜7Kšœžœ$˜=Kšœžœ!˜5Kšœžœ˜+Kšœžœ˜2Kšœžœ˜!Kšœžœ˜+Kšœžœ ˜5Kšœžœ)˜GKšœžœ,˜MKšœžœ)˜GKšœžœ(˜EKšœžœ˜3Kšœžœ"˜9Kšœ
žœ˜'Kšœžœ˜+Kšœžœ#˜;Kšœžœ˜3Kšœžœ˜1Iprocšœžœ˜#Kšœ
žœ˜'Kšœžœ˜Kšœ
žœ˜'Kšœ	žœ˜%Kšœžœ˜)Kšœžœ˜/Kšœžœ˜/Kšœžœ˜#Kšœžœ˜)K˜Kšœžœ
žœžœ˜;K˜Lšœ
žœžœ˜'Lšœžœ˜.—Ihead1™šœžœ
žœ˜@Kš
œ+˜+Kš
œ=˜=Kš
œB˜BKš
œ/˜/Kš
œ;˜;Kš
œ3˜3Kš
œ7˜7Kš
œ;˜;Kš
Οb™K˜)Kš
œ/˜/Kš
œ/˜/Kš
œ+˜+Kš
œ+˜+Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ+˜+Kš
œ)˜)K˜(K˜(Kš
œ%˜%Kš
œ%˜%K˜/K˜/K˜K˜—šœžœ
žœ˜@Kš
Ÿ™Kš
œ+˜+Kš
œ=˜=Kš
œB˜BKš
œ/˜/Kš
œ;˜;Kš
œ3˜3Kš
œ7˜7Kš
œ;˜;Kš
Ÿ™K˜)Kš
œ/˜/Kš
œ/˜/Kš
œ+˜+Kš
œ+˜+Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ+˜+Kš
œ+˜+K˜(K˜(Kš
œ%˜%Kš
œ%˜%K˜/K˜/K˜—K˜K™šΠbnœžœ
žœ8žœžœ+žœ.žœ
žœžœžœ˜ή
š
žœžœ
žœ
žœ
žœ˜ Kšœžœ˜+Kš
œ˜Kš
œ˜Kšœ
žœ
˜Kš
œ˜Kšœžœ
žœ
˜"Kšœ
žœžœ
˜Kš
œ˜K˜šžœ
žœY˜_Kšžœ
žœ
˜—K˜Kš
œ"˜"šžœžœ
žœ0žœžœ
ž˜TKšžœžœ
žœ
žœ
˜KšœUŸœ#˜„
K™”
šžœ
žœžœ˜-Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜J˜—Jšžœ
˜—šžœ	žœ˜šœžœ˜4Jš
œ˜—J˜—K˜—K˜K˜—š
œžœ@žœ
žœžœE˜·
Kšœ!žœ
˜1Kš
œ$˜$Kšœžœ
žœ˜4Kš
œP˜PKš
œ˜Kšœ(Ÿœ,˜iKš
œI˜IK˜K˜—šœžœ8žœžœ+žœ.žœ
žœžœžœ˜ΰ
š
žœžœ
žœ
žœ
žœ˜ Kšœžœ˜+Kš
œ˜Kš
œ˜Kšœ
žœ
˜Kš
œ˜Kšœžœ
žœ
˜"Kšœ
žœžœ
˜Kš
œ˜K˜Kšžœ
žœY˜_Kšžœ
žœΟc1˜>K˜Kš
œ"˜"šžœžœ
žœ0žœžœ
ž˜TKšžœžœ
žœ
žœ
˜JšœUŸœ#˜†
K™”
šžœ
žœžœ˜-Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜J˜—Jšžœ
˜—šžœ	žœ˜šœžœ˜4Jš
œ˜—J˜—K˜—K˜K˜—šœžœ)žœžœžœ
žœžœžœ
žœ
žœ
žœžœ˜š
K™œ
Lšœžœ
˜.Lšœžœ˜<L˜Lšœ
žœ
žœ
˜Lš	œžœ
žœ
žœ
žœ
˜Lšœ
žœžœ
˜Lšœ	žœžœ
˜K˜šžœžœ
žœ.žœžœ
ž˜ZKš
œ˜Kš
œ]˜]šžœžœ
žœ˜šžœžœ
žœ
žœ
žœ
œ
Ÿ
œ
žœžœ
ž˜Wšžœ
žœ	žœ˜Kšœ
žœ
˜Kšœ
žœ.˜;K˜
—šžœ˜KšœΠbkœ˜+Kšœ
žœ.˜;K˜—Jšžœ
˜—šžœ
žœ	žœ˜Kšœ
žœ
˜Kšœ
žœ!Ÿœ˜<K˜
—šžœ˜Kšœ’œ˜+Kšœ
žœ!Ÿœ˜<K˜—K˜—Kšžœ
˜—K˜K˜—šœžœ)žœžœžœ
žœžœžœ
žœ
žœ
žœžœ˜š
K™‚
Lšœžœ
˜.L˜Lšœžœ
žœ
˜"Lš	œžœ
žœ
žœ
žœ
˜Lšœ
žœžœ
˜Lšœ	žœžœ
˜Lš
œ*˜*Lšœžœžœ
˜K˜Kšžœžœ
žœ
žœ
˜+šžœ
žœN˜TKšžœ
žœ
˜K˜—K™%šžœžœ
žœ3žœžœ
ž˜_Kš
œ˜Kš
œ\˜\šžœžœ
žœ˜Kšœžœ
˜Kšžœ
˜K˜—Kšžœ
˜—K™K™%Kš
œL˜Lšžœžœ
žœ‘˜.Kš
žœžœ
žœ
žœžœ
˜(Kšžœžœ+˜=K˜
—šžœ
žœ˜Kšžœžœ-˜?Kšžœ
žœ
žœžœ˜—K˜K˜—šœžœ'žœ
žœ
žœžœ	˜|Kš
œv™vJš
œ&˜&Kšœžœ˜2Kšœ
žœ
žœ˜Kšœžœ
˜šžœžœ
žœ>žœžœ
ž˜pJš
œ,˜,Jšžœ
žœ
žœ
žœ
˜JšœŸœ	˜1šžœsžœžœ
ž˜ˆ
Jšœ%Ÿœ˜Ašžœžœ
žœ žœžœ
ž˜DJšœ	žœ˜"Jšžœ
˜—Jš
œ$˜$Jšžœ
˜—Jšžœ
˜—K˜K˜—š œžœ+žœ
žœ
žœžœ	˜‚
Kš
œx™xJš
œ&˜&Kšœžœ˜2Kšœ
žœ
žœ˜Kšœžœ
˜šžœžœ
žœ>žœžœ
ž˜pJš
œ,˜,Jšžœ
žœ
žœ
žœ
˜JšœŸœ	˜1šžœsžœžœ
ž˜ˆ
Jšœ%Ÿœ˜Ešžœžœ
žœ žœžœ
ž˜DJšœ	žœ˜"Jšžœ
˜—Jš
œ$˜$Jšžœ
˜—Jšžœ
˜—K˜K˜—š œžœžœ
žœžœžœ
žœ˜eKš
œZ™ZKšœ!žœ
˜1KšœŸœ4˜aK˜K˜—š
œžœ
žœžœ
žœžœžœ
žœ˜kKš
œ
˜
Kš
œ˜šžœ
žœž˜$Kšœ!žœ˜5Kš
œ˜Kš
œ*˜*Kšžœ
˜—K˜K˜—™K˜—šœžœ
žœT˜lšœžœ&˜<Kš
œŒ
™Œ
JšœC’œ˜HJšœ:’œ˜?Jšœ>’œ˜CJšœ’œ˜„
JšœD’œ‘Πbc˜iJšœ@’œ‘£˜eK˜K˜—Kšœžœ˜+Jšœžœ
˜.š
œ+˜+K™ —šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pJšœ"žœ˜'Jš
ž˜—š
žœ
žœžœ
žœ<žœ
žœ
ž˜oJšžœžœ
žœ@˜[Jšžœ
˜—Kš
œ˜K˜—š
 œžœ
žœ0žœžœ˜ƒ
Kš
œD™DK™ Kšœžœ˜+Jšœžœ
˜.Kš
ϥ
™•
šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pKšœ0žœ’œ˜GJš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`šžœžœ
žœ˜JšœP’œ˜UJ˜—Jšžœ
˜—Kš
œ+˜+K˜K˜—š œžœ
žœ#žœžœžœžœ˜{Kšœžœžœ
˜š
 œžœ(žœžœžœ˜`Jšœžœžœ
˜Kšœžœ
˜Jš
œI˜Išžœ
žœžœ˜Jš
œ˜Jšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜Jšžœžœ
žœ
žœ˜-J˜
—šžœ˜Jš
œ˜Jšœžœ
˜
J˜—J˜—J˜—Kšœžœ<žœ˜TK˜K˜—š œžœ
žœS˜lKš
œ@™@K™ Kšœžœ˜+Jšœžœ
˜.Kš
œ”
™”
šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pKšœ.žœ
’œ˜CJš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`Jšžœžœ
žœM’œ˜hJšžœ
˜—K˜K˜—š œžœ
žœ#žœ*žœžœ˜}Kšœžœžœ
˜š
œžœ(žœžœžœ˜^Jšœžœžœ
˜Kš
œ˜Jš
œE˜Ešžœ
žœžœ˜Jš
œ˜Jšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜Jšžœžœ
žœ
žœ˜)J˜
—šžœ˜Jš
œ˜Jšœžœ
˜
J˜—J˜—J˜—Kšœžœ:žœ˜RK˜K˜—š œžœ
žœW˜rKš
œD™DK™ Kšœžœ˜+Jšœžœ
˜.Kš
œ–
™–
šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pKšœ0žœžœ˜GJš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`Jš
žœžœ
žœŸœ2’œ˜lJšžœ
˜—Kš
œ˜K˜—š œžœ
žœ#žœ.žœžœ˜ƒ
Kšœžœžœ
˜š
œžœ(žœžœžœ˜`Jšœžœžœ
˜Kš
œ˜Jš
œI˜Išžœ
žœžœ˜Jš
œ˜Jšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜Jšžœžœ
žœ
žœ˜-J˜
—šžœ˜Jš
œ˜Jšœžœ
˜
J˜—J˜—J˜—Kšœžœ<žœ˜TK˜K˜—š œžœ
žœ9žœ˜tKš
œ>™>K™ Kšœžœ˜+Jšœžœ
˜.Kš
œ–
™–
šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pKšœ0žœ’œ˜IJš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`šžœžœ
žœ˜JšœŸœ4’œ˜WJ˜—Jšžœ
˜—K˜K˜—š œžœ
žœ#žœžœžœ˜oKšœžœžœ
˜š
œžœ(žœžœžœ˜`Jšœžœžœ
˜Kš
œ˜Jš
œI˜Išžœ
žœžœ˜Jš
œ˜Jšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜Jš
žœ
žœ.žœ
žœ
žœ˜FJ˜
—šžœ˜Jš
œ˜Jšœžœ
˜
J˜—J˜—J˜—Kšœžœ<žœ˜TK˜K˜—š œžœ
žœ9žœ˜rKš
œ<™<K™ Jšœžœ
˜.Kšœžœ˜+Kš
œ“
™“
šžœž˜Kš
œ&˜&˜Kš
œD˜DKš
œ!˜!K˜—Kšžœžœ
˜—šžœ	žœ
žœ
ž
˜šžœžœ
žœ.žœ
žœ
ž˜\Kšœ.žœžœ˜GJš
ž˜J˜
——šžœ
ž
˜šžœžœ
žœ7žœžœ
ž˜[šžœžœ
žœ˜JšœPžœ˜UJ˜—Jšžœ
˜—J˜—K˜K˜—š œžœ
žœ#žœžœžœ˜tKš
œ ™ Jšœžœ
˜.Kš
œ˜K˜K˜—š œžœ
žœ#žœžœžœ˜mKšœžœžœ
˜š
œžœ(žœžœžœ˜^Jšœžœžœ
˜Kš
œ˜Jš
œG˜Gšžœ
žœžœ˜Jš
œ˜Jšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜Jš
žœ
žœ.žœ
žœ
žœ˜FJ˜
—šžœ˜Jš
œ˜Jšœžœ
˜
J˜—J˜—J˜—Kšœžœ:žœ˜RK˜K˜—š 	œžœ
žœ+žœžœ
žœžœ#˜©
Kš
œ2™2K™ Kšœžœ˜+Jšœžœ
˜.Kš
œ‘
™‘
šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pKšœŸ	œžœ#žœ˜VJš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`šžœžœ
žœ˜JšœŸ	œFžœ˜dJ˜—Jšžœ
˜—K˜K˜—š	œžœ
žœ#žœ
žœžœ+žœžœžœ˜§
Kšœžœžœ
˜š

œžœ(žœžœžœ˜[Jšœžœžœ
˜Kšœžœ
˜Kš
œ˜Kšœžœ
˜Jš
œj˜jšžœ
žœžœ˜Jš
œU˜UJšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜š
ž˜Jšœžœž˜&Jšœž˜Jšœž˜Jšžœ5˜8—Jšžœ
žœ
žœ˜J˜
—šžœ˜Jšœžœ
˜
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—J˜—J˜—Kšœžœ7žœ˜OK˜K˜—šœžœ
žœTžœžœžœ˜’
Kšœžœ
˜.Kšœžœ˜+šžœ	žœ
žœ
žœžœ
žœ.žœ
žœ
ž˜pKšœ0žœžœ˜GJš
ž˜—š
žœ
žœžœ
žœ7žœžœ
ž˜`šžœžœ
žœ˜JšœPžœ˜UJ˜—Jšžœ
˜—K˜K˜—šœžœ
žœ#žœ,žœžœ˜
K™NKšœžœ
˜.Kšœžœžœ
˜š
œžœ(žœžœžœ˜`Jšœžœžœ
˜Kš
œ˜Jš
œJ˜Jšžœ
žœžœ˜Jš
œ˜Jšžœ
žœ˜
J˜
—šžœ˜šžœžœ˜Jšžœžœ
žœ
žœ˜.J˜
—šžœ˜Jš
œ˜Jšœžœ
˜
J˜—J˜—J˜—Kšœžœ<žœ˜TK˜—K˜š
œ™K™—š
œžœ
žœ)žœ˜_Kšœžœžœ"žœ˜hšœ	žœ
˜Kš
œ)˜)K˜Kšœžœžœžœ˜&Kš
œ$˜$Kš
œ$˜$Kšœ
žœ˜—Kšœ<žœ˜AKš
œ˜šžœ!žœ˜)Kšœžœ
˜(Kšžœžœ˜1K˜—Kš
œ˜K˜—šœžœ
žœ žœ˜PKšœ‘™1Kš
œ˜Kšœ)‘˜<Kšœžœ‘˜?KšœAžœ
‘˜iKšœ‘*˜AKšžœ!žœ!˜HKš
œ˜Kš
œ˜K˜—šœžœ
žœ#žœ˜`Kš
œ8™8Kšœ
žœžœ
˜Kšœ
žœ
žœ'‘˜RKš
œ˜Kš
œ˜Kšžœ
žœ˜-šžœ˜Kšžœžœ
žœž˜*šžœ˜Kš
œ˜Kš
œ˜K˜—K˜—Kš
žœžœ
žœ
žœ
žœ˜&Kšœ3žœ
žœ)˜eKšžœ
žœ
žœ
žœ
˜KšœUžœ	˜aKšœ
žœ˜"šžœžœ
žœžœžœ
ž˜AKš
œ˜Kšœ/‘%˜TKšœ?žœ˜OKš
œ˜Kšžœ
˜—Kš
œ!˜!K˜K˜—šœžœ
žœ-žœ˜eKš
œ™Kš
œ™Kš
œ˜Kš
œ˜Kšœ
žœ
žœ˜Kšœžœ˜,Kšžœ
žœ
žœ
žœ˜&Kšžœ!žœ
žœ(˜VKš
œ9˜9Kš
œB˜BKšœ
žœ˜"Kšœ)‘˜Cšžœžœ
žœžœžœ
ž˜AKš
œ˜š	žœžœ
žœ
žœ‘/˜XKš
œ+˜+Kšœ?žœ˜OKš
œ˜K˜
—šžœ
žœžœ‘$˜AKš
œ'˜'Kšœ?žœ˜OKš
œ˜K˜—Kšžœ
˜—Kš
œ!˜!K˜K˜—K˜šœžœ
žœžœ˜<Kšžœ.˜4Kš
œ˜K˜—š
œžœ
žœžœžœ˜EKšžœ
žœ%˜2K˜K˜—š
œžœ
žœ1žœžœ˜qKšžœ$žœ
žœ
‘˜?šžœ˜š
œžœžœžœžœ˜FKšœžœ™9Kšœž™šžœžœ
žœ˜Kš
œ2˜2Kš
œ ˜ K˜—Kš
œ?˜?Kš
œ˜K˜—K˜Kš
œ)˜)Kšœ žœ˜(Kšœžœ
˜šžœ+žœ
žœ˜7Kšœžœ
˜.Kšœ‘(˜Eš
œ&˜&Kš
œ3™3—Kšœ,‘#˜OKšœ'Οtœ€˜=K˜—J˜—J˜—J˜šœžœ
žœ)žœ˜xKšœžœ
˜.Kšœžœ
žœ˜6Kšœžœ
žœ˜Kšœžœ˜.Kšœ(Ÿœ˜Cšžœžœ
žœ(žœ
žœ
ž˜RKšœ(Ÿœ
žœžœžœ
žœ˜‹
Kšžœ
˜—Kš
œ6˜6K˜K˜—šœžœ
žœžœ˜cKšœ5žœ	˜AKš
œ6˜6K˜K˜—š%œžœžœ!˜uKš
žœ"žœ
žœ	žœ
žœ{˜Ύ
K˜K˜—šœžœ
žœ)žœ˜xKšœžœ˜2Kš
žœžœ
žœ
žœ
žœ˜Kš
žœžœ
žœ
žœ$žœ˜Išžœžœ
žœ7žœžœ
ž˜YKš
žœžœ
žœžœ
žœ
˜EKšžœ
˜—Kšžœ
žœ˜K˜—K˜š
œžœ
žœ(žœ˜bK™Ζ
šžœ"ž˜,˜
Kšœžœ˜2Kš
œ˜Kš
œ˜Kšœžœ
žœ˜,Kš
œ<˜<šžœžœ
žœ7žœžœ
ž˜YKšœžœžœ
žœ
ž˜(Kšžœ˜"Kš
œS˜SKšžœ
˜—Kšœžœ$˜2Kš
œ;˜;K˜—˜
Kš
œ'˜'K˜—šžœ˜Kš
œ˜K˜——K˜K˜—šœžœ)žœ˜cK™&Kšœžœ˜4Kš
œ˜šžœžœ
žœ7žœžœ
ž˜[šžœžœ
žœžœ˜4J˜Jšžœ˜
J˜—š
ž˜˜	Jšœ	žœ
žœ.žœ,˜oJšœžœ˜8Jš
œ=˜=J˜—Jšžœ˜—Jšžœ
˜—K˜K˜—šœžœ
žœ+žœ˜hš
œžœžœžœžœ˜MKš
œN˜NJ˜—Jšœ"‘2˜TJšœG€œ€˜ZKš
œ˜K˜—š!œžœ
žœ˜CK™†
šœžœ"˜9Kš
œM˜Mšžœ
žœ
žœ˜š
œžœžœžœžœ˜SJšœ:Ÿœ˜GJ˜—JšœH€œ€˜\J˜—K˜—Kšœžœ˜0Kšœ
žœ
žœ˜/šžœžœ
žœ%žœžœ
ž˜WKšœ'‘+˜RKšœ%žœ‘˜;Kšœ%žœ‘˜8Kšœ%žœ‘˜;Kšœ%žœ
‘˜:Jšžœ
˜—Kšœ%Ÿœ
™7Kšœ
Ÿœ˜Kšœ
Ÿœ˜Kšœ
Ÿœ˜Kšœ
Ÿœ˜J˜K˜—š
œžœ
žœžœ
žœžœGžœ˜œ
K™6Kš
œO™OKšœ!žœ
˜1Kš
œ˜Kšžœ!žœb˜‰
K˜K˜—š
œžœ
žœžœ,žœ˜…
Kš
œ8™8Kš
œ˜Kšžœ
žœ
žœ-žœ
žœ
žœ˜UKšœžœ˜&šžœžœ
žœ>žœžœ
ž˜pšžœžœ
žœ˜Jš
œ$˜$Kšžœ1žœ.žœ˜„
Jšžœ
˜J˜—Jšžœ
˜—K˜K˜—šœžœ
žœžœžœžœCžœžœžœ"žœžœ
žœ˜žKš
œ˜Kš
žœ
žœ
žœ-žœ
žœ
˜KKšœžœ˜&šžœžœ
žœ>žœžœ
ž˜pšžœžœ
žœ˜Jšœ
žœ‘&˜6Jš
œ$˜$Kšžœ1žœ
˜8Jš
œ’
˜’
Jšžœ
˜J˜—Jšžœ
˜—K˜K™—K˜šœŸ™K™—šœžœ
žœžœžœ
žœ˜gKš
œΜ
™Μ
Kšœžœ˜0Kšœžœ
žœ˜š
	œžœžœžœžœ˜AKšžœ"žœ@˜hK˜—Kš
œ=˜=K˜K˜—šœžœ
žœžœ˜SKš
œ2™2Kšœžœ˜0Kšœžœ
žœ(˜:Kšœ
žœ"˜/K˜K˜—šœžœ
žœžœ	žœ
žœ	žœ˜\Kš
œ;™;Kšœžœ˜0Kšœžœ
žœ˜Kš
œ*˜*šžœžœ
žœ)žœžœ
ž˜MJšžœ&žœ;˜gJšžœ
˜—K˜K˜—š	œžœ
žœžœ
žœ
žœ˜NKšœžœ˜)Kš
œ˜K˜K˜—š
œžœ
žœžœžœ˜BKšœžœ˜)Kšžœžœ˜K˜—M™Kš
œ%™%K™šœžœ
žœžœ)˜_Kš
œ2˜2K˜K™—š	œžœ
žœžœ
žœ
žœ˜aKšœžœ˜2Kšœžœ
žœ˜Kš
œ8˜8šžœžœ
žœ7žœžœ
ž˜[Jšžœžœ
žœM˜eJšžœ
˜—K˜K˜—šœžœ
žœ%žœ)˜hKšœžœ$˜2Kš	žœžœ
žœ
žœ
‘˜'šžœ˜Kšœžœ˜+Kšœžœ
žœ˜(Kš
œ8˜8šžœžœ
žœ7žœžœ
ž˜[Jšžœžœ
žœM˜eJšžœ
˜—Kš
œ˜K˜—K˜K˜—šœžœ
žœžœ ˜NKšœžœ˜)šœžœ˜$Kš
œ˜K˜—K˜K˜—š	œžœ
žœžœ
žœ
žœ˜OKšœžœ˜)Kš
œ˜K˜K˜K˜—K˜šœžœ
žœ=žœ
žœžœžœžœžœ˜•
Kšœ–
žœE™ή
šžœžœ˜#Kšœžœ˜/šžœ	žœ
žœ+žœ
žœ
ž˜SKšœ
žœ$˜2Kš
œ™šžœžœ2žœžœ
žœžœ˜yKš
œ"˜"Kšžœ	žœ
žœ
˜K˜—K™šžœžœžœžœžœ!žœ˜yKš
œK˜KKšžœ	žœ
žœ
˜K˜—Jšžœ
˜—J˜—K˜K˜—šœžœ
žœdžœžœžœžœžœ˜΄
Kšœ–
žœN™η
Kšœžœ˜(šžœžœ˜%Kšœžœ˜+Kšžœžœ
žœ
žœ
˜"šžœ
žœ
žœ=žœžœ
ž˜mKš
œ/˜/š
žœžœ
žœ
žœ%žœ˜FKšœ
žœ(˜6K™*šžœžœ6žœžœ
žœ3žœ˜™
Kš
œ ˜ Kšžœ	žœ
žœ
˜K˜—K™šžœžœžœžœžœ%žœ˜}Kšœ
ŸœA˜_Kšžœ	žœ
žœ
˜K˜—K˜—Jšžœ
˜—J˜—K˜K˜—šœžœ_žœžœžœžœžœ˜₯
Kšœžœ˜(šžœžœ˜%šžœ	žœ
žœ˜Kšœžœ˜/šžœžœ
žœ.žœ
žœ
ž˜\Kš
œ#˜#Kšœ
žœ!˜/K™*šžœžœ/žœžœ
žœ,žœ˜‹
Kšœžœ˜$Kšžœ	žœ
žœ
˜K˜—K™šžœžœžœžœžœžœ˜vKšœ
Ÿœžœ˜HKšžœ	žœ
žœ
˜K˜—Jšžœ
˜—K˜
—šžœ˜Kšœžœ˜+Kšžœžœ
žœ
žœ
˜"šžœ
žœ
žœ=žœžœ
ž˜mKš
œ/˜/š
žœžœ
žœ
žœ%žœ˜FKšœ
žœ(˜6K™*šžœžœ6žœžœ
žœ3žœ˜™
Kš
œ8˜8Kšžœ	žœ
žœ
˜K˜—K™šžœžœžœžœžœ%žœ˜}Kšœ
œA˜\Kšžœ	žœ
žœ
˜K˜—K˜—Jšžœ
˜—J˜—J˜—K˜K˜—šœžœ
žœ.žœžœžœ
žœ
žœ˜yKšœžœ
žœ˜š

œžœžœžœžœ˜CKš
œ=˜=K˜—Kš
œ.˜.Kš
œ;˜;K˜K˜—šœžœ
žœAžœžœžœžœ
žœ˜‘
Kšœžœ
žœ˜š

œžœžœžœžœ˜NKš
œN˜NK˜—Kš
œ;˜;Kš
œJ˜JK˜K˜—š
œžœ
žœ.žœžœžœ˜pš
œžœžœžœžœ˜FKš
œ˜Kšžœ
žœ˜
K˜—Kš
œ>˜>K˜K˜—šœžœ
žœAžœžœžœ˜‘
š
œžœžœžœžœ˜QKš
œ˜Kšžœ
žœ˜
K˜—Kš
œM˜MK˜K˜—š
œžœ
žœ,žœ$žœžœ˜‚
Kš
œΑ
™Α
Kšœ&žœžœ
˜3Kš
œ0˜0šžœžœžœ˜5Kšœžœ˜/Kšœžœ
žœ˜Kšœžœ˜.Kš
œC˜Cšžœžœ
žœ)žœžœ
ž˜MJš
œ˜šžœ
žœ	žœ˜Jš
œ8˜8Jšžœ	žœ
žœ
žœ
˜%J˜
—Jšžœ	žœ
˜Jš
œ]˜]Jšžœ
˜—Jšžœžœ7˜HJšžœ
žœ
˜K˜
—šžœ˜Kšžœžœ&žœ˜=Kšžœ
žœ
˜Kš
œ˜K˜—K˜—šœžœ
žœIžœ$žœžœ˜§
Kš
œΑ
™Α
Kšœ žœžœ
˜-Kš
œ˜Kš
œF˜FKš
œ2˜2šžœžœžœ˜5Kšœžœ˜+Kšœžœ
žœ˜Kšœžœ˜.Kš
œC˜Cšžœžœ
žœ7žœžœ
ž˜[Jš
œ˜šžœ
žœ	žœ˜šžœžœ
žœ˜Jš
œX˜XJšžœ	žœ
žœ
žœ
˜%J˜—J˜
—Jšžœ	žœ
˜Jš
œ]˜]Jšžœ
˜—Jšžœžœ7˜HJšžœ
žœ
˜K˜
—šžœ˜Kš
œ˜Kš
œ˜K˜—K˜K˜—š
œžœ
žœžœžœ˜7Kšžœžœ˜CK˜K˜—šœžœ
žœ
žœžœžœ˜>Kšžœžœ˜5K˜K˜—š	œžœ
žœžœ˜AKšžœ˜K˜K˜—šœžœ
žœžœ˜MKš
œ˜Kšžœžœ*žœ
˜WK˜K˜—š
œžœ
žœžœžœžœžœ˜Sš
œžœžœžœžœ˜HKšœžœ
˜K˜—K™GKš
žœžœ
žœ
žœžœ˜3Kšœžœ:™Ešžœž˜Kšžœ
žœD˜N—Kšœžœ:™Ešžœž˜Kšžœ
žœD˜N—Kšœžœ$™/Kšžœ(˜.K˜K˜—š
œžœ
žœ
žœžœžœ˜MKšœžœžœ
žœžœžœ(˜‘
šœ	žœ
˜Kš
œ)˜)K˜Kšœžœžœžœ˜&Kš
œ$˜$Kš
œ$˜$Kšœ
žœ˜—Kšœ<žœ˜AKš
œ˜K˜—šœžœ
žœ)žœ˜OKš
œ™Kšœžœ˜.K˜Kšžœ	žœ
žœ
žœ
˜Kš
œ˜Kšžœžœ'žœ˜Yšžœ
žœžœ˜Kšœžœ
˜Kšœžœ
˜#Kšœžœ˜7K˜
—KšžœFžœ	˜WKš
œ˜Kš
œ˜K˜—šœžœ
žœžœ
žœžœ˜]Kšœžœ˜.K˜Kšžœ
žœ
žœ
žœ
˜šžœžœ
žœžœžœ
ž˜AKš
œ˜Kšžœ
˜—šžœžœžœ˜7šžœžœ
žœžœžœ
ž˜AKš
œ ˜ Kšžœ
˜—K˜
—šžœ
žœžœ˜Kšœžœ
˜Kšœžœ
˜#Kš
œO˜OK˜
—šžœ˜Kš
œ2™2Kšœžœ
žœ+˜@Kš
œS˜SK˜—Kš
œ˜K˜—K˜šœžœ
žœžœ˜UK™fKšœžœ˜.Kšœžœ
˜Kšœžœ
˜#Kš
œP˜PKš
œ˜Kšœžœžœ
žœ
žœ
žœ˜>K˜K˜—šœžœ
žœ#˜AKšœžœ˜0šžœžœ
žœ˜$Kš
œ#˜#šžœ
žœ
žœ˜Kš
œ$˜$K˜
—šžœ˜Kš
œ4˜4Kšžœžœ
žœ"˜=K˜—K˜—K˜K˜—š	œžœ
žœžœ˜9Kšœžœ˜/Kšœžœ˜;Kš
œ˜K˜K˜—š
	œžœ
žœžœ
žœ˜BKšœžœ˜/Kšœžœ˜;Kš
œ˜K˜—K˜šœžœ"˜3Kšœžœ˜.K˜Kšœžœ
˜#Kšžœ
žœžœ˜6Kš
œg˜gK˜K˜—K™K™š
œžœ
žœžœžœ˜DKš
œ<™<Kšœžœ˜.K˜Kšžœ
žœžœ˜@Kšžœ
žœžœ˜6Kš
žœ
žœžœ
žœžœ ˜HK˜K˜—š

œžœ
žœ'žœ
žœ˜PKš
œ'™'Kšœžœ˜.š
žœžœ
žœžœ
žœ˜"Kšœ&žœ
žœ˜4Kšœžœžœ
˜Kš
œ`˜`šžœžœ˜Kšžœžœ
žœ‘˜0Kšœžœ
˜Kšœžœ
˜#Kšœ‘W˜jšžœžœ
žœžœžœ
ž˜@K˜Kšžœ
˜—K˜K˜—K˜—K˜K˜—š
	œžœ
žœ'žœ
žœ˜OKš
œ'™'Kšœžœ˜.š
žœžœ
žœžœ
žœ˜"Kšœ&žœ
žœ˜4Kšœžœžœ
˜Kš
œ`˜`šžœžœ˜Kšžœžœ
žœ‘˜0Kšœžœ
˜Kšœžœ
˜#Kš	žœžœ
žœžœ‘1˜‚
šžœžœ
žœžœžœ
ž˜@K˜Kšžœ
˜—Kšœ‘7˜NK˜—Kš
œ˜—Kš
œ˜K˜—š

œžœ
žœžœžœ˜TKšœžœ˜.šžœžœ‘˜2Kšžœ
žœžœ˜6Kšžœ˜K˜
—Kš	žœ
žœžœ
žœ‘˜Všžœ‘˜!Kšœžœ˜šžœžœ
žœ2žœžœ
ž˜^Kšžœžœ
žœ˜/Kš
œ˜Kšžœ
˜—Kš
œ™Kšžœ
žœžœ˜6Kšžœ˜K˜—K˜K˜—š
œžœ
žœžœžœ˜WKšœžœ˜.Kš
œ=™=Kšžœ
žœžœ˜@Kšžœ
žœ
žœ
žœ
žœ
žœ
žœ™:Kš
œ˜K˜K˜—šœžœ
žœžœ˜VKš
œ‰
™‰
Kšœžœ
žœ
žœ
˜$K˜(Kš
œ˜Kš
œ˜K˜šžœž˜#Kš
œ%˜%Kšœ
žœ9˜JKš
œ˜Kšžœ
˜—šžœž˜#Kš
œ%˜%Kšœ
žœ9˜JKš
œ˜Kšžœ
˜—š	žœžœ
žœžœ
ž˜-Kš
œ@˜@Kšžœžœ
žœ
˜(Kš
œ˜Kš
œ˜Kšžœ
˜—Kšžœ˜K˜K˜—šœžœ˜*Kšœžœ˜.š
œžœžœžœžœ˜>Jš
œ˜Jš
œ˜J˜—Jšœžœ˜Kšœ(€œ€˜4Jšœžœ
˜"Kš
œ˜K˜—š	œžœ˜-Kš	žœžœ
žœžœ
ž˜9šžœžœ
žœ(žœžœ
ž˜JKš
œ˜Kšžœ
˜—Kšœžœ
˜Kš
œ˜K˜—K˜Kšžœ
˜—…—Υ†.U