DIRECTORY
GGBasicTypes, GGBoundBox, GGDescribe, GGError, GGInterfaceTypes, GGModelTypes, GGOutline, GGObjects, GGSelect, GGSegmentTypes, GGSequence, GGShapes, GGTraj, GGUtility, GGVector, GList, Imager, ImagerColor, ImagerPath, ImagerTransformation, Rope, Rosary;

GGOutlineImpl: CEDAR PROGRAM
IMPORTS GGBoundBox, GGDescribe, GGError, GGObjects, GGSelect, GGSequence, GGShapes, GGTraj, GGUtility, GGVector, GList, Imager, ImagerColor, ImagerPath, ImagerTransformation, Rosary
EXPORTS GGOutline = BEGIN

BitVector: TYPE = GGBasicTypes.BitVector;
BoundBox: TYPE = GGBasicTypes.BoundBox;
CameraData: TYPE = GGModelTypes.CameraData;
Circle: TYPE = GGBasicTypes.Circle;
Color: TYPE = Imager.Color;
ControlPointGenerator: TYPE = GGModelTypes.ControlPointGenerator;
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
GargoyleData: TYPE = GGInterfaceTypes.GargoyleData;
Joint: TYPE = GGSegmentTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Line: TYPE = GGBasicTypes.Line;
ObjectBag: TYPE = GGInterfaceTypes.ObjectBag;
Outline: TYPE = REF OutlineObj;
OutlineObj: TYPE = GGModelTypes.OutlineObj;
OutlineClass: TYPE = REF OutlineClassObj;
OutlineClassObj: TYPE = GGModelTypes.OutlineClassObj;
OutlineDescriptor: TYPE = GGModelTypes.OutlineDescriptor;
OutlineSequence: TYPE = GGSelect.OutlineSequence;
OutlineSequenceGenerator: TYPE = GGSelect.OutlineSequenceGenerator;
Point: TYPE = GGBasicTypes.Point;
PointGenerator: TYPE = GGModelTypes.PointGenerator;
PointPairGenerator: TYPE = GGModelTypes.PointPairGenerator;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SelectMode: TYPE = GGModelTypes.SelectMode;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
Sequence: TYPE = GGModelTypes.Sequence;
SliceClass: TYPE = REF SliceClassObj;
SliceClassObj: TYPE = GGModelTypes.SliceClassObj;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceParts: TYPE = GGModelTypes.SliceParts;
Traj: TYPE = REF TrajObj;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajGenerator: TYPE = REF TrajGeneratorObj;
TrajGeneratorObj: TYPE = GGModelTypes.TrajGeneratorObj;
TrajObj: TYPE = GGModelTypes.TrajObj;
TrajPartType: TYPE = GGModelTypes.TrajPartType;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
Vector: TYPE = GGBasicTypes.Vector;

OutlineDescribeProc: TYPE = GGModelTypes.OutlineDescribeProc;
OutlineFileoutProc: TYPE = GGModelTypes.OutlineFileoutProc;
OutlineFileinProc: TYPE = GGModelTypes.OutlineFileinProc;
OutlineUnionPartsProc: TYPE = GGModelTypes.OutlineUnionPartsProc;
OutlineDifferencePartsProc: TYPE = GGModelTypes.OutlineDifferencePartsProc;
OutlineFixedPartsProc: TYPE = GGModelTypes.OutlineFixedPartsProc;
OutlineAugmentPartsProc: TYPE = GGModelTypes.OutlineAugmentPartsProc;
OutlinePointsInDescriptorProc: TYPE = GGModelTypes.OutlinePointsInDescriptorProc;
OutlinePointPairsInDescriptorProc: TYPE = GGModelTypes.OutlinePointPairsInDescriptorProc;
OutlineNextPointProc: TYPE = GGModelTypes.OutlineNextPointProc;
OutlineNextPointPairProc: TYPE = GGModelTypes.OutlineNextPointPairProc;
OutlineClosestPointProc: TYPE = GGModelTypes.OutlineClosestPointProc;
OutlineClosestPointAndTangentProc: TYPE = GGModelTypes.OutlineClosestPointAndTangentProc;
OutlineClosestSegmentProc: TYPE = GGModelTypes.OutlineClosestSegmentProc;
OutlineSetArrowsProc: TYPE = GGModelTypes.OutlineSetArrowsProc;
OutlineGetArrowsProc: TYPE = GGModelTypes.OutlineGetArrowsProc;

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

NoOpFileout: PUBLIC OutlineFileoutProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
NoOpFilein: PUBLIC OutlineFileinProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
NoOpFixedParts: PUBLIC OutlineFixedPartsProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
NoOpPointsInDescriptor: PUBLIC PROC [sliceD: OutlineDescriptor] RETURNS [pointGen: PointGenerator] = {
pointGen _ NIL;
};
NoOpPointPairsInDescriptor: PUBLIC PROC [sliceD: OutlineDescriptor] RETURNS [pointPairGen: PointPairGenerator] = {
pointPairGen _ NIL;
};
NoOpNextPoint: PUBLIC PROC [pointGen: PointGenerator] RETURNS [pointAndDone: GGModelTypes.PointAndDone] = {
pointAndDone.done _ TRUE;
};
NoOpNextPointPair: PUBLIC PROC [pointPairGen: PointPairGenerator] RETURNS [pointPairAndDone: GGModelTypes.PointPairAndDone] = {
pointPairAndDone.done _ TRUE;
};

NoOpClosestPoint: PUBLIC OutlineClosestPointProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
NoOpClosestPointAndTangent: PUBLIC OutlineClosestPointAndTangentProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
NoOpClosestSegment: PUBLIC OutlineClosestSegmentProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};

NoOpSetArrows: PUBLIC OutlineSetArrowsProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
NoOpGetArrows: PUBLIC OutlineGetArrowsProc = {
SIGNAL Problem [msg: "All slice classes must have this proc."];
};
MakeOutlineClass: PROC [] RETURNS [class: OutlineClass] = {
class _ NEW[OutlineClassObj _ [
type: $Outline,
getBoundBox: OutlineBoundBox,
getTightBox: OutlineTightBox,
copy: OutlineCopy,
drawParts: OutlineDrawParts,
drawTransform: OutlineDrawTransform,
drawSelectionFeedback: OutlineDrawSelectionFeedback,
drawAttractorFeedback: OutlineDrawAttractorFeedback,
transform: OutlineTransform,
describe: OutlineDescribe,
fileout: NoOpFileout,
filein: NoOpFilein,
emptyParts: OutlineEmptyParts,
newParts: OutlineNewParts,
unionParts: OutlineUnionParts,
differenceParts: OutlineDifferenceParts,
movingParts: OutlineMovingParts,
fixedParts: OutlineFixedParts,
augmentParts: OutlineAugmentParts,
setSelectedFields: OutlineSetSelectedFields,
pointsInDescriptor: OutlinePointsInDescriptor,
pointPairsInDescriptor: OutlinePointPairsInDescriptor,
nextPoint: OutlineNextPoint,
nextPointPair: OutlineNextPointPair,
closestPoint: OutlineClosestPoint,
closestPointAndTangent: NoOpClosestPointAndTangent,
closestSegment: OutlineClosestSegment,
lineIntersection: OutlineLineIntersection,
circleIntersection: OutlineCircleIntersection,
hitDataAsSimpleCurve: OutlineHitDataAsSimpleCurve,
setStrokeWidth: OutlineSetStrokeWidth,
getStrokeWidth: OutlineGetStrokeWidth,
setStrokeColor: OutlineSetStrokeColor,
getStrokeColor: OutlineGetStrokeColor,
setFillColor: OutlineSetFillColor,
getFillColor: OutlineGetFillColor,
setArrows: NoOpSetArrows,
getArrows: NoOpGetArrows
]];
};

OutlineParts: TYPE = REF OutlinePartsObj;
OutlinePartsObj: TYPE = RECORD [
seqs: LIST OF Sequence
];

CreateOutline: PUBLIC PROC [traj: Traj, lineEnds: Imager.StrokeEnd _ square, fillColor: Imager.Color _ Imager.black] RETURNS [outline: Outline] =  {
boundBox: BoundBox _ GGBoundBox.CopyBoundBox[traj.boundBox];
outline _ NEW[OutlineObj _ [
class: FetchOutlineClass[],
fillColor: fillColor,
lineEnds: lineEnds,
children: LIST[traj],
parent: NIL,
boundBox: boundBox]];
traj.parent _ outline;
IF traj.role = hole THEN traj.role _ fence;
};


OutlineBoundBox: PROC [slice: Outline, parts: SliceParts] RETURNS [box: BoundBox] = {
IF parts = NIL THEN box _ slice.boundBox
ELSE {
outlineParts: OutlineParts _ NARROW[parts];
boxList: LIST OF BoundBox _ NIL;
thisBox: BoundBox;
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
thisBox _ GGSequence.ComputeBoundBox[list.first];
boxList _ CONS[thisBox, boxList];
};
ENDLOOP;
box _ GGBoundBox.BoundBoxOfBoxes[boxList];
};
};

OutlineTightBox: PROC [slice: Outline, parts: SliceParts] RETURNS [box: BoundBox] = {
outlineParts: OutlineParts;
boxList: LIST OF BoundBox _ NIL;
thisBox: BoundBox;
IF parts = NIL THEN parts _ slice.class.newParts[slice, NIL, slice];
outlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
thisBox _ GGSequence.ComputeTightBox[list.first];
boxList _ CONS[thisBox, boxList];
};
ENDLOOP;
box _ GGBoundBox.BoundBoxOfBoxes[boxList];
};

UpdateOutlineBoundBox: PUBLIC PROC [slice: Outline] = {
outlineBoxes: LIST OF BoundBox _ NIL;
trajGen: TrajGenerator;
IF slice=NIL THEN RETURN;
trajGen _ TrajsInOutline[slice];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
outlineBoxes _ CONS[traj.boundBox, outlineBoxes];
ENDLOOP;
UpdateBoundBoxFromList[slice.boundBox, outlineBoxes];
};

UpdateBoundBoxFromList: PROC [bBox: BoundBox, list: LIST OF BoundBox] = {
IF list = NIL THEN ERROR;
bBox.loX _ list.first.loX;
bBox.hiX _ list.first.hiX;
bBox.loY _ list.first.loY;
bBox.hiY _ list.first.hiY;
FOR bBoxList: LIST OF BoundBox _ list.rest, bBoxList.rest UNTIL bBoxList = NIL DO
bBox.loX _ MIN[bBox.loX, bBoxList.first.loX];
bBox.hiX _ MAX[bBox.hiX, bBoxList.first.hiX];
bBox.loY _ MIN[bBox.loY, bBoxList.first.loY];
bBox.hiY _ MAX[bBox.hiY, bBoxList.first.hiY];
ENDLOOP;
};

OutlineCopy: PROC [slice: Outline] RETURNS [copy: Outline] = {
holeGen: TrajGenerator;
newTraj, fence: Traj;
fence _ FenceOfOutline[slice];
newTraj _ GGTraj.CopyTraj[fence];
copy _ CreateOutline[newTraj, slice.lineEnds, slice.fillColor];
holeGen _ HolesOfOutline[slice];
FOR hole: Traj _ GGObjects.NextTraj[holeGen], GGObjects.NextTraj[holeGen] UNTIL hole = NIL DO
newTraj _ GGTraj.CopyTraj[hole];
copy.children _ AppendTrajList[copy.children, LIST[newTraj]];
newTraj.parent _ copy;
ENDLOOP;
};


OutlineDrawParts: PROC [slice: Outline, parts: SliceParts, dc: Imager.Context, camera: CameraData, quick: BOOL] = {
IF parts # NIL THEN ERROR Problem[msg: "outline parts are not yet implemented"];
DrawOutline[dc, slice];
};


DrawOutline: PROC [dc: Imager.Context, outline: Outline] = {
BuildOutline: Imager.PathProc = {
BuildPath: Imager.PathProc = {
BuildTrajPath[traj, moveTo, lineTo, curveTo, conicTo, arcTo];
};
imagerHole: ImagerPath.Trajectory;
cc: BOOL;
traj _ fence;
cc _  GGTraj.IsClockwiseTraj[traj];
BuildTrajPath[traj, moveTo, lineTo, curveTo, conicTo, arcTo];
FOR holeList: LIST OF Traj _ outline.children.rest, holeList.rest UNTIL holeList = NIL DO
traj _ holeList.first;
imagerHole _ ImagerPath.TrajectoryListFromPath[BuildPath].first;
IF cc=GGTraj.IsClockwiseTraj[traj] THEN ImagerPath.MapTrajectoryBackward[imagerHole, moveTo, lineTo, curveTo, conicTo, arcTo]
ELSE ImagerPath.MapTrajectory[imagerHole, moveTo, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
fence, traj: Traj;
fence _ outline.children.first;
IF fence.role = fence AND outline.fillColor#NIL THEN {
Imager.SetColor[dc, outline.fillColor];
Imager.MaskFill[dc, BuildOutline];
};
GGTraj.DrawTraj[dc, fence];
FOR holeList: LIST OF Traj _ outline.children.rest, holeList.rest UNTIL holeList = NIL DO
GGTraj.DrawTraj[dc, holeList.first];
ENDLOOP;
};

OutlineDrawTransform: PROC [slice: Outline, parts: SliceParts, dc: Imager.Context, camera: CameraData, transform: ImagerTransformation.Transformation] = {
sliceParts: OutlineParts _ NARROW[parts];
BuildOutline: Imager.PathProc = {
BuildPath: Imager.PathProc = {
seg: Segment;
firstPoint: Point _ GGTraj.FetchJointPos[traj, 0];
moveTo[ [firstPoint.x, firstPoint.y] ];
FOR i: INT IN [0..GGTraj.HiSegment[traj]] DO
seg _ GGTraj.FetchSegment[traj, i];
seg.class.buildPath[seg, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
BuildPathTransformSeq: Imager.PathProc = {
seg: Segment;
firstPoint: Point _ GGTraj.FetchJointPos[traj, 0];
IF thisSeq.segments[0] OR thisSeq.joints[0] THEN firstPoint _ ImagerTransformation.Transform[transform, firstPoint];
moveTo[ [firstPoint.x, firstPoint.y] ];
FOR i: INT IN [0..GGTraj.HiSegment[traj]] DO
seg _ GGTraj.FetchSegment[traj, i];
seg.class.buildPathTransform[seg, transform, thisSeq.segments[i], thisSeq.joints[i], thisSeq.joints[(i+1) MOD thisSeq.traj.segCount], thisSeq.controlPoints[i], lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};

imagerHole: ImagerPath.Trajectory;
cc, holeCC: BOOL;
traj _ fence;

thisSeq _ FindSequenceInList[traj, sliceParts.seqs];
IF thisSeq # NIL THEN {
BuildPathTransformSeq[moveTo, lineTo, curveTo, conicTo, arcTo];
cc _  GGTraj.IsClockwiseTrajTransformSeq[thisSeq, transform];
}
ELSE {
BuildPath[moveTo, lineTo, curveTo, conicTo, arcTo];
cc _  GGTraj.IsClockwiseTraj[traj];
};
FOR holeList: LIST OF Traj _ slice.children.rest, holeList.rest UNTIL holeList = NIL DO
traj _ holeList.first;
thisSeq _ FindSequenceInList[traj, sliceParts.seqs];
IF thisSeq # NIL THEN {
imagerHole _ ImagerPath.TrajectoryListFromPath[BuildPathTransformSeq].first;
holeCC _ GGTraj.IsClockwiseTrajTransformSeq[thisSeq, transform];
}
ELSE {
imagerHole _ ImagerPath.TrajectoryListFromPath[BuildPath].first;
holeCC _ GGTraj.IsClockwiseTraj[traj];
};
IF cc=holeCC THEN ImagerPath.MapTrajectoryBackward[imagerHole, moveTo, lineTo, curveTo, conicTo, arcTo]
ELSE ImagerPath.MapTrajectory[imagerHole, moveTo, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};

traj: Traj;
thisSeq: Sequence;
fence: Traj _ slice.children.first;
IF fence.role = fence AND slice.fillColor#NIL THEN {
transformedColor: Color;
WITH slice.fillColor SELECT FROM
cc: ImagerColor.ConstantColor => {
Imager.SetColor[dc, cc];
};
sc: ImagerColor.SampledColor => {
IF OutlineCompleteParts[slice, parts] THEN {
transformedColor _ ImagerColor.MakeSampledColor[pa: sc.pa, um: ImagerTransformation.Concat[sc.um, transform], colorOperator: sc.colorOperator];
Imager.SetColor[dc, transformedColor];
};
};
ENDCASE => ERROR;
Imager.MaskFill[dc, BuildOutline];
};
thisSeq _ FindSequenceInList[fence, sliceParts.seqs];
IF thisSeq # NIL THEN GGTraj.DrawTrajTransformSeq[dc, thisSeq, transform] ELSE GGTraj.DrawTraj[dc, fence];
FOR holeList: LIST OF Traj _ slice.children.rest, holeList.rest UNTIL holeList = NIL DO
thisSeq _ FindSequenceInList[holeList.first, sliceParts.seqs];
IF thisSeq # NIL THEN GGTraj.DrawTrajTransformSeq[dc, thisSeq, transform] ELSE GGTraj.DrawTraj[dc, holeList.first];
ENDLOOP;
};

FindSequenceInList: PROC [traj: Traj, seqList: LIST OF Sequence] RETURNS [seq: Sequence] = {
FOR list: LIST OF Sequence _ seqList, list.rest UNTIL list = NIL DO
IF list.first # NIL AND list.first.traj = traj THEN RETURN[list.first];
ENDLOOP;
RETURN[NIL];
};

BuildTrajPath: PROC [traj: Traj, moveTo: ImagerPath.MoveToProc, lineTo: ImagerPath.LineToProc, 
curveTo: ImagerPath.CurveToProc, conicTo: ImagerPath.ConicToProc, arcTo: ImagerPath.ArcToProc] = {
DoBuildTrajPath: Imager.PathProc = {
seg: Segment;
firstPoint: Point _ GGTraj.FetchJointPos[traj, 0];
moveTo[ [firstPoint.x, firstPoint.y] ];
FOR i: INT IN [0..GGTraj.HiSegment[traj]] DO
seg _ GGTraj.FetchSegment[traj, i];
seg.class.buildPath[seg, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
DoBuildTrajPath[moveTo, lineTo, curveTo, conicTo, arcTo];
};


OutlineDrawSelectionFeedback: PROC [slice: Outline, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: CameraData, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
normalOutlineParts, hotOutlineParts: OutlineParts;
normalList, hotList: LIST OF Sequence;
normalOutlineParts _ NARROW[selectedParts];
hotOutlineParts _ NARROW[hotParts];
IF caretIsMoving OR dragInProgress THEN RETURN;
IF selectedParts = NIL AND hotParts = NIL THEN RETURN;
IF selectedParts # NIL AND hotParts # NIL THEN {
hotList _ hotOutlineParts.seqs;
FOR normalList _ normalOutlineParts.seqs, normalList.rest UNTIL normalList = NIL DO
IF normalList.first # NIL THEN GGTraj.DrawSelectionFeedback[normalList.first.traj, normalList.first, hotList.first, dc, camera, dragInProgress, caretIsMoving, hideHot, quick]
ELSE IF hotList.first # NIL THEN GGTraj.DrawSelectionFeedback[hotList.first.traj, normalList.first, hotList.first, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
hotList _ hotList.rest;
ENDLOOP;
}
ELSE IF selectedParts # NIL THEN {
FOR normalList _ normalOutlineParts.seqs, normalList.rest UNTIL normalList = NIL DO
IF normalList.first # NIL THEN GGTraj.DrawSelectionFeedback[normalList.first.traj, normalList.first, NIL, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
ENDLOOP;
}
ELSE {
FOR hotList _ hotOutlineParts.seqs, hotList.rest UNTIL hotList = NIL DO
IF hotList.first # NIL THEN GGTraj.DrawSelectionFeedback[hotList.first.traj, NIL, hotList.first, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
ENDLOOP;
};
};

DrawCpsAndJoints: PROC [dc: Imager.Context, seg: Segment] = {
point: Point;
GGShapes.DrawJoint[dc, seg.lo];
GGShapes.DrawJoint[dc, seg.hi];
FOR j:INT IN [0..seg.class.controlPointCount[seg]) DO
point _ seg.class.controlPointGet[seg, j];
GGShapes.DrawCP[dc, point];
ENDLOOP;
};

OutlineDrawAttractorFeedback: PUBLIC PROC [sliceD: OutlineDescriptor, selectedParts: SliceParts, dragInProgress: BOOL, dc: Imager.Context, camera: CameraData] = {
success: BOOL;
partType: TrajPartType;
traj: Traj;
seg: Segment;
jointNum: NAT;
[success, partType, traj, ----, jointNum, ----, ----, seg] _ UnpackSimpleDescriptorOld[sliceD];
SELECT partType FROM
joint => {
IF jointNum > 0 THEN DrawCpsAndJoints[dc, GGTraj.FetchSegment[traj, jointNum-1]];
IF jointNum < traj.segCount THEN DrawCpsAndJoints[dc, GGTraj.FetchSegment[traj, jointNum]];
};
segment, controlPoint =>  DrawCpsAndJoints[dc, seg];
ENDCASE; -- none
};

OutlineTransform: PUBLIC PROC [slice: Outline, parts: SliceParts, transform: ImagerTransformation.Transformation] = {
outlineParts: OutlineParts _ NARROW[parts];
transformedColor: Color;
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN GGTraj.TransformSequence[list.first, transform];
ENDLOOP;
UpdateOutlineBoundBox[slice];
IF slice.fillColor # NIL THEN {
WITH slice.fillColor SELECT FROM
cc: ImagerColor.ConstantColor => {};
sc: ImagerColor.SampledColor => {
IF OutlineCompleteParts[slice, parts] THEN {
transformedColor _ ImagerColor.MakeSampledColor[pa: sc.pa, um: ImagerTransformation.Concat[sc.um, transform], colorOperator: sc.colorOperator];
slice.fillColor _ transformedColor;
};
};
ENDCASE => ERROR;
};
};


OneSequenceOnly: PROC [realParts: OutlineParts] RETURNS [theSeq: Sequence] = {
theSeq _ NIL;
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF theSeq # NIL THEN RETURN[NIL]
ELSE theSeq _ list.first;
};
ENDLOOP;
};

OutlineDescribe: PROC [slice: Outline, parts: SliceParts] RETURNS [rope: Rope.ROPE] = {
realParts: OutlineParts _ NARROW[parts];
theSeq: Sequence;
IF (theSeq _ OneSequenceOnly[realParts]) # NIL THEN {
rope _ DescribeSequence[theSeq];
}
ELSE {
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN RETURN["several parts of a multi-trajectory outline"];
ENDLOOP;
rope _ "No outline parts to speak of.";
};
};

DescribeSequence: PROC [seq: Sequence] RETURNS [rope: Rope.ROPE] = {
segNum, cpNum: NAT;
segCount: NAT _ seq.segCount;
jointCount: NAT _ seq.jointCount;
cpCount: NAT _ seq.controlPointCount;
SELECT TRUE FROM
segCount=1 => { -- single segment selected. Describe it
segGen: SegmentGenerator _ GGSequence.SegmentsInSequence[seq];
rope _ GGDescribe.DescribeSegment[seq.traj,
GGSequence.NextSegmentAndIndex[segGen].index];
};
segCount=0 AND cpCount=1 => { -- single CP selected. Describe it
cpGen: ControlPointGenerator _ GGSequence.ControlPointsInSequence[seq];
[segNum, cpNum] _ GGSequence.NextSegNumAndCPNum[cpGen];
rope _ GGDescribe.DescribeControlPoint[seq.traj, segNum, cpNum];
};
segCount=0 AND cpCount=0 AND jointCount=1 => { -- single joint selected. Describe it
jointGen: JointGenerator _ GGSequence.JointsInSequence[seq];
rope _ GGDescribe.DescribeJoint[seq.traj, GGSequence.NextJoint[jointGen]];
};
ENDCASE => rope _ GGDescribe.DescribeSequence[seq];
};



OutlineMovingParts: PROC [slice: Outline, parts: SliceParts] RETURNS [moving: SliceParts] = {
outlineParts: OutlineParts _ NARROW[parts];
moveParts: OutlineParts;
ptr: LIST OF Sequence;
movingSeq: Sequence;
moving _ moveParts _ NEW[OutlinePartsObj];
[moveParts.seqs, ptr] _ GGUtility.StartSequenceList[];
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first = NIL THEN {
[moveParts.seqs, ptr] _ GGUtility.AddSequence[NIL, moveParts.seqs, ptr]
}
ELSE {
movingSeq _ MovingSequence[list.first];
[moveParts.seqs, ptr] _ GGUtility.AddSequence[movingSeq, moveParts.seqs, ptr];
};
ENDLOOP;
};

OutlineFixedParts: PROC [slice: Outline, parts: SliceParts, selectedList: LIST OF REF ANY] RETURNS [fixed: SliceParts] = {
realParts: OutlineParts;
seq: Sequence;

fixed _ realParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
seq _ list.first;
IF seq # NIL THEN {
GGSequence.TrimSelectedControlPointSegments[seq, selectedList];
GGSequence.TrimSelectedJointSegments[seq, selectedList];
GGSequence.TrimSelectedParts[seq, selectedList];
};
ENDLOOP;
};

MovingSequence: PROC [seq: Sequence] RETURNS [movingSeq: Sequence] = {
completeSeq: Sequence _ GGSequence.CreateComplete[seq.traj];
stationarySeq: Sequence _ GGSequence.Copy[completeSeq];
GGSequence.DDifference[stationarySeq, seq]; -- remove everything that is directly moving
GGSequence.TrimControlPointSegments[stationarySeq, FALSE]; -- remove all segments with a directly moving control point.
GGSequence.TrimJointSegments[stationarySeq, FALSE]; -- remove all segments with a directly moving joint
movingSeq _ GGSequence.Difference[completeSeq, stationarySeq];  -- Difference calculates the moving parts
};

OutlineEmptyParts: PROC [slice: Outline, parts: SliceParts] RETURNS [BOOL] = {
realParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL AND NOT GGSequence.IsEmpty[list.first] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

OutlineCompleteParts: PROC [slice: Outline, parts: SliceParts] RETURNS [BOOL] = {
realParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first = NIL THEN RETURN[FALSE];
IF NOT GGSequence.IsComplete[list.first] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};


NearestJointToHitSpot: PUBLIC PROC [caretPt: Point, traj: Traj, hitJointNum: INT, hitSegNum: INT, hitType: HitType] RETURNS [jointNum: NAT] = {
nextNum: NAT;
p1, p2: Point;
d1, d2: REAL;
SELECT hitType FROM
joint => {
jointNum _ hitJointNum;
};
segment, controlPoint => {
nextNum _ GGTraj.FollowingJoint[traj, hitSegNum];
p1 _ GGTraj.FetchJointPos[traj, hitSegNum];
p2 _ GGTraj.FetchJointPos[traj, nextNum];
d1 _ GGVector.DistanceSquared[p1, caretPt];
d2 _ GGVector.DistanceSquared[p2, caretPt];
IF d1 <= d2 THEN jointNum _ hitSegNum
ELSE jointNum _ nextNum;
};
ENDCASE => ERROR Problem[msg: "not yet implemented"];
}; -- end of NearestJointToHitSpot

OutlineNewParts: PROC [slice: Outline, hitData: REF ANY, mode: SelectMode] RETURNS [parts: SliceParts] = {
realParts: OutlineParts;
ptr: LIST OF Sequence;
trajGen: GGModelTypes.TrajGenerator;
parts _ realParts _ NEW[OutlinePartsObj];
[realParts.seqs, ptr] _ GGUtility.StartSequenceList[];
SELECT mode FROM
none => {
outlineHitData: OutlineHitData _ NARROW[hitData];
SELECT outlineHitData.hitType FROM
joint, controlPoint => parts _ OutlineNewParts[slice, hitData, joint];
segment => parts _ OutlineNewParts[slice, hitData, segment];
ENDCASE => ERROR;
};
slice => {
completeSeq: Sequence;
trajGen _ TrajsInOutline[slice];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
completeSeq _ GGSequence.CreateComplete[traj];
[realParts.seqs, ptr] _ GGUtility.AddSequence[completeSeq, realParts.seqs, ptr];
ENDLOOP;
};
joint => {
outlineHitData: OutlineHitData _ NARROW[hitData];
SELECT outlineHitData.hitType FROM
joint => { -- hit a joint
traj: Traj _ outlineHitData.traj;
jointNum: NAT _ outlineHitData.jointNum;
seq: Sequence _ GGSequence.CreateJointToJoint[traj, jointNum, jointNum];
parts _ PartsFromSequence[slice, seq];
};
segment => { -- we are in the middle of a segment. Select nearest joint or cp
success: BOOL;
segNum: NAT;
cpNum, jointNum: NAT;
jointPoint, cpPoint, caretPt: Point;
traj: Traj;
seg: Segment;
seq: Sequence;

traj _ outlineHitData.traj;
segNum _ outlineHitData.segNum;
seg _ GGTraj.FetchSegment[traj, segNum];
caretPt _ outlineHitData.hitPoint;
jointNum _ NearestJointToHitSpot[caretPt, traj, -1, segNum, segment];
jointPoint _ GGTraj.FetchJointPos[traj, jointNum];
[cpPoint, cpNum, success] _ seg.class.closestControlPoint[seg, caretPt, GGUtility.plusInfinity];
IF NOT success THEN seq _ GGSequence.CreateJointToJoint[traj, jointNum, jointNum]
ELSE {
cpDist: REAL _ GGVector.DistanceSquared[cpPoint, caretPt];
jointDist: REAL _ GGVector.DistanceSquared[jointPoint, caretPt];
seq _ IF cpDist < jointDist THEN GGSequence.CreateFromControlPoint[traj, segNum, cpNum]
ELSE GGSequence.CreateJointToJoint[traj, jointNum, jointNum];
};
parts _ PartsFromSequence[slice, seq];
};
controlPoint => {
traj: Traj;
segNum, cpNum: NAT;
controlPointSeq: Sequence;
traj _ outlineHitData.traj;
segNum _ outlineHitData.segNum;
cpNum _ outlineHitData.cpNum;
controlPointSeq _ GGSequence.CreateFromControlPoint[traj, segNum, cpNum];
parts _ PartsFromSequence[slice, controlPointSeq];
};
ENDCASE  => ERROR;
};
segment => {
outlineHitData: OutlineHitData _ NARROW[hitData];
SELECT outlineHitData.hitType FROM
joint => {
parts _ CreateEmptyParts[slice];
};
segment, controlPoint => {
seq: Sequence;
seq _ GGSequence.CreateFromSegment[outlineHitData.traj, outlineHitData.segNum];
parts _ PartsFromSequence[slice, seq];
};
ENDCASE  => ERROR;
};
traj => {
outlineHitData: OutlineHitData _ NARROW[hitData];
traj: Traj _ outlineHitData.traj;
seq: Sequence _ GGSequence.CreateComplete[traj];
parts _ PartsFromSequence[slice, seq];
};
topLevel => {
parts _ slice.class.newParts[slice, NIL, slice];
};
ENDCASE => ERROR;
};

CreateEmptyParts: PROC [slice: Outline] RETURNS [empty: SliceParts] = {
realParts: OutlineParts;
empty _ realParts _ NEW[OutlinePartsObj];
realParts.seqs _ NIL;
FOR list: LIST OF Traj _ slice.children, list.rest UNTIL list = NIL DO
realParts.seqs _ CONS[NIL, realParts.seqs];
ENDLOOP;
};

OutlineUnionParts: PROC [slice: Outline, partsA: SliceParts, partsB: SliceParts] RETURNS [aPlusB: SliceParts] = {
realPartsA: OutlineParts _ NARROW[partsA];
realPartsB: OutlineParts _ NARROW[partsB];
union: OutlineParts;
listA: LIST OF Sequence _ realPartsA.seqs;
listB: LIST OF Sequence _ realPartsB.seqs;
ptr: LIST OF Sequence;
aPlusB _ union _ NEW[OutlinePartsObj];
[union.seqs, ptr] _ GGUtility.StartSequenceList[];
UNTIL listA = NIL DO
IF listA.first = NIL THEN [union.seqs, ptr] _ GGUtility.AddSequence[listB.first, union.seqs, ptr]
ELSE IF listB.first = NIL THEN [union.seqs, ptr] _ GGUtility.AddSequence[listA.first, union.seqs, ptr]
ELSE {
newSeq: Sequence _ GGSequence.Union[listA.first, listB.first];
[union.seqs, ptr] _ GGUtility.AddSequence[newSeq, union.seqs, ptr];
};
listA _ listA.rest;
listB _ listB.rest;
ENDLOOP;
};

OutlineDifferenceParts: PROC [slice: Outline, partsA: SliceParts, partsB: SliceParts] RETURNS [aMinusB: SliceParts] = {
realPartsA: OutlineParts _ NARROW[partsA];
realPartsB: OutlineParts _ NARROW[partsB];
diff: OutlineParts;
listA: LIST OF Sequence _ realPartsA.seqs;
listB: LIST OF Sequence _ realPartsB.seqs;
ptr: LIST OF Sequence;
aMinusB _ diff _ NEW[OutlinePartsObj];
[diff.seqs, ptr] _ GGUtility.StartSequenceList[];
UNTIL listA = NIL DO
IF listA.first = NIL THEN [diff.seqs, ptr] _ GGUtility.AddSequence[NIL, diff.seqs, ptr]
ELSE IF listB.first = NIL THEN [diff.seqs, ptr] _ GGUtility.AddSequence[listA.first, diff.seqs, ptr]
ELSE {
newSeq: Sequence _ GGSequence.Difference[listA.first, listB.first];
[diff.seqs, ptr] _ GGUtility.AddSequence[newSeq, diff.seqs, ptr];
};
listA _ listA.rest;
listB _ listB.rest;
ENDLOOP;
};

OutlineAugmentParts: PROC [slice: Outline, parts: SliceParts, selectClass: SelectionClass] RETURNS [more: SliceParts] = {
sliceParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ sliceParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN SequenceAugmentParts[list.first, selectClass];
ENDLOOP;
more _ parts;
};

SequenceAugmentParts: PROC [seq: Sequence, selectClass: SelectionClass] = {
IF selectClass = normal THEN {
GGSequence.FillInJoints[seq];
GGSequence.FillInControlPoints[seq];
}
ELSE {
GGSequence.FillInControlPoints[seq];
};
};
OutlineSetSelectedFields: PROC [sliceD: OutlineDescriptor, selected: BOOL, selectClass: SelectionClass] = {
sliceParts: OutlineParts _ NARROW[sliceD.parts];
FOR list: LIST OF Sequence _ sliceParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN SequenceSetSelectedFields[list.first, selected, selectClass];
ENDLOOP;
};

SequenceSetSelectedFields: PROC [seq: Sequence, selected: BOOL, selectClass: SelectionClass] = {
joint: Joint;
jointGen: JointGenerator;
segGen: SegmentGenerator;
SetTrajPartField[seq.traj, selected, selectClass];
jointGen _ GGSequence.JointsInSequence[seq];
FOR jointNum: INT _ GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL jointNum = -1 DO
joint _ NARROW[Rosary.Fetch[seq.traj.joints, jointNum]];
SetJointField[joint, selected, selectClass];
ENDLOOP;
segGen _ GGSequence.SegmentsInSequence[seq];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
SetSegmentField[seg, selected, selectClass];
ENDLOOP;
};

SetTrajPartField: PROC [traj: Traj, selected: BOOL, selectClass: SelectionClass]  = {
SELECT selectClass FROM
normal => traj.selectedInPart.normal _ selected;
hot => traj.selectedInPart.hot _ selected;
active => traj.selectedInPart.active _ selected;
ENDCASE;
};

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


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

SetControlPointField: PROC [seg: Segment, cpNum: NAT, selected: BOOL, selectClass: SelectionClass]  = {
seg.class.controlPointFieldSet[seg, cpNum, selected, selectClass];
};

GetControlPointField: PROC [seg: Segment, cpNum: NAT, selectClass: SelectionClass] RETURNS [selected: BOOL]  = {
selected _ seg.class.controlPointFieldGet[seg, cpNum, selectClass];
};

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

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


HitType: TYPE = GGModelTypes.TrajPartType;
OutlineHitData: TYPE = REF OutlineHitDataObj;
OutlineHitDataObj: TYPE = RECORD [
traj: Traj,
hitType: HitType,
segNum: INT,
cpNum: INT,
jointNum: INT,
hitPoint: Point
];

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

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

OutlinePointsInDescriptor: PUBLIC PROC [sliceD: OutlineDescriptor] RETURNS [pointGen: GGModelTypes.OutlinePointGenerator] = {
realParts: OutlineParts _ NARROW[sliceD.parts];
seqPtr: LIST OF Sequence _ realParts.seqs;
trajPointGen: GGModelTypes.PointGenerator;
pointGenData: PointGeneratorData;
trajPointGen _ IF seqPtr.first = NIL THEN NIL ELSE GGTraj.PointsInDescriptor[seqPtr.first];
pointGenData _ NEW[PointGeneratorDataObj _ [seqPtr: seqPtr, pointGen: trajPointGen]];
pointGen _ NEW[GGModelTypes.OutlinePointGeneratorObj _ [sliceD, 0, 0, pointGenData]];
};

OutlinePointPairsInDescriptor: PUBLIC PROC [sliceD: OutlineDescriptor] RETURNS [pointPairGen: GGModelTypes.OutlinePointPairGenerator] = {
realParts: OutlineParts _ NARROW[sliceD.parts];
seqPtr: LIST OF Sequence _ realParts.seqs;
trajPointGen: GGModelTypes.PointPairGenerator;
pointGenData: PointPairGeneratorData;
trajPointGen _ IF seqPtr.first = NIL THEN NIL ELSE GGTraj.PointPairsInDescriptor[seqPtr.first];
pointGenData _ NEW[PointPairGeneratorDataObj _ [seqPtr: seqPtr, pointGen: trajPointGen]];
pointPairGen _ NEW[GGModelTypes.OutlinePointPairGeneratorObj _ [sliceD, 0, 0, pointGenData]];
};

OutlineNextPoint: PUBLIC PROC [pointGen: GGModelTypes.OutlinePointGenerator] RETURNS [pointAndDone: GGModelTypes.PointAndDone] = {
pgd: PointGeneratorData _ NARROW[pointGen.classSpecific];
seqPtr: LIST OF Sequence _ pgd.seqPtr;
IF seqPtr = NIL THEN RETURN[[[0,0], TRUE]];
WHILE TRUE DO
IF seqPtr.first # NIL THEN {
pointAndDone _ GGTraj.NextPoint[pgd.pointGen];
IF NOT pointAndDone.done THEN {
pgd.seqPtr _ seqPtr;
RETURN;
};
seqPtr _ seqPtr.rest; -- on to the next sequence
};
UNTIL seqPtr = NIL OR seqPtr.first # NIL DO seqPtr _ seqPtr.rest ENDLOOP;
IF seqPtr = NIL THEN RETURN[[[0,0], TRUE]];
pgd.pointGen _ GGTraj.PointsInDescriptor[seqPtr.first];
ENDLOOP;
};

OutlineNextPointPair: PUBLIC PROC [pointPairGen: GGModelTypes.OutlinePointPairGenerator] RETURNS [pointPairAndDone: GGModelTypes.PointPairAndDone] = {
pgd: PointPairGeneratorData _ NARROW[pointPairGen.classSpecific];
seqPtr: LIST OF Sequence _ pgd.seqPtr;
IF seqPtr = NIL THEN RETURN[[[0,0], [0,0], TRUE]];
WHILE TRUE DO
IF seqPtr.first # NIL THEN {
pointPairAndDone _ GGTraj.NextPointPair[pgd.pointGen];
IF NOT pointPairAndDone.done THEN {
pgd.seqPtr _ seqPtr;
RETURN;
};
seqPtr _ seqPtr.rest; -- on to the next sequence
};
UNTIL seqPtr = NIL OR seqPtr.first # NIL DO seqPtr _ seqPtr.rest ENDLOOP;
IF seqPtr = NIL THEN RETURN[[[0,0], [0,0], TRUE]];
pgd.pointGen _ GGTraj.PointPairsInDescriptor[seqPtr.first];
ENDLOOP;
};

GoodPointType: TYPE = {joint, intersectionPoint, midpoint, controlPoint, slice, none};
OutlineClosestPoint: PROC [sliceD: OutlineDescriptor, testPoint: Point, tolerance: REAL] RETURNS [bestPoint: Point, bestDist: REAL, hitData: REF ANY, success: BOOL] = {
parts: OutlineParts _ NARROW[sliceD.parts];
thisDist: REAL;
thisSegNum, bestSegNum, thisCP, bestCP, thisJointNum, bestJointNum: NAT;
thisPoint: Point;
thisSuccess: BOOL;
bestTraj: Traj;
bestType: GoodPointType _ none;
outlineHitData: OutlineHitData;

success _ FALSE;
bestDist _ GGUtility.plusInfinity;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
[thisDist, thisSegNum, thisCP, thisPoint, thisSuccess] _ GGTraj.NearestControlPoint[testPoint, list.first, tolerance];
IF thisSuccess AND thisDist < bestDist THEN {
bestType _ controlPoint;
bestPoint _ thisPoint;
bestDist _ thisDist;
bestTraj _ list.first.traj;
bestSegNum _ thisSegNum;
bestCP _ thisCP;
success _ TRUE;
};
ENDLOOP;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
[thisDist, thisJointNum, thisPoint, thisSuccess] _ GGTraj.NearestJoint[testPoint, list.first, tolerance];
IF thisSuccess AND thisDist < bestDist THEN {
bestType _ joint;
bestPoint _ thisPoint;
bestDist _ thisDist;
bestTraj _ list.first.traj;
bestJointNum _ thisJointNum;
success _ TRUE;
};
ENDLOOP;
IF success THEN {
SELECT bestType FROM
controlPoint => {
hitData _ outlineHitData _ NEW[OutlineHitDataObj _ [
bestTraj, controlPoint, bestSegNum, bestCP, -1, bestPoint]];
};
joint => {
hitData _ outlineHitData _ NEW[OutlineHitDataObj _ [
bestTraj, joint, -1, -1, bestJointNum, bestPoint]];
};
ENDCASE => ERROR;
};
};


OutlineClosestSegment: PUBLIC PROC [sliceD: OutlineDescriptor, testPoint: Point, tolerance: REAL] RETURNS [bestPoint: Point, bestDist: REAL, hitData: REF ANY, success: BOOL] = {
parts: OutlineParts _ NARROW[sliceD.parts];
thisDist: REAL;
thisSegNum, bestSegNum: NAT;
thisPoint: Point;
thisSuccess: BOOL;
bestTraj: Traj;
outlineHitData: OutlineHitData;

success _ FALSE;
bestDist _ GGUtility.plusInfinity;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
[thisDist, thisSegNum, thisPoint, thisSuccess] _ GGTraj.NearestSegment[testPoint, list.first, tolerance];
IF thisSuccess AND thisDist < bestDist THEN {
bestPoint _ thisPoint;
bestDist _ thisDist;
bestTraj _ list.first.traj;
bestSegNum _ thisSegNum;
success _ TRUE;
};
ENDLOOP;
IF success THEN {
hitData _ outlineHitData _ NEW[OutlineHitDataObj _ [
bestTraj, segment, bestSegNum, -1, -1, bestPoint]];
};
};
OutlineLineIntersection: PUBLIC PROC [sliceD: OutlineDescriptor, line: Line] RETURNS [points: LIST OF Point, pointCount: NAT] = {
segGen: GGModelTypes.SegmentGenerator;
thesePoints: LIST OF Point;
thisCount: NAT;
seq: Sequence;
parts: OutlineParts _ NARROW[sliceD.parts];

points _ NIL;
pointCount _ 0;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
seq _ list.first;
IF seq = NIL THEN LOOP;
segGen _ GGSequence.SegmentsInSequence[seq];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] 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;
};

OutlineCircleIntersection: PROC [sliceD: OutlineDescriptor, circle: Circle] RETURNS [points: LIST OF Point, pointCount: NAT] = {
segGen: GGModelTypes.SegmentGenerator;
thesePoints: LIST OF Point;
thisCount: NAT;
seq: Sequence;
parts: OutlineParts _ NARROW[sliceD.parts];

points _ NIL;
pointCount _ 0;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
seq _ list.first;
IF seq = NIL THEN LOOP;
segGen _ GGSequence.SegmentsInSequence[seq];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] 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;
ENDLOOP;
pointCount _ pointCount + thisCount;
ENDLOOP;
};

OutlineHitDataAsSimpleCurve: PROC [slice: Outline, hitData: REF ANY] RETURNS [simpleCurve: REF ANY] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
traj: Traj _  outlineHitData.traj;
SELECT outlineHitData.hitType FROM
joint, controlPoint => RETURN[NIL];
segment => {
segNum: INT _ outlineHitData.segNum;
seg: Segment _ GGTraj.FetchSegment[traj, segNum];
simpleCurve _ seg.class.asSimpleCurve[seg, outlineHitData.hitPoint];
};
ENDCASE => ERROR;
};


OutlineSetStrokeWidth: PROC [slice: Outline, parts: SliceParts, strokeWidth: REAL] = {
realParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN GGSequence.SetStrokeWidth[list.first, strokeWidth];
ENDLOOP;
};

OutlineGetStrokeWidth: PROC [slice: Outline, parts: SliceParts] RETURNS [strokeWidth: REAL] = {
realParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN RETURN[GGSequence.GetStrokeWidth[list.first]];
ENDLOOP;
ERROR Problem[msg: "No segments to get a stroke width from"];
};

OutlineSetStrokeColor: PROC [slice: Outline, parts: SliceParts, color: Imager.Color] = {
realParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN SequenceSetStrokeColor[list.first, color];
ENDLOOP;
};

SequenceSetStrokeColor: PROC [seq: Sequence, color: Imager.Color] =  {
segGen: SegmentGenerator;
segGen _ GGSequence.SegmentsInSequence[seq];
FOR seg: Segment _ GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
seg.color _ color;
ENDLOOP;
};

OutlineGetStrokeColor: PROC [slice: Outline, parts: SliceParts] RETURNS [color: Imager.Color] = {
realParts: OutlineParts _ NARROW[parts];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN RETURN[SequenceGetStrokeColor[list.first]];
ENDLOOP;
ERROR Problem[msg: "No segments to get a stroke width from"];
};

SequenceGetStrokeColor: PROC [seq: Sequence] RETURNS [color: Imager.Color] =  {
segGen: SegmentGenerator _ GGSequence.SegmentsInSequence[seq];
seg: Segment _ GGSequence.NextSegment[segGen];
IF seg#NIL THEN color _ seg.color;
};

OutlineSetFillColor: PROC [slice: Outline, color: Imager.Color] = {
slice.fillColor _ color
};
OutlineGetFillColor: PROC [slice: Outline] RETURNS [color: Imager.Color] = {
color _ slice.fillColor;
};
UnpackOnePointDescriptorOld: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [traj: Traj, isACP: BOOL, segNum, cpNum, jointNum: NAT] = {
parts: OutlineParts;
theSeq: Sequence;
IF outlineD = NIL THEN RETURN[NIL, FALSE, 999, 999, 999];
parts _ NARROW[outlineD.parts];
traj _ NIL;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF traj # NIL THEN RETURN[NIL, FALSE, 999, 999, 999]
ELSE {
theSeq _ list.first;
traj _ theSeq.traj;
[isACP, segNum, cpNum, jointNum] _ GGSequence.UnpackOnePointSequence[theSeq];
};
};
ENDLOOP;
};

UnpackSimpleDescriptorOld: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [success: BOOL, partType: TrajPartType, traj: Traj, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point, cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = {
parts: OutlineParts;
theSeq: Sequence;
IF outlineD = NIL THEN RETURN[FALSE, joint, NIL, NIL, 999, [0,0]];
parts _ NARROW[outlineD.parts];
traj _ NIL;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF traj # NIL THEN RETURN[FALSE, joint, NIL, NIL, 999, [0,0]]
ELSE {
theSeq _ list.first;
traj _ theSeq.traj;
[success, partType, traj, joint, jointNum, cp, cpNum, seg, segNum] _ GGSequence.UnpackSimpleSequence[theSeq];
};
};
ENDLOOP;
};

UnpackSimpleDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [success: BOOL, partType: TrajPartType, traj: Traj, joint: Joint _ NIL, jointNum: NAT _ 999, cp: Point, cpNum: NAT _ 999, seg: Segment _ NIL, segNum: NAT _ 999] = {
ERROR Problem[msg: "Outlines are not slices yet"];
};

UnpackOnePointDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [traj: Traj, isACP: BOOL, segNum, cpNum, jointNum: NAT] = {
ERROR Problem[msg: "Outlines are not slices yet"];
};

UnpackOneSegmentDescriptorOld: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [traj: Traj, segNum: NAT] = {
parts: OutlineParts;
theSeq: Sequence;
IF outlineD = NIL THEN RETURN[NIL, 999];
parts _ NARROW[outlineD.parts];
traj _ NIL;
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN {
IF traj # NIL THEN RETURN[NIL, 999]
ELSE {
theSeq _ list.first;
traj _ theSeq.traj;
[segNum] _ GGSequence.UnpackOneSegmentSequence[theSeq];
};
};
ENDLOOP;
};


UnpackOneSegmentDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [traj: Traj, segNum: NAT] = {
ERROR Problem[msg: "Outlines are not slices yet"];
};

FindTrajInDescriptor: PUBLIC PROC [outlineD: OutlineDescriptor, traj: Traj] RETURNS [seq: Sequence] = {
outlineParts: OutlineParts;
outlineParts _ NARROW[outlineD.parts];
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL AND list.first.traj = traj THEN RETURN[list.first];
ENDLOOP;
RETURN[NIL];
};

PartsFromSequence: PUBLIC PROC [outline: Outline, seq: Sequence] RETURNS [sliceParts: SliceParts] = {
realParts: OutlineParts;
ptr: LIST OF Sequence;
trajGen: GGModelTypes.TrajGenerator;
sliceParts _ realParts _ NEW[OutlinePartsObj];
[realParts.seqs, ptr] _ GGUtility.StartSequenceList[];
trajGen _ TrajsInOutline[outline];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
IF traj = seq.traj THEN [realParts.seqs, ptr] _ GGUtility.AddSequence[seq, realParts.seqs, ptr]
ELSE [realParts.seqs, ptr] _ GGUtility.AddSequence[NIL, realParts.seqs, ptr];
ENDLOOP;
};

CopyParts: PUBLIC PROC [outline: Outline, parts: SliceParts] RETURNS [copy: SliceParts] = {
realParts, realCopyParts: OutlineParts;
copySeq: Sequence;
ptr: LIST OF Sequence;
realParts _ NARROW[parts];
copy _ realCopyParts _ NEW[OutlinePartsObj];
[realCopyParts.seqs, ptr] _ GGUtility.StartSequenceList[];
FOR list: LIST OF Sequence _ realParts.seqs, list.rest UNTIL list = NIL DO
IF list.first = NIL THEN [realCopyParts.seqs, ptr] _ GGUtility.AddSequence[NIL, realCopyParts.seqs, ptr]
ELSE {
copySeq _ GGSequence.Copy[list.first];
[realCopyParts.seqs, ptr] _ GGUtility.AddSequence[copySeq, realCopyParts.seqs, ptr]
};
ENDLOOP;
};

AddHole: PUBLIC PROC [outline: Outline, hole: Traj] RETURNS [holier: Outline] = {
holier _ outline.class.copy[outline];
holier.children _ AppendTrajList[holier.children, LIST[hole]];
hole.parent _ holier;
hole.role _ hole;
UpdateOutlineBoundBox[holier];
};

ReplaceFence: PUBLIC PROC [outline: Outline, newFence: Traj] RETURNS [newOutline: Outline] = {
holeGen: TrajGenerator;
newTraj: Traj;
newOutline _ CreateOutline[newFence, outline.lineEnds, outline.fillColor];
holeGen _ HolesOfOutline[outline];
FOR hole: Traj _ GGObjects.NextTraj[holeGen], GGObjects.NextTraj[holeGen] UNTIL hole = NIL DO
newTraj _ GGTraj.CopyTraj[hole];
newOutline.children _ AppendTrajList[newOutline.children, LIST[newTraj]];
newTraj.parent _ newOutline;
ENDLOOP;
UpdateOutlineBoundBox[newOutline];
};


ReplaceHole: PUBLIC PROC [outline: Outline, oldHole, newHole: Traj] RETURNS [newOutline: Outline] = {
holeGen: TrajGenerator;
newTraj, fence: Traj;
fence _ FenceOfOutline[outline];
newTraj _ GGTraj.CopyTraj[fence];
newOutline _ CreateOutline[newTraj, outline.lineEnds, outline.fillColor];
holeGen _ HolesOfOutline[outline];
FOR hole: Traj _ GGObjects.NextTraj[holeGen], GGObjects.NextTraj[holeGen] UNTIL hole = NIL DO
IF hole = oldHole THEN {
newOutline.children _ AppendTrajList[newOutline.children, LIST[newHole]];
newHole.parent _ newOutline;
}
ELSE {
newTraj _ GGTraj.CopyTraj[hole];
newOutline.children _ AppendTrajList[newOutline.children, LIST[newTraj]];
newTraj.parent _ newOutline;
};
ENDLOOP;
UpdateOutlineBoundBox[newOutline];
};

OutlineOfTraj: PUBLIC PROC [traj: Traj] RETURNS [outline: Outline] = {
outline _ traj.parent;
};

SaveSelectionsInOutline: PUBLIC PROC [outline: Outline, scene: Scene] = {
outlineD: OutlineDescriptor;
outlineParts: OutlineParts;
outlineD _ GGSelect.FindSelectedOutline[outline, scene, hot];
ClearSelectionInOutline[outline, hot];
IF outlineD # NIL THEN {
outlineParts _ NARROW[outlineD.parts];
FOR seqList: LIST OF Sequence _ outlineParts.seqs, seqList.rest UNTIL seqList = NIL DO
IF seqList.first#NIL THEN SaveSelectionInSequence[seqList.first, hot];
ENDLOOP;
};
outlineD _ GGSelect.FindSelectedOutline[outline, scene, normal];
ClearSelectionInOutline[outline, normal];
IF outlineD # NIL THEN {
outlineParts _ NARROW[outlineD.parts];
FOR seqList: LIST OF Sequence _ outlineParts.seqs, seqList.rest UNTIL seqList = NIL DO
IF seqList.first#NIL THEN SaveSelectionInSequence[seqList.first, normal];
ENDLOOP;
};
outlineD _ GGSelect.FindSelectedOutline[outline, scene, active];
ClearSelectionInOutline[outline, active];
IF outlineD # NIL THEN {
outlineParts _ NARROW[outlineD.parts];
FOR seqList: LIST OF Sequence _ outlineParts.seqs, seqList.rest UNTIL seqList = NIL DO
IF seqList.first#NIL THEN SaveSelectionInSequence[seqList.first, active];
ENDLOOP;
};
};

SaveSelectionInTraj: PUBLIC PROC [traj: Traj, selectClass: SelectionClass, scene: Scene] = {
seq: Sequence _ GGSelect.FindSelectedSequence[traj, scene, selectClass];
IF seq=NIL THEN ClearSelectionInTraj[traj, selectClass]
ELSE SaveSelectionInSequence[seq, selectClass];
};

ClearSelectionInTraj: PROC [traj: Traj, selectClass: SelectionClass] = {
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..GGTraj.HiSegment[traj]] DO
seg _ GGTraj.FetchSegment[traj, i];
SetSegmentField[seg, FALSE, selectClass];
FOR j: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
SetControlPointField[seg, j, FALSE, selectClass];
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..GGTraj.HiJoint[traj]] DO
joint _ GGTraj.FetchJoint[traj, i];
SetJointField[joint, FALSE, selectClass];
ENDLOOP;
};

RemakeSelectionFromTraj: PUBLIC PROC [traj: Traj, scene: Scene, selectClass: SelectionClass] = {
seq: Sequence _ GGSequence.CreateEmpty[traj];
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..GGTraj.HiSegment[traj]] DO
seg _ GGTraj.FetchSegment[traj, i];
seq.segments[i] _ GetSegmentField[seg, selectClass];
IF seq.segments[i] THEN seq.segCount _ seq.segCount + 1;
FOR j: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
seq.controlPoints[i][j] _ GetControlPointField[seg, j, selectClass];
IF seq.controlPoints[i][j] THEN seq.controlPointCount _ seq.controlPointCount + 1;
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..GGTraj.HiJoint[traj]] DO
joint _ GGTraj.FetchJoint[traj, i];
seq.joints[i] _ GetJointField[joint, selectClass];
IF seq.joints[i] THEN seq.jointCount _ seq.jointCount + 1;
ENDLOOP;
GGSelect.SelectSequence[seq, scene, selectClass];
};

SaveSelectionInSequence: PROC [seq: Sequence, selectClass: SelectionClass] = {
seg: Segment;
joint: Joint;
FOR i: NAT IN [0..GGTraj.HiSegment[seq.traj]] DO
seg _ GGTraj.FetchSegment[seq.traj, i];
SetSegmentField[seg, seq.segments[i], selectClass];
FOR j: NAT IN [0..seg.class.controlPointCount[seg]-1] DO
SetControlPointField[seg, j, seq.controlPoints[i][j], selectClass];
ENDLOOP;
ENDLOOP;
FOR i: NAT IN [0..GGTraj.HiJoint[seq.traj]] DO
joint _ GGTraj.FetchJoint[seq.traj, i];
SetJointField[joint, seq.joints[i], selectClass];
ENDLOOP;
};

ClearSelectionInOutline: PROC [outline: Outline, selectClass: SelectionClass] = {
trajGen: GGModelTypes.TrajGenerator;
trajGen _ TrajsInOutline[outline];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
ClearSelectionInTraj[traj, selectClass];
ENDLOOP;
};

RemakeSelectionsFromOutline: PUBLIC PROC [outline: Outline, scene: Scene] = {
trajGen: GGModelTypes.TrajGenerator;
trajGen _ TrajsInOutline[outline];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
RemakeSelectionFromTraj[traj, scene, hot];
RemakeSelectionFromTraj[traj, scene, normal];
RemakeSelectionFromTraj[traj, scene, active];
ENDLOOP;
};

SequencesOfOutline: PUBLIC PROC [outlineD: OutlineDescriptor] RETURNS [seqList: LIST OF Sequence] = {
outlineParts: OutlineParts _ NARROW[outlineD.parts];
ptr: LIST OF Sequence;
[seqList, ptr] _ GGUtility.StartSequenceList[];
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN [seqList, ptr] _ GGUtility.AddSequence[list.first, seqList, ptr];
ENDLOOP;
};

RemoveTraj: PUBLIC PROC [outlineD: OutlineDescriptor, traj: Traj] = {
outlineParts: OutlineParts _ NARROW[outlineD.parts];
seq: Sequence;
FOR list: LIST OF Sequence _ outlineParts.seqs, list.rest UNTIL list = NIL DO
IF list.first#NIL AND list.first.traj = traj THEN {
seq _ list.first;
GOTO Done;
};
REPEAT
Done => {
outlineParts.seqs _ NARROW[GList.DSubst[NIL, seq, outlineParts.seqs]];
};
FINISHED => NULL;
ENDLOOP;
};
NearestJointToHitData: PUBLIC PROC [hitData: REF ANY] RETURNS [jointNum: NAT, traj: Traj] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
nextNum: NAT;
p1, p2: Point;
d1, d2: REAL;
traj _ outlineHitData.traj;
SELECT outlineHitData.hitType FROM
joint => {
jointNum _ outlineHitData.jointNum;
};
segment, controlPoint => {
nextNum _ GGTraj.FollowingJoint[traj, outlineHitData.segNum];
p1 _ GGTraj.FetchJointPos[traj, outlineHitData.segNum];
p2 _ GGTraj.FetchJointPos[traj, nextNum];
d1 _ GGVector.DistanceSquared[p1, outlineHitData.hitPoint];
d2 _ GGVector.DistanceSquared[p2, outlineHitData.hitPoint];
IF d1 <= d2 THEN jointNum _ outlineHitData.segNum
ELSE jointNum _ nextNum;
};
ENDCASE => ERROR;
};

UnpackHitData: PUBLIC PROC [hitData: REF ANY] RETURNS [traj: Traj, hitType: TrajPartType, segNum, cpNum, jointNum: INT, hitPoint: Point] = {
outlineHitData: OutlineHitData _ NARROW[hitData];
traj _ outlineHitData.traj;
hitType _ outlineHitData.hitType;
segNum _ outlineHitData.segNum;
cpNum _ outlineHitData.cpNum;
jointNum _ outlineHitData.jointNum;
hitPoint _ outlineHitData.hitPoint;
};

UpdateDescriptorBoundBoxes: PUBLIC PROC [outlineD: OutlineDescriptor] = {
parts: OutlineParts _ NARROW[outlineD.parts];
FOR list: LIST OF Sequence _ parts.seqs, list.rest UNTIL list = NIL DO
IF list.first # NIL THEN GGSequence.UpdateBoundBox[list.first];
ENDLOOP;
};
HasHoles: PUBLIC PROC [outline: Outline] RETURNS [BOOL] =  {
RETURN[outline.children.rest # NIL];
};

FenceOfOutline: PUBLIC PROC [outline: Outline] RETURNS [fence: Traj] =  {
fence _ outline.children.first;
};

HolesOfOutline: PUBLIC PROC [outline: Outline] RETURNS [trajGen: TrajGenerator] =  {
list: LIST OF Traj _ outline.children.rest;
trajGen _ NEW[TrajGeneratorObj _ [
list: list
]];
};

TrajsInOutline: PUBLIC PROC [outline: Outline] RETURNS [trajGen: TrajGenerator] =  {
list: LIST OF Traj _ outline.children;
trajGen _ NEW[TrajGeneratorObj _ [
list: list
]];
};

FetchOutlineClass: PROC [] RETURNS [class: OutlineClass] = {
class _ globalOutlineClass;
};

globalOutlineClass: OutlineClass;
Init: PROC [] = {
globalOutlineClass _ MakeOutlineClass[];
};


AppendTrajList: PROC [list1, list2: LIST OF Traj] RETURNS [result: LIST OF Traj] = {
pos: LIST OF Traj;
newCell: LIST OF Traj;
IF list1 = NIL THEN RETURN[list2];
result _ CONS[list1.first, NIL];
pos _ result;
FOR l: LIST OF Traj _ list1.rest, l.rest UNTIL l = NIL DO
newCell _ CONS[l.first, NIL];
pos.rest _ newCell;
pos _ newCell;
ENDLOOP;
pos.rest  _ list2;
};

Init[];

END.


ÖGGOutlineImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last edited by Bier on June 2, 1986 5:10:01 pm PDT
Contents:  Procedures to implement the Outline Slice Class in Gargoyle.  Outlines consist of Trajectories which in turn consist of Segments.  Outline is the most important slice class.

NoOp Class Routines

Textual Description


Style


The Outline Class

Drawing
Transforming
Textual Description
Parts
Hit Testing
Style
simple: BOOL _ FALSE, -- TRUE if seqs contains only a single control point or a single joint
Fundamentals
Computes it from traj boxes.

Drawing
GGModelTypes.OutlineDrawPartsProc

Drawing Utilities
Someday this will be a call to
path.class.buildPath[traj, moveTo, lineTo, curveTo, conicTo, arcTo];
path.class.buildPath[traj, moveTo, lineTo, curveTo, conicTo, arcTo];
Will be path.class.drawBorder[fence, dc, gargoyleData];
Will be path.class.drawBorder[holeList.first, dc, gargoyleData];
PathProc: TYPE ~ PROC[moveTo: MoveToProc, lineTo: LineToProc, 
curveTo: CurveToProc, conicTo: ConicToProc, arcTo: ArcToProc];


Transforming

Textual Description

Parts
Trim away the moving parts.
exclude segments with moving cps
exclude segments with moving joints
exclude all directly moving parts
Segments with selected control points are not stationary
If selectClass = normal, then for each segment mentioned in parts, place it, its adjacent joints, and its control points in more.  If selectClass # normal then just place each segment and its control points in more.
Selected sequences must satisfy the requirement that if a segment is selected its joints and control points are as well.

Set the selected fields of all of the joints and segments mentioned in sliceD.
Joint Fields.
Segment Fields.
Hit Testing


Finds the intersection of the line with those slice parts mentioned in sliceD.
simpleCurve will be of type Edge, Arc, etc.  There will be Conic and Bezier types as well.
Style
Sets the stroke width of the named parts of slice to be strokeWidth.
Get the stroke width of the first segment you come to.
Sets the stroke color of the named parts of slice to be color.
Get the stroke color of the named parts of slice.
Sets the fill color of the slice to be color.
Get the fill color of the slice.

Outline-Only operations.

outlineD describes either a single control point or a single joint.  Return the [segNum, cpNum] pair or the jointNum as appropriate.
outlineD describes either a single control point or a single joint.  Return the [segNum, cpNum] pair or the jointNum as appropriate.
Holes can be removed using DeleteSequence.
Should check for duplicates. -- Bier, February 20
Like CopyOutline except in one place.
Like CopyOutline except in one place.
Finds the unique outline to which traj belongs.
hotness.
normal selection.
active selection.
This outline has just been created by copying parts from an existing outline.  The selection information was copied as well.  Make sequences from the selection bits, and select these sequences.
hotness.
normal selection.
active selection.
Used by GGSelect to do a DeselectTraj.
Replace the old sequence with a NIL.  No trajectory has actually been deleted.  It is just no longer mentioned in outlineD.

This will go away when the Caret machinery is revised.
Update the bound boxes of all contained sequences.

Queries about Outlines.
Returns the unique fence trajectory of outline.
Generates all of the holes of outline.
Generates the fence and all of the holes of outline.
Utility Routines
Non-destructive (copies the first list).
�Ê;“˜J˜Icodeš
œ™Kšœ
Ïm
œ1™<Kš
œ2™2Kš
œ¸
™¸
K™š
Ïk	˜	Kš
œý
˜ý
—K˜šÏn
œžœ
ž˜Kšžœ®
˜µ
Kšžœ
ž˜K˜Kšœžœ˜)Kšœ
žœ˜'Kšœžœ˜+Kšœžœ˜#Kšœžœ˜Kšœžœ&˜AKšœ
žœ ˜1Kšœžœ!˜3Kšœžœ˜#Kšœžœ˜3Kšœžœ˜Kšœžœ˜-Kšœ	žœžœ˜Kšœžœ˜+Kšœžœžœ˜)Kšœžœ ˜5Kšœžœ"˜9Kšœžœ˜1Kšœžœ%˜CKšœžœ˜!Kšœžœ˜3Kšœžœ#˜;Kšœžœ˜!Kšœ	žœ˜'Kšœžœ!˜7Kšœžœ˜+Kšœžœ!˜5Kšœ
žœ˜'Kšœžœžœ˜%Kšœžœ˜1Kšœžœ ˜5Kšœžœ˜+Kšœžœžœ	˜Kšœ	žœ˜%Kšœžœžœ˜+Kšœžœ!˜7Kšœ	žœ˜%Kšœžœ˜/Kšœžœ˜/Kšœžœ˜#K˜Kšœžœ$˜=Kšœžœ#˜;Kšœžœ"˜9Kšœžœ&˜AKšœžœ+˜KKšœžœ&˜AKšœžœ(˜EKšœžœ.˜QKšœ#žœ2˜YKšœžœ%˜?Kšœžœ)˜GKšœžœ(˜EKšœ#žœ2˜YKšœžœ*˜IKšœžœ%˜?Kšœžœ%˜?—K˜KšŸœžœ
žœžœ
˜'KšŸœžœ
žœžœ˜:K˜K™K™Kš
œ™K™šŸœžœ˜*Kšžœ9˜?K˜—šŸ
œžœ˜(Kšžœ9˜?K˜—šŸœžœ˜0Kšžœ9˜?K˜—šŸœžœ
žœžœ˜fKšœžœ
˜K˜—šŸœžœ
žœžœ'˜rKšœžœ
˜K˜—šŸ
œžœ
žœžœ.˜kKšœžœ
˜K˜—šŸœžœ
žœ$žœ6˜Kšœžœ
˜K˜K˜—šŸœžœ˜4Kšžœ9˜?K˜—šŸœžœ&˜HKšžœ9˜?K˜—šŸœžœ˜8Kšžœ9˜?K˜K˜—K™Kš
œ™K™šŸ
œžœ˜.Kšžœ9˜?K˜—šŸ
œžœ˜.Kšžœ9˜?K˜—K™K™K™šŸœžœžœ˜;šœžœ˜Kš
œ˜Kšœ
Ïbœ
˜Kšœ
 œ
˜šœ œ
˜Kš
 ™—Kšœ œ
˜Kšœ œ
˜$Kšœ œ
˜4šœ œ
˜4Kš
 ™—šœ œ
˜Kš
 ™—Kšœ
 œ
˜K˜˜Kš
 ™—Kšœ œ
˜Kšœ
 œ
˜Kšœ œ
˜Kšœ œ
˜(Kšœ
 œ
˜ Kšœ œ
˜Kšœ œ
˜"šœ œ
˜,Kš
 ™—Kšœ œ
˜.Kšœ œ
˜6Kšœ œ
˜Kšœ œ
˜$Kšœ œ
˜"K˜3Kšœ œ
˜&Kšœ œ
˜*Kšœ œ
˜.šœ œ
˜2Kš
 ™—Kšœ œ
˜&Kšœ œ
˜&Kšœ œ
˜&Kšœ œ
˜&Kšœ œ
˜"Kšœ œ
˜"K˜K˜K˜—K˜K˜—Kšœžœžœ˜)šœžœžœ˜ KšœžœžœÏcF™\Kšœžœ
žœ	˜K˜K˜—šŸ
œžœ
žœ[žœ˜”
Kš
œ<˜<šœ
žœ˜K˜Kš
œ˜Kš
œ˜Kšœ
žœ˜Kšœžœ
˜Kš
œ˜—Kš
œ˜Kšžœžœ˜+Kš
œ˜K˜—Kš
œ™K˜šŸœžœ%žœ˜UKšžœ	žœ
žœ˜(šžœ˜Kšœžœ˜+Kšœ	žœ
žœžœ
˜ Kš
œ˜šžœžœ
žœ)žœžœ
ž˜Mšžœžœ
žœ˜Jš
œ1˜1Jšœ
žœ˜!J˜—Jšžœ
˜—Jš
œ*˜*J˜—K˜K˜—šŸœžœ%žœ˜UKš
œ˜Kšœ	žœ
žœžœ
˜ Kš
œ˜Kšžœ	žœ
žœ%žœ	˜DKšœžœ˜šžœžœ
žœ)žœžœ
ž˜Mšžœžœ
žœ˜Jš
œ1˜1Jšœ
žœ˜!J˜—Jšžœ
˜—Jš
œ*˜*K˜K˜—šŸœžœ˜7K™Kšœžœ
žœžœ
˜%Kš
œ˜Kšžœžœ
žœ
ž˜Kš
œ ˜ šžœGžœžœ
ž˜]Kšœžœ˜1Kšžœ
˜—Kš
œ5˜5K˜K˜—šŸœžœžœ
žœ˜IKšžœžœ
žœ
žœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šžœžœ
žœ%žœžœ
ž˜QKšœžœ˜-Kšœžœ˜-Kšœžœ˜-Kšœžœ˜-Kšžœ
˜—K˜K˜—šŸœžœžœ˜>K˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ?˜?Kš
œ ˜ šžœGžœžœ
ž˜]Kš
œ ˜ Kšœ.žœ˜=Kš
œ˜Kšžœ
˜—K˜K˜—K™Kš
œ™K˜šŸœžœTžœ˜sKš
œ!™!Kšžœ	žœ
žœ
žœ7˜PKš
œ˜K˜K˜—K™K™K˜šŸœžœ+˜<šŸœ˜!šŸ	œ˜K™Kš
œD™DKš
œ=˜=K˜—Kš
œ"˜"Kšœžœ
˜	Kš
œ
˜
Kš
œ#˜#Kš
œD™DKš
œ=˜=šžœžœ
žœ-žœžœ
ž˜YKš
œ˜Kš
œ@˜@Kšžœ!žœV˜}KšžœO˜S—Kšžœ
˜K˜—Kš
œ˜Kš
œ˜šžœžœžœ
žœ˜6Kš
œ'˜'K˜"K˜—Kš
œ˜Kš
œ7™7šžœžœ
žœ-žœžœ
ž˜YKš
œ$˜$Kš
œ@™@—Kšžœ
˜K˜K˜—šŸœžœ€
˜š
Kšœžœ˜)šÐbnœ˜!Kšœ
žœžœh™}š¢	œ˜K˜
Kš
œ2˜2Kš
œ'˜'šžœžœ
žœž˜,Kš
œ#˜#Kš
œ:˜:—Kšžœ
˜K˜—š¢œ˜*K˜
Kš
œ2˜2KšžœžœžœD˜tKš
œ'˜'šžœžœ
žœž˜,Kš
œ#˜#KšœjžœT˜Á
Kšžœ
˜—K˜—K˜Kš
œ"˜"Kšœžœ
˜Kš
œ
˜
K˜Kš
œ4˜4šžœžœ
žœ˜Kš
œ?˜?Kš
œ=˜=K˜
—šžœ˜Kš
œ3˜3Kš
œ#˜#K˜—šžœžœ
žœ+žœžœ
ž˜WKš
œ˜Kš
œ4˜4šžœžœ
žœ˜Kš
œL˜LKš
œ@˜@K˜
—šžœ˜Kš
œ@˜@Kš
œ&˜&K˜—KšžœžœV˜gKšžœO˜SKšžœ
˜—K˜—K˜Kš
œ˜K˜Kš
œ#˜#šžœžœžœ
žœ˜4Kš
œ˜šžœžœ
ž˜ š
œ"˜"Kš
œ˜Kš
œ˜—š
œ!˜!šžœ$žœ˜,Kš
œ�
˜�
Kš
œ&˜&K˜—K˜—Kšžœžœ
˜—K˜"K˜—Kš
œ5˜5Kšžœžœ
žœ5žœ˜jšžœžœ
žœ+žœžœ
ž˜WKš
œ>˜>Kšžœžœ
žœ5žœ%˜sKšžœ
˜—K˜K˜—š
Ÿœžœžœ
žœžœ˜\šžœžœ
žœžœžœ
ž˜CKš
žœžœ
žœžœ
žœ
˜GKšžœ
˜—Kšžœ
žœ˜K˜K˜—šŸ
œžœ¯
˜Â
šŸœ˜$K˜
Kš
œ2˜2Kš
œ'˜'šžœžœ
žœž˜,Kš
œ#˜#Kš
œ:˜:—Kšžœ
˜K˜—Kš
œ9˜9Kš
œ˜—˜K˜—šŸœžœš
žœ˜Å
K˜2Kšœžœ
žœ
˜&Kšœžœ˜+Kšœžœ˜#Kšžœžœžœ
žœ
˜/Kšžœžœ
žœžœ
žœ
žœ
˜6š
žœžœ
žœžœ
žœ˜0Kš
œ˜šžœ7žœžœ
ž˜SKšžœžœ
žœ�
˜®
Kšžœ
žœžœ
žœŽ
˜®
Kš
œ˜Kšžœ
˜—K˜
—šžœ
žœžœ
žœ˜"šžœ7žœžœ
ž˜SKšžœžœ
žœGžœ=˜¥
Kšžœ
˜—K˜
—šžœ˜šžœ.žœžœ
ž˜GKšžœžœ
žœ2žœL˜œ
Kšžœ
˜—K˜—K˜K˜—K™šŸœžœ'˜=Kš
œ
˜
Kš
œ˜Kš
œ˜šžœžœ
žœ'ž˜5Kš
œ*˜*Kš
œ˜Kšžœ
˜—K˜K˜—š¢œžœ
žœHžœ-˜¢
Jšœ	žœ
˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jšœ
žœ
˜Jšœ¡œA˜_šžœ
ž˜š
œ
˜
Jšžœžœ=˜QJšžœžœ;˜[J˜—Jš
œ4˜4Jšžœ¡˜—K˜—K™Kš
œ™K˜šŸœžœ
žœX˜uKšœžœ˜+K˜šžœžœ
žœ)žœžœ
ž˜MKšžœžœ
žœ1˜IKšžœ
˜—Kš
œ˜šžœž
˜šžœžœ
ž˜ Kš
œ$˜$š
œ!˜!šžœ$žœ˜,Kš
œ�
˜�
Kš
œ#˜#K˜—K˜—Kšžœžœ
˜—K˜—K˜K˜—K™Kš
œ™K˜šŸœžœžœ˜NKšœ	žœ
˜
šžœžœ
žœ&žœžœ
ž˜Jšžœžœ
žœ˜Kš
žœ
žœ
žœ
žœ
žœ
˜ Kšžœ˜K˜—Kšžœ
˜—K˜K˜—šŸœžœ%žœ
žœ˜WKšœžœ˜(Kš
œ˜šžœ)ž
˜5Kš
œ ˜ K˜
—šžœ˜šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ
žœ0˜OJšžœ
˜—Jš
œ'˜'J˜—K˜K˜—šŸœžœžœ
žœ˜DKšœžœ
˜Kšœ
žœ˜Kšœžœ˜!Kšœ	žœ˜%šžœ
žœ
ž˜šœ¡'˜7Kš
œ>˜>šœ œ
˜+Kš
œ.˜.—K˜—šœžœ¡"˜@Kš
œG˜GKš
œ7˜7Kšœ œ˜@K˜—šœžœžœ¡%˜TKš
œ<˜<Kšœ 
œ+˜JK˜—Kšžœ,˜3—K˜K˜K˜—K™Kš
œ™K˜šŸœžœ%žœ˜]Kšœžœ˜+Kš
œ˜Kšœžœ
žœ
˜Kš
œ˜Kšœžœ˜*Kš
œ6˜6šžœžœ
žœ)žœžœ
ž˜Mšžœžœ
žœ˜Jšœ.žœ˜GJ˜
—šžœ˜Jš
œ'˜'Jš
œN˜NJ˜—Jšžœ
˜—J˜J˜—šŸœžœ3žœ
žœ
žœ
žœžœ˜zJš
œ˜Jš
œ˜J˜šœžœ˜"J™—šžœžœ
žœ&žœžœ
ž˜JJš
œ˜šžœžœ
žœ˜Kš
  ™ Kš
œ?˜?Kš
 #™#Kš
œ8˜8Kš
 !™!Kš
œ0˜0J˜—Jšžœ
˜—J˜J˜—šŸœžœžœ˜FKš
œ<˜<š
œ7˜7Kš
Ðbc8™8—Kš
œX˜XKšœ3žœ?˜wKšœ,žœ¡3˜gKšœ@¡)˜iK˜K˜—šŸœžœ%žœžœ˜NKšœžœ˜(šžœžœ
žœ&žœžœ
ž˜JKšžœžœ
žœ
žœ žœ
žœ
žœ˜NKšžœ
˜—Kšžœ
žœ˜
K˜K˜—šŸœžœ%žœžœ˜QKšœžœ˜(šžœžœ
žœ&žœžœ
ž˜JKš
žœžœ
žœ
žœ
žœ˜'Kš
žœ
žœ#žœ
žœ
žœ˜<Kšžœ
˜—Kšžœ
žœ˜
K˜K˜K˜—šŸœžœ
žœ+žœ
žœžœžœ˜�
Kšœ	žœ
˜
K˜Kšœžœ
˜
šžœ	ž˜š
œ
˜
Kš
œ˜K˜—š
œ˜Kš
œ1˜1Kš
œ+˜+Kš
œ)˜)Kš
œ+˜+Kš
œ+˜+Kšžœ
žœ˜%Kšžœ˜K˜—Kšžœžœ%˜5—Kšœ¡˜"K˜—š
Ÿœžœžœ
žœžœ˜jKš
œ˜Kšœžœ
žœ
˜Jš
œ$˜$Kšœžœ˜)Kš
œ6˜6šžœž˜˜	Jšœ!žœ
˜1šžœž˜"Jš
œF˜FJš
œ<˜<Jšžœžœ
˜—J˜—š
œ
˜
Jš
œ˜Jš
œ ˜ šžœGžœžœ
ž˜]Kš
œ.˜.Jš
œP˜PJšžœ
˜—J˜—˜
Jšœ!žœ
˜1šžœž˜"šœ¡˜Kš
œ!˜!Kšœ
žœ˜(Kš
œH˜HKš
œ&˜&K˜—šœ
¡@˜MKšœ	žœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ$˜$Kš
œ˜Kš
œ
˜
K˜K˜Kš
œ˜Kš
œ˜Kš
œ(˜(Kš
œ"˜"Kš
œE˜EKš
œ2˜2Kš
œ`˜`Kšžœ
žœ	žœ>˜Qšžœ˜Kšœžœ.˜:Kšœžœ1˜@Kšœžœžœ7˜WKšžœ9˜=K˜—Kš
œ&˜&K˜—˜Kš
œ˜Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œI˜IKš
œ2˜2K˜—Kšžœžœ
˜—J˜—˜Jšœ!žœ
˜1šžœž˜"š
œ
˜
Kš
œ ˜ K˜—š
œ˜Kš
œ˜Kš
œO˜OKš
œ&˜&K˜—Kšžœžœ
˜—J˜—˜	Jšœ!žœ
˜1Jš
œ!˜!Jš
œ0˜0Jš
œ&˜&J˜—˜
Jšœ$žœ	˜0J˜—Jšžœžœ
˜—K˜K˜—šŸœžœžœ˜GK˜Kšœžœ˜)Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜FKšœžœ
žœ˜+Kšžœ
˜—Kš
œ˜K˜—šŸœžœ:žœ˜qKšœžœ	˜*Kšœžœ	˜*Kš
œ˜Kšœžœ
žœ˜*Kšœžœ
žœ˜*Kšœžœ
žœ
˜Kšœžœ˜&Kš
œ2˜2šžœ	žœ
ž˜Kšžœžœ
žœH˜aKšžœ
žœžœ
žœH˜fšžœ˜Kš
œ>˜>Kš
œC˜CK˜—Kš
œ˜K˜Kšžœ
˜—K˜K˜—šŸœžœ:žœ˜wKšœžœ	˜*Kšœžœ	˜*Kš
œ˜Kšœžœ
žœ˜*Kšœžœ
žœ˜*Kšœžœ
žœ
˜Kšœžœ˜&Kš
œ1˜1šžœ	žœ
ž˜Kšžœžœ
žœ*žœ˜WKšžœ
žœžœ
žœF˜dšžœ˜Kš
œC˜CKš
œA˜AK˜—Kš
œ˜K˜Kšžœ
˜—K˜K˜—šŸœžœBžœ˜yKš
œ×
™×
Kšœžœ˜)šžœžœ
žœ'žœžœ
ž˜KKšžœžœ
žœ/˜GKšžœ
˜—Kš
œ
˜
K˜K˜—šŸœžœ1˜KK™xšžœžœ˜Kš
œ˜Kš
œ$˜$K˜
—šžœ˜Kš
œ$˜$K˜—K˜K™—šŸœžœ'žœ"˜kKš
œN™NKšœžœ˜0šžœžœ
žœ'žœžœ
ž˜KKšžœžœ
žœ>˜VKšžœ
˜—K˜K˜—šŸœžœžœ"˜`K˜
K˜K˜Kš
œ2˜2š
œ,˜,Kš
œ
™
—šžœžœBžœž˜iKšœžœ*˜8Kš
œ,˜,Kšžœ
˜Kš
œ™—Kš
œ,˜,šžœOžœžœ
ž˜dKš
œ,˜,Kšžœ
˜—K˜K˜—šŸœžœžœ#˜Ušžœ
ž˜Kš
œ0˜0Kš
œ*˜*Kš
œ0˜0Kšžœ
˜—K˜K˜—šŸ
œžœžœ#˜Tšžœ
ž˜Kš
œ2˜2Kš
œ,˜,Kš
œ2˜2Kšžœ
˜—K˜K˜K˜—šŸœžœžœ#˜Všžœ
ž˜Kš
œ0˜0Kš
œ*˜*Kš
œ0˜0Kšžœ
˜—K˜K˜—šŸœžœžœžœ#˜gKš
œB˜BK˜K˜—š
Ÿœžœžœžœžœ˜pKš
œC˜CK˜K˜—šŸ
œžœ-žœžœ˜\šžœ
ž˜Kš
œ2˜2Kš
œ,˜,Kš
œ2˜2Kšžœ
˜—K˜K˜—šŸœžœ-žœžœ˜^šžœ
ž˜Kš
œ0˜0Kš
œ*˜*Kš
œ0˜0Kšžœ
˜—K˜K˜—K˜K™K™Kšœ	žœ˜*Kšœžœžœ˜-šœžœžœ˜"K˜K˜Kšœžœ
˜Kšœžœ
˜Kšœ
žœ
˜K˜Kš
œ˜K˜—Kšœžœžœ˜5šœžœžœ˜&Kšœžœ
žœ
˜Kš
œ]˜]Kš
œ˜K˜—Kšœžœžœ˜=šœžœžœ˜*Kšœžœ
žœ
˜Kš
œ\˜\Kš
œ˜K˜—š¢œžœ
žœžœ3˜}Kšœžœ˜/Kšœžœ
žœ˜*Kš
œ*˜*Kš
œ!˜!Kšœžœžœ
žœ
žœ
žœ)˜[KšœžœC˜UKšœžœG˜UK˜K˜—š¢œžœ
žœžœ;˜‰
Kšœžœ˜/Kšœžœ
žœ˜*Kš
œ.˜.Kš
œ%˜%Kšœžœžœ
žœ
žœ
žœ-˜_KšœžœG˜YKšœžœK˜]K˜K˜—š¢œžœ
žœ0žœ.˜‚
Kšœžœ˜9Kšœžœ
žœ˜&Kš
žœ
žœ
žœ
žœ	žœ˜+šžœ
žœ
ž˜
šžœžœ
žœ˜Kš
œ.˜.šžœ
žœžœ
ž
˜Kš
œ˜Kšžœ
˜K˜—Kšœ¡˜0K˜—Kšžœ
žœ
žœžœ
žœžœ
˜IKš
žœ
žœ
žœ
žœ	žœ˜+Kš
œ7˜7Kšžœ
˜—K˜K˜—š¢œžœ
žœ8žœ6˜–
Kšœžœ˜AKšœžœ
žœ˜&Kš
žœ
žœ
žœ
žœžœ˜2šžœ
žœ
ž˜
šžœžœ
žœ˜Kš
œ6˜6šžœ
žœžœ
ž
˜#Kš
œ˜Kšžœ
˜K˜—Kšœ¡˜0K˜—Kšžœ
žœ
žœžœ
žœžœ
˜IKš
žœ
žœ
žœ
žœžœ˜2Kš
œ;˜;Kšžœ
˜—K˜—K˜KšœžœC˜Vš œžœ:žœžœžœžœ
žœžœ˜¨
Kšœžœ˜+Kšœ
žœ
˜KšœDžœ
˜HKš
œ˜Kšœ
žœ
˜K˜Kš
œ˜Kš
œ˜K˜Kšœ
žœ
˜Kš
œ"˜"šžœžœ
žœ"žœžœ
ž˜FJš
œv˜všžœ
žœžœ˜-Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜J˜—Jšžœ
˜—šžœžœ
žœ"žœžœ
ž˜FJš
œi˜išžœ
žœžœ˜-Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜J˜—Jšžœ
˜—šžœ	žœ˜Jšžœ
ž˜š
œ˜šœžœ˜4Jš
œ<˜<—J˜—˜
šœžœ˜4Jš
œ3˜3—J˜—Jšžœžœ
˜J˜—K˜K˜K˜—šŸœžœ
žœ:žœžœžœžœ
žœžœ˜±
Kšœžœ˜+Kšœ
žœ
˜Kšœžœ
˜Kš
œ˜Kšœ
žœ
˜K˜Kš
œ˜K˜Kšœ
žœ
˜Kš
œ"˜"šžœžœ
žœ"žœžœ
ž˜FJš
œi˜išžœ
žœžœ˜-Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
žœ
˜J˜—Jšžœ
˜—šžœ	žœ˜šœžœ˜4Jš
œ3˜3—J˜—K˜—K™šŸœžœ
žœ)žœ
žœ
žœžœ˜�
Kš
œN™NJš
œ&˜&Kšœ
žœ
žœ˜Kšœžœ
˜Kš
œ˜Kšœžœ˜+K˜Jšœ	žœ
˜
Jš
œ˜šžœžœ
žœ"žœžœ
ž˜FJš
œ˜Jšžœžœ
žœ
žœ
˜Jš
œ,˜,šžœOžœžœ
ž˜dJš
œA˜Ašžœžœ
žœ žœžœ
ž˜DJšœ	žœ˜"Jšžœ
˜—Jš
œ$˜$Jšžœ
˜—J˜Jšžœ
˜—K˜K˜—š¢œžœ-žœ
žœ
žœžœ˜€
Jš
œ&˜&Kšœ
žœ
žœ˜Kšœžœ
˜Kš
œ˜Kšœžœ˜+K˜Jšœ	žœ
˜
Jš
œ˜šžœžœ
žœ"žœžœ
ž˜FJš
œ˜Jšžœžœ
žœ
žœ
˜Jš
œ,˜,šžœOžœžœ
ž˜dJš
œE˜Ešžœžœ
žœ žœžœ
ž˜DJšœ	žœ˜"Jšžœ
˜—Jšžœ
˜—Jš
œ$˜$Jšžœ
˜—K˜K˜—š¢œžœžœ
žœžœžœ
žœ˜gKš
œZ™ZKšœ!žœ
˜1Kš
œ"˜"šžœž˜"Kšœžœ
žœ˜#š
œ˜Kšœžœ˜$Kš
œ1˜1Kš
œD˜DK˜—Kšžœžœ
˜—K˜K˜—K™K˜š¢œžœ2žœ˜VKš
œD™DKšœžœ˜(šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ4˜LJšžœ
˜—K˜K˜—š¢œžœ%žœžœ˜_Kš
œ6™6Kšœžœ˜(šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ
žœ(˜GJšžœ
˜—Jšžœ8˜=K˜K˜—š¢œžœ=˜XKš
œ>™>Kšœžœ˜(šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ+˜CJšžœ
˜—K˜K˜—šŸœžœ*˜FK˜Kš
œ,˜,šžœOžœžœ
ž˜dKš
œ˜—Kšžœ
˜K˜K˜—š¢œžœ%žœ˜aKš
œ1™1Kšœžœ˜(šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ
žœ%˜DJšžœ
˜—Jšžœ8˜=K˜K˜—šŸœžœžœ˜OKš
œ>˜>Kš
œ.˜.Kšžœžœ
žœ˜"K˜K˜—šŸ¢œžœ*˜CKš
œ-™-Kš
œ˜K˜—š¢œžœžœ˜LKš
œ ™ Kš
œ˜K˜—K™K™K™šŸœžœ
žœžœžœžœ˜Š
Kš
œ„
™„
Kš
œ˜K˜Kšžœžœ
žœ
žœ
žœžœ˜9Kšœžœ˜Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜Fšžœžœ
žœ˜Jšžœžœ
žœ
žœ
žœžœ˜4šžœ˜Jš
œ˜Jš
œ˜Jš
œM˜MJ˜—J˜—Jšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ5žœžœžœžœ
žœ˜ñ
Kš
œ˜K˜Kšžœžœ
žœ
žœ
žœ	žœžœ˜BKšœžœ˜Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜Fšžœžœ
žœ˜Jšžœžœ
žœ
žœ
žœ	žœžœ
˜=šžœ˜Jš
œ˜Jš
œ˜Jš
œm˜mJ˜—J˜—Jšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ5žœžœžœžœ
žœ˜ê
Kšžœ-˜2K˜K˜—šŸœžœ
žœžœžœžœ˜ƒ
Kšžœ-˜2K˜K˜—š
Ÿœžœ
žœžœžœ˜nKš
œ„
™„
Kš
œ˜Kš
œ˜Kš
žœžœ
žœ
žœ
žœ˜(Kšœžœ˜Kšœžœ
˜šžœžœ
žœ"žœžœ
ž˜Fšžœžœ
žœ˜Jš
žœžœ
žœ
žœ
žœ˜#šžœ˜Jš
œ˜Jš
œ˜Jš
œ7˜7J˜—J˜—Jšžœ
˜—K˜K˜K˜—š
Ÿœžœ
žœžœžœ˜gKšžœ-˜2K˜K˜—šŸœžœ
žœ+žœ˜gKš
œ˜Kšœžœ˜&šžœžœ
žœ)žœžœ
ž˜MKš
žœžœ
žœžœ
žœ
˜GKšžœ
˜—Kšžœ
žœ˜K˜K˜—šŸœžœ#žœ˜eK˜Kšœžœ
žœ
˜Jš
œ$˜$Kš
œ.˜.Kš
œ6˜6Jš
œ"˜"šžœGžœžœ
ž˜]Jš
œ_˜_Jšžœ/žœ˜MJšžœ
˜—J˜J˜—šŸ	œžœ
žœ'žœ˜[K˜'Kš
œ˜Kšœžœ
žœ
˜Kš
œ˜Kš
œ,˜,Kš
œ:˜:šžœžœ
žœ&žœžœ
ž˜JJšžœžœ
žœ3žœ˜hšžœ˜Jš
œ&˜&Jš
œS˜SJ˜—Jšžœ
˜—K˜K˜—šŸœžœ
žœ žœ˜QK™*K™1Kš
œ%˜%Kšœ2žœ˜>Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ$žœ˜^K™%K˜Kš
œ˜Kš
œJ˜JKš
œ"˜"šžœGžœžœ
ž˜]Kš
œ ˜ Kšœ:žœ˜IKš
œ˜Kšžœ
˜—Kš
œ"˜"K˜K˜K˜—šŸœžœ,žœ˜eK™%K˜Kš
œ˜Kš
œ ˜ Kš
œ!˜!Kš
œI˜IKš
œ"˜"šžœGžœžœ
ž˜]šžœžœ˜Kšœ:žœ˜IKš
œ˜K˜
—šžœ˜Kš
œ ˜ Kšœ:žœ˜IKš
œ˜K˜—Kšžœ
˜—Kš
œ"˜"K˜K˜—šŸ
œžœ
žœžœ˜FKš
œ/™/Kš
œ˜K˜K˜—šŸœžœ
žœ%˜IKš
œ˜˜Jš
 ™—Kšœ8 œ˜=Jšœ! œ˜&šžœžœ
žœ˜Kšœžœ˜&šžœ=žœžœ
ž˜VJšžœžœ
žœ( œ˜FJšžœ
˜—J˜Jš
 ™—Kšœ8 œ˜@Jšœ! œ˜)šžœžœ
žœ˜Kšœžœ˜&šžœ=žœžœ
ž˜VJšžœžœ
žœ0˜IJšžœ
˜—J˜Jš
 ™—Kšœ8 œ˜@Jšœ! œ˜)šžœžœ
žœ˜Kšœžœ˜&šžœ
žœ
žœ,žœžœ
ž˜VJšžœžœ
žœ( œ˜IJšžœ
˜—J˜—J˜K˜—šŸœžœ
žœ<˜\Jš
œH˜HJšžœžœ
žœ(˜7Jšžœ+˜/J˜J˜—šŸœžœ.˜HJš
œ
˜
Jš
œ
˜
šžœžœ
žœž˜,Jš
œ#˜#Jšœžœ˜)šžœžœ
žœ)ž˜8Jšœžœ˜1Jšžœ
˜—Jšžœ
˜—šžœžœ
žœž˜*Jš
œ#˜#Jšœžœ˜)Jšžœ
˜—š
œ˜J˜——šŸœžœ
žœ<˜`Jš
œ-˜-J˜
J˜
šžœžœ
žœž˜,Jš
œ#˜#Jš
œ4˜4Jšžœžœ!˜8šžœžœ
žœ)ž˜8Jš
œD˜DJšžœžœ3˜RJšžœ
˜—Jšžœ
˜—šžœžœ
žœž˜*Jš
œ#˜#Jš
œ2˜2Jšžœžœ%˜:Jšžœ
˜—Jš
œ1˜1K˜K˜—šŸœžœ1˜NJ˜
J˜
šžœžœ
žœ!ž˜0Jš
œ'˜'Jš
œ3˜3šžœžœ
žœ)ž˜8Jš
œC˜CJšžœ
˜—Jšžœ
˜—šžœžœ
žœž˜.Jš
œ'˜'Jš
œ1˜1Jšžœ
˜—J˜J˜—šŸœžœ4˜QJš
œ$˜$Jš
œ"˜"šžœGžœžœ
ž˜]Jš
œ(˜(Jšžœ
˜—Jš
œ˜J˜—šŸœžœ
žœ%˜MK™Á
Jš
œ$˜$Jš
œ"˜"šžœGžœžœ
ž˜]Jš
 ™Jšœ% œ˜*Jš
 ™Jšœ% œ˜-Jš
 ™Jšœ% œ˜-Jšžœ
˜—K˜K˜—šŸœžœ
žœžœžœ
žœ˜eKšœžœ˜4Kšœžœ
žœ
˜Kš
œ/˜/šžœžœ
žœ)žœžœ
ž˜MJšžœžœ
žœB˜ZJšžœ
˜—K˜K˜—šŸ
œžœ
žœ.˜EK™&Kšœžœ˜4K˜šžœžœ
žœ)žœžœ
ž˜Mšžœžœ
žœžœ˜3J˜Jšžœ˜
J˜—š
ž˜˜	šœžœžœ˜FJš
œ{™{—J˜—Jšžœžœ
˜—Jšžœ
˜—K˜—K™šŸœžœžœ
žœžœžœ˜]Kšœ!žœ
˜1Kšœ	žœ
˜
Kš
œ˜Kšœžœ
˜
Kš
œ˜šžœž˜"˜
Kš
œ#˜#K˜—š
œ˜Kš
œ=˜=Kš
œ7˜7Kš
œ)˜)Kš
œ;˜;Kš
œ;˜;Kšžœ
žœ!˜1Kšžœ˜K˜—Kšžœžœ
˜—K˜K˜—šŸ
œžœ
žœžœ
žœžœ>žœ˜Œ
K™6Kšœ!žœ
˜1Kš
œ˜Kš
œ!˜!Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ#˜#K˜K˜—šŸœžœ
žœ"˜IK™2Kšœžœ˜-šžœžœ
žœ"žœžœ
ž˜FJšžœžœ
žœ'˜?Jšžœ
˜—K˜—K™Kšœ œ
™š
Ÿœžœ
žœžœžœ˜<Kšžœžœ˜$K˜K˜—šŸœžœ
žœžœ˜IKš
œ/™/Kš
œ˜K˜K˜—šŸœžœ
žœžœ˜TKš
œ&™&Kšœžœ
žœ˜+šœ
žœ˜"Kš
œ
˜
K˜—K˜K˜—šŸœžœ
žœžœ˜TKš
œ4™4Kšœžœ
žœ˜&šœ
žœ˜"Kš
œ
˜
K˜—K˜K˜—šŸœžœžœ˜<K˜K˜K˜—K˜!šŸœžœ˜K˜(K˜K˜—K˜K™šŸœžœžœ
žœžœ
žœ
žœ
˜TKšœžœ
žœ˜Kšœ	žœ
žœ˜K™(Kšžœ	žœ
žœ
žœ˜"Kšœ	žœžœ˜ Kš
œ
˜
šžœžœ
žœžœžœ
ž˜9Kšœ
žœ
žœ˜Kš
œ˜Kš
œ˜Kšžœ
˜—Kš
œ˜K˜K˜—K˜K˜Kšžœ
˜J˜—…—ÑŽ÷