DIRECTORY
Basics, Feedback, GGBasicTypes, GGBoundBox, GGCoreOps, GGCoreTypes, GGHistoryTypes, GGInterfaceTypes, GGModelTypes, GGOutline, GGParent, GGScene, GGSegmentTypes, GGSelect, GGSequence, GGSlice, GGSliceOps, GGTraj, GGTrajTypes, 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;
RunProc: TYPE = GGTrajTypes.RunProc;
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 Ź GGBoundBox.CopyBoundBox[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;
IF GGSliceOps.GetType[outline]#$Outline THEN ERROR;
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 GGSliceOps.GetType[outline]#$Outline THEN ERROR;
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 GGSliceOps.GetType[outline]#$Outline THEN ERROR;
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];
};

ReplaceRunsInOutline: PUBLIC PROC [outlineD: SliceDescriptor, runProc: RunProc, segmentsOnly: BOOL Ź TRUE, selectNewRuns: BOOL Ź FALSE] RETURNS [newOutline: Slice Ź NIL] = {
WHILE outlineD # NIL AND NOT GGSliceOps.IsEmptyParts[outlineD] DO
thisChildD: SliceDescriptor Ź GGParent.FirstIncludedChild[outlineD.slice, outlineD.parts, first];
SELECT GGSliceOps.GetType[thisChildD.slice] FROM
$Traj => {
newOutline Ź
GGTraj.ReplaceFirstRun[thisChildD, runProc, segmentsOnly, selectNewRuns];
IF newOutline = NIL THEN outlineD Ź NIL
ELSE {
parts: SliceParts Ź GGSliceOps.RemakeSelections[newOutline, active]; -- yuk
outlineD Ź IF parts = NIL THEN NIL ELSE GGSlice.DescriptorFromParts[newOutline, parts];
};
};
ENDCASE => { -- $Box or $Circle.  Clear its active bits and ignore it.
parts: SliceParts; -- yuk
GGSliceOps.SaveSelections[thisChildD.slice, NIL, active];
parts Ź GGSliceOps.RemakeSelections[thisChildD.slice, active];
outlineD Ź IF parts = NIL THEN NIL ELSE GGSlice.DescriptorFromParts[thisChildD.slice, parts];
};
ENDLOOP;
};

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;
IF NOT GGSliceOps.GetType[outline]=$Outline THEN RETURN;
[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];
IF GGSliceOps.GetType[outline]=$Outline THEN holesList Ź data.children.rest;
};

HasHoles: PUBLIC PROC [outline: Slice] RETURNS [BOOL Ź FALSE] =  {
data: OutlineData Ź NARROW[outline.data];
RETURN[GGSliceOps.GetType[outline]=$Outline AND 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 GGSliceOps.GetType[parent]#$Cluster THEN ERROR;
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 GGSliceOps.GetType[parent]#$Cluster THEN ERROR;
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 GGSliceOps.GetType[cluster]#$Cluster THEN ERROR;
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, 1992 by Xerox Corporation.  All rights reserved.
Pier, June 22, 1992 4:51 pm PDT
Bier, January 28, 1993 3:15 pm PST
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.
CopyBoundBox in case the caller or descendants messes with the conference of the slice boundBox
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
outlineD is a summary of the active bits of this outline that are set.  We proceed as follows:
1) Find the first active run of outlineD.
2) Replace it with the desired new run to create a new trajectory and a new outline.
3) Extract a new outlineD from the active bits of the result.
4) If outlineD is empty, we are done.  Otherwise return to step 1.
If newOutline is NIL at the end, no replaces were done.

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).
N.B.: the type check is to prevent erroneous reporting that Cluster types have holes, because if this proc is called with a Slice of class=$Cluster the NARROW will succeed.
N.B.: the type check is to prevent erroneous reporting that Cluster types have holes, because if this proc is called with a Slice of class=$Cluster the NARROW will succeed.
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.
Ę>¨  (cedarcode) styleNewlineDelimiter
 codeKĎnKSK
ĎeCNK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	'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.Ihead1@K+K=KBK/K;K3K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BK/K;K3K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-KKKKKK
KK	4KKKKK 
@EˇK!
1K$K4KPKK( ,iKIKK 8+.ŕ
 K+KKK
KK"KKK KY_KĎc1>K K"0TKKU #K-KKKKKK
KK	4KKKKK )KL.L<LLL	LL	K .ZKK] W	K
K
.;KKĐbk+K
.;KK	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˘.K
(K+=KK-?KKK '
	|KvvK&&K2KK>pK,K
K 	1sK% A DK	"KK$KKKK Ą+
	KxxK&&K2KK>pK,K
K 	1sK% E DK	"KK$KKKK ĄeKZZK!
1K 4aKK kKK$K!5KK*KKK K Tl&<KKCŁHK:Ł?K>ŁCKŁKDŁ˘ĐbciK@Ł˘¤eKK K+K.+K 	.pK"'K<oK@[KKK 
Ą0KDDK K+K.K	.pK0ŁGK7`KPŁUKKDK_KK Ą#{KĄ(`KKKIKKKK-KKKKKKK<TKK ĄSlK@@K K+K.K	.pK.ŁCK7`KMŁhKKK Ą#*}K
(^KKKEKKKK)KKKKKKK:RKK ĄWrKDDK K+K.K	.pK0GK7`K
 2ŁlKKK Ą#.K
(`KKKIKKKK-KKKKKKK<TKK Ą9tK>>K K+K.K	.pK0ŁIK7`K 4ŁWKKKK Ą#oK
(`KKKIKKKK
.FKKKKKKK<TKK Ą9rK<<K K.K+KK&KDK!KK	.\K.GKK7[KPUKKKKK Ą#tK  K.KKK Ą#mK
(^KKKGKKKK
.FKKKKKKK:RKK Ą	+
#ŠK22K K+K.K	.pK 	#VK7`K 	FdKKKK 	#
+§K
([KKKKKjKUKKK&KKK58KKKKKKKKKKK7OKK TK.K+	.pK0GK7`KPUKKKK #,KNK.K
(`KKKJKKKK.KKKKKKK<TKK K )_K"h	K))KK&K$$K$$K
K<AK!)K(K1KKK  PK˘1KK&3K)˘<K˘?KA
˘iK˘*AK!!HKKK #`K88K
K
'˘RKKK&3K
-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&3K
&K!(VK9KBK
"K)˘CAK	
˘/XK+K?OKK˘$AK'K?OKKKK!!KK =­J^^J))JTTJ==JBBJ#7J 	#AKa&0

KIIK'KE˘KK	0WKK˘9FK˘K,
9K>K	6]KKKK <K.4KK 
EK%2KK 
1qK$˘?
FK9KK2K KK??KKK K))K (K+7K.K˘(E&K33K,˘#OK'ĎtĽ=KKKK )xK.K6KK.K( C(
RK( KK6KK cK5	AK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SKK$2K;KK'KKKKK )cK&K4K7[4KK
K	K	.,oK8K=KKKKK +h
MKNNKK"˘2TKGĽĽZKK !CK"9KM

SK: GKKHĽĽ\KKK0K
/%WK'˘+RK%˘;K%˘8K%˘;K%
˘:KK% 
7K K K K KK GK6KOOK!
1KK!bKK 
,K88KK
-UK&>pK$K1.KKKKK C"
KK

-KK&>pK
˘&6K$K18KKKKKK K  K gKĚĚK0K
	AK"@hKK=KK SK22K0K(:K
"/KK 		\K;;K0KK&8K*)MK&;gKKK 	NK)KŹK& LKK BK)KŹK&HKMK%%K )_K2KK 	aK2KK87[KMeKKK %)hK$2K	˘'K+K(K87[KMeK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KK	KKKKK d´KNçK(%K+K"=mK/
%FK
(6K*63K K	KK%}K
 A_K	KKKKKK _ĽK(%	K/.\K#K
!/K*/,K$K	KKvK
 HK	KKKK+K"=mK/
%FK
(6K*63K8K	KK%}K
A\K	KKKKKKK .yK
CK=KK.K;KK AĄK
NKNKK;KJKK 
.p
FKKKK>KK A
QKKKKMKK ,$KÁÁK&3K05K/KK.KC)MK	K8K	%KK	K]KK7HK
KK&=K
KKKI$§KÁÁK -KKFK25K+KK.KC7[K	KXK	%KKK	K]KK7HK
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%2K	KK'YKK#K7KKF	WKKK ]K.K%2K
AKK7AK  KKKK#KOKK22K+@KSSKKKK UKfK.KK#KPKK>KK #AK0K&3$K#
K$$KK4K"=KKKK 	9K/K;KKK 
	
BK/K;KKK "3K.K K#K6K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.
>KKKKK(ĽĽ4K"KK 	-K	9(JKKKKK K K     Ű  6Ŕ 