DIRECTORY
PathEditor,
PEAlgebra USING [ClosestPointOnLineSegment, DistanceSquared],
PEBezier USING [Bezier, BezierToSegment, SegmentToBezier, SplitBezier],
PEConstraints USING [Constrain, ContinuousAt],
PEDisplay USING [DrawControlPoints, DrawSegment, DrawSegmentAndVertices, DrawVertex, DrawVertices],
PEFileOps USING [ReadTrajectoryFile, WriteTrajectoryFile],
PEHitTest USING [SegmentHitTest, TrajectoryHitTest, VertexHitTest],
PERefresh USING [CreateRefreshProcess, DestroyRefreshProcess, DisableSegmentRefresh, DisableTrajectoryRefresh, EnableSegmentRefresh, NewRefreshData, RefreshData, RequestRefresh],
PETrajectoryOps USING [FollowingVertex, ForAllSegments, ForAllTrajectories, ForAllVertices, FreeSegmentList, FreeTrajectoryList, InsertSegment, InsertTrajectory, InsertVertex, IsAKnot, IsAControlPoint, IsFirstSegment, IsLastSegment, LastSegmentNode, LastTrajectoryNode, LastVertexNode, PrecedingVertex, RemoveSegment, RemoveTrajectory, RemoveVertex, SegmentProc, SwapSegments, TrajectoryProc, VertexListAppend, VertexListLength, VertexListNthElement, VertexProc],
PETypes,
PEViewer USING [BuildViewer, ButtonProc, DrawInViewer, DrawProc, QuitProc, RedrawProc],
Rope USING [ROPE],
ViewerClasses USING [Viewer];

PathEditorImpl: CEDAR PROGRAM
IMPORTS PEAlgebra, PEBezier, PEConstraints, PEDisplay, PEFileOps, PEHitTest, PERefresh, PETrajectoryOps, PEViewer
EXPORTS PathEditor = 

BEGIN OPEN PathEditor, PEAlgebra, PEBezier, PEConstraints, PEDisplay, PEFileOps, PEHitTest, PERefresh, PETrajectoryOps, PETypes, PEViewer;

Handle: TYPE = REF PathEditorRec;
PathEditorRec: TYPE = RECORD [
refreshData: RefreshData _ NIL,				-- data for refresh process
buttonProc: ButtonHitProc _ NIL,				-- client's button procedure
redrawProc: DrawProc _ NIL,					-- client's redraw procedure
pathViewer: ViewerClasses.Viewer,			-- path editor viewer
trajectoryList: TrajectoryList _ NIL,			-- list of segments in the path
newTrajectory: BOOLEAN _ TRUE,			-- create a new trajectory?
activeTrajectory: TrajectoryNode _ NIL,		-- trajectory currently being manipulated
activeVertex: VertexNode _ NIL,				-- vertex currently being manipulated
activeSegment: SegmentNode _ NIL,			-- segment containing activeVertex
splitSegment: SegmentNode _ NIL,			-- segment being split by a vertex addition
splitReplacements: SegmentNode _ NIL,		-- replacement segments for segment being split
vertexHit: RECORD [							-- cache for hits in vertex hit testing
hitCached: BOOLEAN _ FALSE,
where: Point,
closeToVertex: BOOLEAN,
vertexType: VertexType,
vertex: Point
],
curveHit: RECORD [								-- cache for hits in curve hit testing
hitCached: BOOLEAN _ FALSE,
where: Point,
closeToCurve: BOOLEAN,
curveType: CurveType,
p0, p1, p2, p3: Point,
hitPoint: Point
]
];


CreatePathViewer: PUBLIC PROCEDURE [name: Rope.ROPE, menuLabels: LIST OF MenuLabel, buttonProc: ButtonHitProc _ NIL, redrawProc: DrawProc _ NIL] RETURNS [pathData: PathData] = {
handle: Handle_ NEW[PathEditorRec];
handle.buttonProc _ buttonProc;
handle.redrawProc _ redrawProc;
handle.pathViewer _ BuildViewer[
name: name,
menuLabels: menuLabels, 
clientData: handle,
redrawProc: DoRedraw, 
quitProc: Quit, 
buttonProc: ButtonHit ];
handle.refreshData _ CreateRefreshProcess[handle.pathViewer, handle.redrawProc];
pathData _ handle;
};

DoRedraw: RedrawProc = {
handle: Handle _ NARROW[clientData];
Redraw[pathData: clientData, erase: TRUE];
};

Quit: QuitProc = {
handle: Handle _ NARROW[clientData];
DestroyRefreshProcess[handle.refreshData];
FreeTrajectoryList[handle.trajectoryList];
};

ButtonHit: ButtonProc = {
handle: Handle _ NARROW[clientData];
IF handle.buttonProc # NIL THEN handle.buttonProc[event: event, x: x, y: y];
};

DrawInPathViewer: PUBLIC PROCEDURE [pathData: PathData, drawProc: DrawProc] = {
handle: Handle _ NARROW[pathData];
DrawInViewer[handle.pathViewer, drawProc];
};

Redraw: PUBLIC PROCEDURE [pathData: PathData, erase: BOOLEAN _ FALSE] = {
handle: Handle _ NARROW[pathData];
RequestRefresh[handle.refreshData, erase];
};

FlushImage: PUBLIC PROCEDURE [pathData: PathData] = {
handle: Handle _ NARROW[pathData];
DoDrawTrajectory: TrajectoryProc = {
DoDrawSegment: SegmentProc = {
DrawSegment[pathViewer: handle.pathViewer, segment: s.first, undo: TRUE];
IF t = handle.activeTrajectory THEN DrawVertices[pathViewer: handle.pathViewer, segment: s.first, undo: TRUE];
};
ForAllSegments[t.first.segments, DoDrawSegment];
};
ForAllTrajectories[handle.trajectoryList, DoDrawTrajectory];
FreeTrajectoryList[handle.trajectoryList];
handle.trajectoryList _ NIL;
NewTrajectory[pathData];
InvalidateHitCache[handle];
};

NewTrajectory: PUBLIC PROCEDURE [pathData: PathData] = {
handle: Handle _ NARROW[pathData];
handle.newTrajectory _ TRUE;
DoSetActiveTrajectory[handle, NIL];
};

SetActiveTrajectory: PUBLIC PROCEDURE [pathData: PathData, where: Point] RETURNS [activeTrajectorySet: BOOLEAN, hitPoint: Point] = {
handle: Handle _ NARROW[pathData];
hitTrajectory: TrajectoryNode;
[hitTrajectory, hitPoint] _ TrajectoryHitTest[handle.trajectoryList, where];
DoSetActiveTrajectory[handle, hitTrajectory];
activeTrajectorySet _ hitTrajectory # NIL;
};

DoSetActiveTrajectory: PROCEDURE [handle: Handle, activeTrajectory: TrajectoryNode] = {
DrawAsBackground: SegmentProc = {
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: s.first, undo: TRUE];
DrawSegment[pathViewer: handle.pathViewer, segment: s.first, background: TRUE];
};
DrawAsForeground: SegmentProc = {
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: s.first, background: FALSE];
};
DoSetActiveVertex[handle, NIL, NIL];
IF handle.activeTrajectory # activeTrajectory THEN {
NewRefreshData[handle.refreshData, handle.trajectoryList, activeTrajectory];
IF handle.activeTrajectory # NIL THEN 
ForAllSegments[handle.activeTrajectory.first.segments, DrawAsBackground];
handle.activeTrajectory _ activeTrajectory;
IF handle.activeTrajectory # NIL THEN 
ForAllSegments[handle.activeTrajectory.first.segments, DrawAsForeground];
RequestRefresh[handle.refreshData];
};
};

TrajectoryIsEmpty: PUBLIC PROCEDURE [pathData: PathData] RETURNS [empty: BOOLEAN] = {
handle: Handle _ NARROW[pathData];
RETURN [handle.activeTrajectory = NIL OR handle.activeTrajectory.first.segments = NIL];
};

DeleteActiveTrajectory: PUBLIC PROCEDURE [pathData: PathData] = {
handle: Handle _ NARROW[pathData];
UnDraw: SegmentProc = {
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: s.first, undo: TRUE];
};
DisableTrajectoryRefresh[handle.activeTrajectory.first];
ForAllSegments[handle.activeTrajectory.first.segments, UnDraw];
[handle.trajectoryList,] _ RemoveTrajectory[handle.trajectoryList, handle.activeTrajectory];
DoSetActiveTrajectory[handle, NIL];
};

GetTrajectoryFile: PUBLIC PROCEDURE [pathData: PathData, fileName: Rope.ROPE] = {
handle: Handle _ NARROW[pathData];
trajectories: TrajectoryList _ ReadTrajectoryFile[fileName];
t: TrajectoryNode _ LastTrajectoryNode[handle.trajectoryList];
IF t = NIL THEN handle.trajectoryList _ trajectories
ELSE {
t.rest _ trajectories;
IF trajectories # NIL THEN trajectories.preceding _ t;
};
DoSetActiveTrajectory[handle, NIL];
DoRequestRefresh[handle];
};

StoreTrajectoryFile: PUBLIC PROCEDURE [pathData: PathData, fileName: Rope.ROPE] = {
handle: Handle _ NARROW[pathData];
WriteTrajectoryFile[fileName, handle.trajectoryList];
};

EnumerateTrajectories: PUBLIC PROCEDURE [pathData: PathData, moveToProc: MoveToProc, lineToProc: LineToProc, curveToProc: CurveToProc] = {
handle: Handle _ NARROW[pathData];
EnumerateTrajectory: TrajectoryProc = {
handle.activeTrajectory _ t;
EnumerateActiveTrajectory[pathData, moveToProc, lineToProc, curveToProc];
};
saveActiveTrajectory: TrajectoryNode _ handle.activeTrajectory;
ForAllTrajectories[handle.trajectoryList, EnumerateTrajectory];
handle.activeTrajectory _ saveActiveTrajectory;
};

AddKnotToFront: PUBLIC PROCEDURE [pathData: PathData, position: Point] = {
handle: Handle _ NARROW[pathData];
knot: Vertex _ NEW[VertexRec _ [point: position]];
newSegment: Segment _ NEW[SegmentRec _ [type: moveTo]];
newTrajectory: Trajectory;
IF handle.activeTrajectory = NIL AND handle.newTrajectory THEN {
newTrajectory _ NEW[TrajectoryRec];
[handle.trajectoryList, handle.activeTrajectory] _ InsertTrajectory[handle.trajectoryList, newTrajectory, NIL];
handle.newTrajectory _ FALSE;
};
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.activeTrajectory.first.segments # NIL THEN {
DisableSegmentRefresh[handle.activeTrajectory.first.segments.first];
handle.activeTrajectory.first.segments.first.type _ curveTo;
};
[newSegment.vertices,] _ InsertVertex[newSegment.vertices, knot, NIL];
[handle.activeTrajectory.first.segments,] _ InsertSegment[handle.activeTrajectory.first.segments, newSegment, NIL];
Constrain[pathViewer: handle.pathViewer, vertex: handle.activeTrajectory.first.segments.first.vertices, segment: handle.activeTrajectory.first.segments, newPosition: position];
DoSetActiveVertex[handle, handle.activeTrajectory.first.segments.first.vertices, handle.activeTrajectory.first.segments];
InvalidateHitCache[handle];
};

AddCubicToFront: PUBLIC PROCEDURE [pathData: PathData, cp1, cp2, knot: Point] = {
handle: Handle _ NARROW[pathData];
knotVertex: Vertex _ NEW[VertexRec _ [point: knot]];
cp1Vertex: Vertex _ NEW[VertexRec _ [point: cp1]];
cp2Vertex: Vertex _ NEW[VertexRec _ [point: cp2]];
newSegment: Segment _ NEW[SegmentRec _ [type: moveTo]];
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.activeTrajectory.first.segments # NIL THEN {
DisableSegmentRefresh[handle.activeTrajectory.first.segments.first];
handle.activeTrajectory.first.segments.first.type _ curveTo;
[handle.activeTrajectory.first.segments.first.vertices,] _ InsertVertex[handle.activeTrajectory.first.segments.first.vertices, cp1Vertex, NIL];
[handle.activeTrajectory.first.segments.first.vertices,] _ InsertVertex[handle.activeTrajectory.first.segments.first.vertices, cp2Vertex, NIL];
DrawVertices[handle.pathViewer, handle.activeTrajectory.first.segments.first];
[newSegment.vertices,] _ InsertVertex[newSegment.vertices, knotVertex, NIL];
[handle.activeTrajectory.first.segments,] _ InsertSegment[handle.activeTrajectory.first.segments, newSegment, NIL];
Constrain[pathViewer: handle.pathViewer, vertex: handle.activeTrajectory.first.segments.rest.first.vertices.rest, segment: handle.activeTrajectory.first.segments.rest, newPosition: cp1];
EnableSegmentRefresh[handle.activeTrajectory.first.segments.rest.first];
};
DoSetActiveVertex[handle, NIL, NIL];
InvalidateHitCache[handle];
};

AddKnotToRear: PUBLIC PROCEDURE [pathData: PathData, position: Point] = {
handle: Handle _ NARROW[pathData];
knot: Vertex _ NEW[VertexRec _ [point: position]];
newSegment: Segment _ NEW[SegmentRec];
newSegmentNode: SegmentNode;
IF handle.activeTrajectory = NIL OR handle.activeTrajectory.first.segments = NIL THEN AddKnotToFront[pathData, position]
ELSE {
[newSegment.vertices,] _ InsertVertex[newSegment.vertices, knot, NIL];
[handle.activeTrajectory.first.segments, newSegmentNode] _ InsertSegment[handle.activeTrajectory.first.segments, newSegment, LastSegmentNode[handle.activeTrajectory.first.segments]];
Constrain[pathViewer: handle.pathViewer, vertex: newSegment.vertices, segment: newSegmentNode, newPosition: position];
DoSetActiveVertex[handle, newSegment.vertices, newSegmentNode];
InvalidateHitCache[handle];
};
};

AddCubicToRear: PUBLIC PROCEDURE [pathData: PathData, cp1, cp2, knot: Point] = {
handle: Handle _ NARROW[pathData];
knotVertex: Vertex _ NEW[VertexRec _ [point: knot]];
cp1Vertex: Vertex _ NEW[VertexRec _ [point: cp1]];
cp2Vertex: Vertex _ NEW[VertexRec _ [point: cp2]];
newSegment: Segment _ NEW[SegmentRec _ [type: moveTo]];
newSegmentNode: SegmentNode;
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.activeTrajectory.first.segments # NIL THEN {
[newSegment.vertices,] _ InsertVertex[newSegment.vertices, knotVertex, NIL];
[newSegment.vertices,] _ InsertVertex[newSegment.vertices, cp2Vertex, NIL];
[newSegment.vertices,] _ InsertVertex[newSegment.vertices, cp1Vertex, NIL];
DrawVertices[handle.pathViewer, newSegment];
[handle.activeTrajectory.first.segments, newSegmentNode] _ InsertSegment[handle.activeTrajectory.first.segments, newSegment, LastSegmentNode[handle.activeTrajectory.first.segments]];
Constrain[pathViewer: handle.pathViewer, vertex: newSegment.vertices, segment: newSegmentNode, newPosition: cp1];
};
DoSetActiveVertex[handle, NIL, NIL];
InvalidateHitCache[handle];
};

SplitSegment: PUBLIC PROCEDURE [pathData: PathData, where: Point] = {
handle: Handle _ NARROW[pathData];
segment: SegmentNode;
point: Point;
t: REAL;
originalBezier: Bezier;
b1, b2: Bezier;
IF handle.activeTrajectory = NIL THEN RETURN;
[segment, point, t] _ SegmentHitTest[handle.activeTrajectory.first.segments, where];
originalBezier _ SegmentToBezier[segment.first];
[b1, b2] _ SplitBezier[originalBezier, t];
[handle.splitReplacements,] _ InsertSegment[NIL, BezierToSegment[b1], NIL];
handle.splitReplacements.first.fp _ segment.first.fp;
[handle.splitReplacements,] _ InsertSegment[handle.splitReplacements, BezierToSegment[b2], handle.splitReplacements];
handle.splitReplacements.rest.first.fp _ VertexListNthElement[handle.splitReplacements.first.vertices, -1];
handle.splitReplacements.rest.first.fp.fixed _ TRUE;
DisableSegmentRefresh[handle.splitReplacements.first];
DisableSegmentRefresh[handle.splitReplacements.rest.first];
[handle.activeTrajectory.first.segments, handle.splitSegment] _ SwapSegments[handle.activeTrajectory.first.segments, handle.splitReplacements, segment];
DrawControlPoints[pathViewer: handle.pathViewer, segment: segment.first, undo: TRUE];
DrawVertices[pathViewer: handle.pathViewer, segment: handle.splitReplacements.first];
DrawControlPoints[pathViewer: handle.pathViewer, segment: handle.splitReplacements.rest.first];
DoSetActiveVertex[handle, NIL, NIL];
InvalidateHitCache[handle];
};

AdjustSegmentSplit: PUBLIC PROCEDURE [pathData: PathData, where: Point] = {
handle: Handle _ NARROW[pathData];
hitSegment: SegmentNode;
hitPoint: Point;
hitT: REAL;
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.splitSegment # NIL THEN {
[handle.activeTrajectory.first.segments, handle.splitReplacements] _ SwapSegments[handle.activeTrajectory.first.segments, handle.splitSegment, handle.splitReplacements, 2];
DrawVertices[pathViewer: handle.pathViewer, segment: handle.splitReplacements.first, undo: TRUE];
DrawControlPoints[pathViewer: handle.pathViewer, segment: handle.splitReplacements.rest.first, undo: TRUE];
DrawSegment[pathViewer: handle.pathViewer, segment: handle.splitSegment.first];
};
[hitSegment, hitPoint, hitT] _ SegmentHitTest[handle.activeTrajectory.first.segments, where];
IF handle.splitSegment # NIL THEN {
IF hitSegment # handle.splitSegment THEN {
DrawVertices[pathViewer: handle.pathViewer, segment: handle.splitReplacements.first, undo: TRUE];
DrawControlPoints[pathViewer: handle.pathViewer, segment: handle.splitReplacements.rest.first, undo: TRUE];
DrawControlPoints[pathViewer: handle.pathViewer, segment: handle.splitSegment.first];
EnableSegmentRefresh[segment: handle.splitSegment.first];
};
FreeSegmentList[handle.splitReplacements];
handle.splitReplacements _ NIL;
};
IF hitSegment = NIL THEN handle.splitSegment _ NIL
ELSE SplitSegment[pathData: pathData, where: where];
DoRequestRefresh[handle];
DoSetActiveVertex[handle, NIL, NIL];
InvalidateHitCache[handle];
};

ConfirmSegmentSplit: PUBLIC PROCEDURE[pathData: PathData] = {
handle: Handle _ NARROW[pathData];
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.splitSegment # NIL THEN {
DrawSegment[pathViewer: handle.pathViewer, segment: handle.splitSegment.first, undo: TRUE];
FreeSegmentList[handle.splitSegment];
handle.splitSegment _ NIL;
DrawSegment[pathViewer: handle.pathViewer, segment: handle.splitReplacements.first];
DrawSegment[pathViewer: handle.pathViewer, segment: handle.splitReplacements.rest.first];
EnableSegmentRefresh[handle.splitReplacements.first];
EnableSegmentRefresh[handle.splitReplacements.rest.first];
};
InvalidateHitCache[handle];
};

AddControlPoint: PUBLIC PROCEDURE [pathData: PathData, where, position: Point] = {
handle: Handle _ NARROW[pathData];
vertex: Vertex _ NEW[VertexRec _ [point: position]];
newVertexNode: VertexNode _ NIL;
hitSegment: SegmentNode;
hitPoint: Point;
hitT: REAL;
numberVertices, maxNumberVertices: CARDINAL;
segmentFull: BOOLEAN;
precedingVertex: VertexNode;
d0, d1: REAL;
IF handle.activeTrajectory = NIL THEN RETURN;
[hitSegment, hitPoint, hitT] _ SegmentHitTest[handle.activeTrajectory.first.segments, where];
IF hitSegment # NIL THEN {
numberVertices _ VertexListLength[hitSegment.first.vertices];
maxNumberVertices _ SELECT hitSegment.first.type FROM
moveTo => 1,
curveTo => 3,
ENDCASE => 0;
segmentFull _ numberVertices >= maxNumberVertices;
IF ~segmentFull THEN {
DrawSegment[pathViewer: handle.pathViewer, segment: hitSegment.first, undo: TRUE];
IF numberVertices < 2 THEN precedingVertex _ NIL
ELSE {
d0 _ DistanceSquared[where, ClosestPointOnLineSegment[point: where, p0: hitSegment.first.fp.point, p1: hitSegment.first.vertices.first.point]];
d1 _ DistanceSquared[where, ClosestPointOnLineSegment[point: where, p0: hitSegment.first.vertices.first.point, p1: hitSegment.first.vertices.rest.first.point]];
precedingVertex _ IF d0 < d1 THEN NIL ELSE hitSegment.first.vertices;
};
[hitSegment.first.vertices, newVertexNode] _ InsertVertex[hitSegment.first.vertices, vertex, precedingVertex];
Constrain[pathViewer: handle.pathViewer, vertex: newVertexNode, segment: hitSegment, newPosition: position];
InvalidateHitCache[handle];
};
};
DoSetActiveVertex[handle, newVertexNode, hitSegment];
};

CloseActiveTrajectory: PUBLIC PROCEDURE [pathData: PathData] = {
handle: Handle _ NARROW[pathData];
fp: VertexNode;
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.activeTrajectory.first.segments.first.type = moveTo THEN {
handle.activeTrajectory.first.segments.first.type _ curveTo;
[fp,] _ PrecedingVertex[handle.activeTrajectory.first.segments.first.vertices, handle.activeTrajectory.first.segments];
handle.activeTrajectory.first.segments.first.fp _ IF fp # NIL THEN fp.first ELSE NIL;
DrawSegment[pathViewer: handle.pathViewer, segment: handle.activeTrajectory.first.segments.first];
};
DoSetActiveVertex[handle, NIL, NIL];
};

OpenActiveTrajectory: PUBLIC PROCEDURE [pathData: PathData] = {
handle: Handle _ NARROW[pathData];
lastVertex: VertexNode;
DoDeleteVertex: VertexProc = {
IF v # lastVertex THEN {
DrawVertex[pathViewer: handle.pathViewer, vertex: v.first, undo: TRUE];
[handle.activeTrajectory.first.segments.first.vertices,] _ RemoveVertex[handle.activeTrajectory.first.segments.first.vertices, v];
};
};
IF handle.activeTrajectory = NIL THEN RETURN;
IF handle.activeTrajectory.first.segments.first.type # moveTo THEN {
DrawSegment[pathViewer: handle.pathViewer, segment: handle.activeTrajectory.first.segments.first, undo: TRUE];
lastVertex _ LastVertexNode[handle.activeTrajectory.first.segments.first.vertices];
ForAllVertices[handle.activeTrajectory.first.segments.first.vertices, DoDeleteVertex];
handle.activeTrajectory.first.segments.first.type _ moveTo;
handle.activeTrajectory.first.segments.first.fp _ NIL;
};
DoSetActiveVertex[handle, NIL, NIL];
};

DeleteVertex: PUBLIC PROCEDURE [pathData: PathData, vertex: Point] = {
handle: Handle _ NARROW[pathData];
closestVertex, pVertex, fVertex: VertexNode;
closestSegment, pSegment, fSegment: SegmentNode;
IF handle.activeTrajectory = NIL THEN RETURN;
[closestVertex, closestSegment] _ VertexHitTest[handle.activeTrajectory.first.segments, vertex];
[pVertex, pSegment] _ PrecedingVertex[closestVertex, closestSegment];
[fVertex, fSegment] _ FollowingVertex[closestVertex, closestSegment];
IF closestVertex # NIL THEN {
IF IsAControlPoint[closestVertex] THEN {
DisableSegmentRefresh[segment: closestSegment.first];
DrawVertex[pathViewer: handle.pathViewer, vertex: closestVertex.first, undo: TRUE];
DrawSegment[pathViewer: handle.pathViewer, segment: closestSegment.first, undo: TRUE];
[closestSegment.first.vertices,] _ RemoveVertex[closestSegment.first.vertices, closestVertex];
DrawSegment[pathViewer: handle.pathViewer, segment: closestSegment.first];
EnableSegmentRefresh[segment: closestSegment.first];
}
ELSE {
SELECT TRUE FROM
closestSegment.rest = closestSegment => {
DisableSegmentRefresh[segment: closestSegment.first];
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: closestSegment.first, undo: TRUE];
[handle.activeTrajectory.first.segments,] _ RemoveSegment[handle.activeTrajectory.first.segments, closestSegment]
};
IsFirstSegment[closestSegment] => {
DisableSegmentRefresh[segment: closestSegment.first];
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: closestSegment.first, undo: TRUE];
IF IsLastSegment[closestSegment] THEN 
[handle.activeTrajectory.first.segments,] _ RemoveSegment[handle.activeTrajectory.first.segments, closestSegment]
ELSE {
DisableSegmentRefresh[segment: closestSegment.rest.first];
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: closestSegment.rest.first, undo: TRUE];
closestSegment.first.vertices.first^ _ LastVertexNode[closestSegment.rest.first.vertices].first^;
[handle.activeTrajectory.first.segments,] _ RemoveSegment[handle.activeTrajectory.first.segments, closestSegment.rest];
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: closestSegment.first];
EnableSegmentRefresh[segment: closestSegment.first];
};
};
IsLastSegment[closestSegment] => {
DisableSegmentRefresh[segment: closestSegment.first];
DrawSegmentAndVertices[pathViewer: handle.pathViewer, segment: closestSegment.first, undo: TRUE];
[handle.activeTrajectory.first.segments,] _ RemoveSegment[handle.activeTrajectory.first.segments, closestSegment];
};
ENDCASE => MergeSegments[handle: handle, segmentNode: closestSegment];
};
IF TrajectoryIsEmpty[pathData] THEN {
DeleteActiveTrajectory[pathData];
NewTrajectory[pathData];
};
IF ContinuousAt[pVertex, pSegment] THEN Constrain[handle.pathViewer, pVertex, pSegment, pVertex.first.point];
IF ContinuousAt[fVertex, fSegment] THEN Constrain[handle.pathViewer, fVertex, fSegment, fVertex.first.point];
DoRequestRefresh[handle];
};
DoSetActiveVertex[handle, NIL, NIL];
InvalidateHitCache[handle];
};

MergeSegments: PROCEDURE [handle: Handle, segmentNode: SegmentNode] = {
DeleteVertex: VertexProc = {
DrawVertex[pathViewer: handle.pathViewer, vertex: v.first, undo: TRUE];
[segmentNode.first.vertices,] _ RemoveVertex[segmentNode.first.vertices, v];
};
vertexNode: VertexNode;
vertexList: VertexList;
IF IsLastSegment[segmentNode] THEN RETURN;
DisableSegmentRefresh[segment: segmentNode.first];
DisableSegmentRefresh[segment: segmentNode.rest.first];
DrawSegment[pathViewer: handle.pathViewer, segment: segmentNode.first, undo: TRUE];
DrawSegment[pathViewer: handle.pathViewer, segment: segmentNode.rest.first, undo: TRUE];
vertexNode _ segmentNode.first.vertices;
IF vertexNode.rest # NIL THEN vertexNode _ vertexNode.rest;
ForAllVertices[vertexNode, DeleteVertex];
vertexList _ segmentNode.rest.first.vertices;
segmentNode.rest.first.vertices _ NIL;
IF VertexListLength[vertexList] > 2 THEN {
DrawVertex[pathViewer: handle.pathViewer, vertex: vertexList.first, undo: TRUE];
[vertexList,] _ RemoveVertex[vertexList, vertexList];
};
segmentNode.first.vertices _ VertexListAppend[segmentNode.first.vertices, vertexList];
[handle.activeTrajectory.first.segments,] _ RemoveSegment[handle.activeTrajectory.first.segments, segmentNode.rest];
DrawSegment[pathViewer: handle.pathViewer, segment: segmentNode.first];
EnableSegmentRefresh[segment: segmentNode.first];
};

SetActiveVertex: PUBLIC PROCEDURE [pathData: PathData, where: Point] RETURNS [activeVertexSet: BOOLEAN, vertex: Point] = {
handle: Handle _ NARROW[pathData];
activeVertex: VertexNode;
activeSegment: SegmentNode;
IF handle.activeTrajectory = NIL THEN activeVertex _ NIL
ELSE [activeVertex, activeSegment] _ VertexHitTest[handle.activeTrajectory.first.segments, where];
DoSetActiveVertex[handle, activeVertex, activeSegment];
activeVertexSet _ activeVertex # NIL;
IF activeVertexSet THEN vertex _ activeVertex.first.point;
};

DoSetActiveVertex: PROCEDURE [handle: Handle, activeVertex: VertexNode, activeSegment: SegmentNode] = {
IF activeVertex = NIL THEN {
handle.activeVertex _ NIL;
handle.activeSegment _ NIL;
}
ELSE {
handle.activeVertex _ activeVertex;
handle.activeSegment _ activeSegment;
};
};

GetActiveVertex: PUBLIC PROCEDURE [pathData: PathData] RETURNS [activeVertexSet: BOOLEAN, vertex: Point] = {
handle: Handle _ NARROW[pathData];
activeVertexSet _ handle.activeVertex # NIL;
IF activeVertexSet THEN vertex _ handle.activeVertex.first.point;
};

MoveActiveVertex: PUBLIC PROCEDURE [pathData: PathData, newPosition: Point] = {
handle: Handle _ NARROW[pathData];
IF handle.activeVertex # NIL THEN {
Constrain[pathViewer: handle.pathViewer, vertex: handle.activeVertex, segment: handle.activeSegment, newPosition: newPosition];
DoRequestRefresh[handle];
};
InvalidateHitCache[handle];
};

SetContinuity: PUBLIC PROCEDURE [pathData: PathData, knot: Point, continuity: BooleanSpecification] = {
handle: Handle _ NARROW[pathData];
hitVertex: VertexNode;
hitSegment: SegmentNode;
IF handle.activeTrajectory = NIL THEN RETURN;
[hitVertex, hitSegment] _ VertexHitTest[handle.activeTrajectory.first.segments, knot];
IF IsAKnot[hitVertex] THEN {
DisableSegmentRefresh[hitSegment.first];
DrawVertex[pathViewer: handle.pathViewer, vertex: hitVertex.first, undo: TRUE];
SELECT continuity FROM
on => hitVertex.first.fixed _ TRUE;
off => hitVertex.first.fixed _ FALSE;
toggle => hitVertex.first.fixed _ ~hitVertex.first.fixed;
ENDCASE;
DrawVertex[pathViewer: handle.pathViewer, vertex: hitVertex.first];
IF ContinuousAt[hitVertex, hitSegment] THEN Constrain[pathViewer: handle.pathViewer, vertex: hitVertex, segment: hitSegment, newPosition: hitVertex.first.point];
EnableSegmentRefresh[hitSegment.first];
};
};

SetTrajectoryContinuity: PUBLIC PROCEDURE [pathData: PathData, continuity: BooleanSpecification] = {
MoveTo: MoveToProc = {};
LineTo: LineToProc = {SetContinuity[pathData, p1, continuity]};
CurveTo: CurveToProc = {SetContinuity[pathData, p3, continuity]};
EnumerateActiveTrajectory[pathData: pathData, moveToProc: MoveTo, lineToProc: LineTo, curveToProc: CurveTo];
};

FixControlPoint: PUBLIC PROCEDURE [pathData: PathData, controlPoint: Point, fixed: BooleanSpecification] = {
handle: Handle _ NARROW[pathData];
hitVertex: VertexNode;
hitSegment: SegmentNode;
IF handle.activeTrajectory = NIL THEN RETURN;
[hitVertex, hitSegment] _ VertexHitTest[handle.activeTrajectory.first.segments, controlPoint];
IF hitVertex # NIL AND ~IsAKnot[hitVertex] THEN {
DisableSegmentRefresh[hitSegment.first];
DrawVertex[pathViewer: handle.pathViewer, vertex: hitVertex.first, undo: TRUE];
SELECT fixed FROM
on => hitVertex.first.fixed _ TRUE;
off => hitVertex.first.fixed _ FALSE;
toggle => hitVertex.first.fixed _ ~hitVertex.first.fixed;
ENDCASE;
DrawVertex[pathViewer: handle.pathViewer, vertex: hitVertex.first];
EnableSegmentRefresh[hitSegment.first];
};
};

EnumerateActiveTrajectory: PUBLIC PROCEDURE [pathData: PathData, moveToProc: MoveToProc, lineToProc: LineToProc, curveToProc: CurveToProc] = {
handle: Handle _ NARROW[pathData];
EnumerateSegment: SegmentProc = {
numberVertices: CARDINAL;
numberVertices _ VertexListLength[s.first.vertices];
SELECT TRUE FROM
s.first.type = moveTo => moveToProc[p1: s.first.vertices.first.point];
numberVertices = 1 => lineToProc[p1: s.first.vertices.first.point];
numberVertices = 2 => curveToProc[p1: s.first.vertices.first.point, p2: s.first.vertices.first.point, p3: s.first.vertices.rest.first.point];
numberVertices = 3 => curveToProc[p1: s.first.vertices.first.point, p2: s.first.vertices.rest.first.point, p3: s.first.vertices.rest.rest.first.point];
ENDCASE;
};
IF handle.activeTrajectory = NIL THEN RETURN;
ForAllSegments[handle.activeTrajectory.first.segments, EnumerateSegment];
};

HitTestVertices: PUBLIC PROCEDURE [pathData: PathData, where: Point] RETURNS [closeToVertex: BOOLEAN, vertexType: VertexType, vertex: Point] = {
handle: Handle _ NARROW[pathData];
hitVertex: VertexNode;
hitSegment: SegmentNode;
IF handle.vertexHit.hitCached AND where = handle.vertexHit.where THEN {
closeToVertex _ handle.vertexHit.closeToVertex;
IF closeToVertex THEN {
vertexType _ handle.vertexHit.vertexType;
vertex _ handle.vertexHit.vertex;
};
}
ELSE {
IF handle.activeTrajectory = NIL THEN hitVertex _ NIL
ELSE [hitVertex, hitSegment] _ VertexHitTest[handle.activeTrajectory.first.segments, where];
closeToVertex _ hitVertex # NIL;
IF closeToVertex THEN {
vertex _ hitVertex.first.point;
vertexType _ SELECT TRUE FROM
IsAKnot[hitVertex] AND IsFirstSegment[hitSegment] => frontKnot,
IsAKnot[hitVertex] AND IsLastSegment[hitSegment] => rearKnot,
IsAKnot[hitVertex] => intermediateKnot,
ENDCASE => controlPoint;
};
handle.vertexHit.hitCached _ TRUE;
handle.vertexHit.closeToVertex _ closeToVertex;
IF closeToVertex THEN {
handle.vertexHit.vertexType _ vertexType;
handle.vertexHit.vertex _ vertex;
};
};
};

HitTestCurves: PUBLIC PROCEDURE [pathData: PathData, where: Point] RETURNS [closeToCurve: BOOLEAN, curveType: CurveType, p0, p1, p2, p3: Point, hitPoint: Point] = {
handle: Handle _ NARROW[pathData];
hitT: REAL;
hitSegment: SegmentNode;
numberVertices: CARDINAL;
bezier: Bezier;
IF handle.curveHit.hitCached AND where = handle.curveHit.where THEN {
closeToCurve _ handle.curveHit.closeToCurve;
IF closeToCurve THEN {
curveType _ handle.curveHit.curveType;
p0 _ handle.curveHit.p0;
p1 _ handle.curveHit.p1;
p2 _ handle.curveHit.p2;
p3 _ handle.curveHit.p3;
hitPoint _ handle.curveHit.hitPoint;
};
}
ELSE {
IF handle.activeTrajectory = NIL THEN hitSegment _ NIL
ELSE [hitSegment, hitPoint, hitT] _ SegmentHitTest[handle.activeTrajectory.first.segments, where];
closeToCurve _ hitSegment # NIL;
IF closeToCurve THEN {
numberVertices _ VertexListLength[hitSegment.first.vertices];
bezier _ SegmentToBezier[hitSegment.first];
p0 _ bezier.b0;
p1 _ bezier.b1;
p2 _ bezier.b2;
p3 _ bezier.b3;
curveType _ SELECT numberVertices FROM
0 => point,
1 => line,
ENDCASE => bezier;
IF curveType = line THEN p1 _ bezier.b3;
};
handle.curveHit.hitCached _ TRUE;
handle.curveHit.closeToCurve _ closeToCurve;
IF closeToCurve THEN {
handle.curveHit.curveType _ curveType;
handle.curveHit.p0 _ p0;
handle.curveHit.p1 _ p1;
handle.curveHit.p2 _ p2;
handle.curveHit.p3 _ p3;
handle.curveHit.hitPoint _ hitPoint;
};
};
};

InvalidateHitCache: PROCEDURE [handle: Handle] = {
handle.vertexHit.hitCached _ FALSE;
handle.curveHit.hitCached _ FALSE;
};

DoRequestRefresh: PROCEDURE [handle: Handle] = {
NewRefreshData[handle.refreshData, handle.trajectoryList, handle.activeTrajectory];
RequestRefresh[handle.refreshData];
};

END.
%|PathEditorImpl.mesa
Written by Darlene Plebon on August 31, 1983 11:24 am
Last Edited by: Spreitzer, May 29, 1985 12:12:02 pm PDT

Routines providing a client interface to the Path Editor.
Routines which operate on the entire image.
This routine creates a viewer for the Path Editor.  The viewer is created with the supplied name and menu labels.  Client supplied routines are called to process button hits and when the entire viewer must be redrawn for some reason.  This routine must be called before any others.  It returns a pointer to Path Editor data which must be passed in all subsequent calls from the client.
This routine handles re-draw requests from the PEViewer package.
This routine cleans up upon program termination.
Break all the back links.
This routine handles menu and mouse button hits in the Path Editor viewer.
This routine calls the client supplied routine with the Path Editor viewer's context so it can draw in the Path Editor's viewer.
This routine redraws the entire image.  The viewer may be erased first, if desired.
This routine flushes the contents of the image, so the client can start over.
Routines which operate on entire trajectories.

This routine creates a new trajectory and makes it the active trajectory.  The trajectory is not actually created until an operation is performed which gives it some contents (e.g. AddKnotToFront).  That is this routine indicates the intent to start a new trajectory.
This routine makes the trajectory which is closest to the specified point the active trajectory.  A trajectory must be made active before its contents can be edited.  When a trajectory is first set active, the active vertex or active segment are unset (i.e. NIL).  The specified position must be "close to" (i.e. whithin a certain minimum distance of) a trajectory in order for the operation to be carried out.  This routine returns an indication of whether the active trajectory was in fact set and the position of the point on the active trajectory which is closest to the specified point.
This routine sets the active trajectory to be the specified trajectory node.  This routine also unsets the active vertex and active segment (i.e. sets them to NIL).
This routine determines if the active trajectory currently has any contents.
This routine deletes the active trajectory.
This routine reads the specified trajectory file into the path editor.  The trajectories read in are appended to those already in the image.
This routine writes a text representation of the trajectories in the path editor to a file.
This routine enumerates all the segments in the all the trajectories.  Client specified routines are called for each line segment, and bezier curve in each trajectory.  The moveToProc is called for the first point (FP) of each trajectory.
Routines which operate on (the contents of) the active trajectory.

This routine extends the active trajectory by adding a knot (and thus a segment) to its front end.
This routine adds a cubic curve segment to the front of the active trajectory.  The cubic is defined by the bezier vertices: knot, cp2, cp1, FP, where FP is the first knot in the original path.
This routine extends the active trajectory by adding a knot (and thus a segment) to its rear end.
This routine adds a cubic curve segment to the rear (end) of the active trajectory.  The cubic is defined by the bezier vertices: LP, cp1, cp2, knot, where LP is the last knot in the original path.
This routine splits the segment in the active trajectory which is nearest the specified position at the point which is closest to the specified position.  The specified position must be "close to" (i.e. whithin a certain minimum distance of) a segment of the active trajectory in order for the operation to be carried out.  This routine also updates the display to reflect the two new segments and saves appropriate information for reversing the action.  A call to this routine may be followed by zero or more calls to AdjustSegmentSplit.  Finally, ConfirmSegmentSplit must be called to clean up the display.
This routine moves the knot at which a bezier segment is split into two segments.
This routine confirms a segment split.  That is, it makes it permanent.  This routine basically cleans up the display a bit.
This routine adds a control point to the specified segment  (the segment in the active trajectory which is closest to "where").  Position specifies the position of the new control point.  If the segment already contained one control point, the new control point is added before or after the current one depending on the the distance from "where" to the line segments defined by the existing control point and the two knots of the segment.  If "where" is closer to the line segment defined by the existing control point and the first knot, the new control point is inserted before the existing one; otherwise it is inserted following the existing control point in the segment.  If the segment already contains two control points, no action is performed.
This routine makes the active trajectory a closed trajectory.
This routine makes the active trajectory an open trajectory.
This routine deletes the vertex (which may be a knot or a control point) in the active trajectory which is closest to the specified point.  The specified point must be "close to" (i.e. whithin a certain minimum distance of) a vertex in the active trajectory in order for the operation to be carried out.
This routine merges the specified segment with the one following it in the segment list, deleting the common knot and the control points surrounding the common knot.  The second of the two segments is the one which is actually removed from the segment list.  If no segment follows the specified segment in the segment list, then no action is performed by this routine.
This routine makes the vertex of the active trajectory which is closest to the specified point the active vertex.  A vertex must be made active before it can be moved.  The specified position must be "close to" (i.e. whithin a certain minimum distance of) a segment in the active trajectory in order for the operation to be carried out.  This routine returns an indication of whether the active vertex was in fact set and the position of the active vertex.  The routines for adding knots and control points also set the active vertex.  The NewImage, DeleteVertex and AddCubic routines unset the active vertex.
This routine sets up all of the information necessary for moving a vertex around.  activeVertex is the vertex to be moved around. activeSegment is the first segment containing activeVertex.
This routine returns an indication of whether the active vertex is set and the position of the active vertex.
This routine moves the active vertex (which may be a knot or a control point) closest to the specified point to the specfied new position.
This routine sets the continuity requirements at the vertex in the active trajectory which is closest to the specified location.  The specified point (knot) must be "close to" (i.e. within a certain minimum distance of) a vertex in the active trajectory in order for the operation to be carried out.  This operation only applies to knots.  The client can specify that continuity is required (on), that continuity is not required (off), or that the current continuity requirement setting is to be toggled.  When continuity is requested, the positions of some vertices may be altered to satisfy the request.
This routine sets the continuity requirements at each knot in the active trajectory.
This routine sets the indicator of whether the vertex in the active trajectory which is closest to the specified location is fixed (i.e. may not be moved unless explicitly requested by the client) or not fixed (i.e. may be moved without a client request in order to satisfy continuity requirements at some other vertex).  The specified point (knot) must be "close to" (i.e. within a certain minimum distance of) a vertex in the active trajectory in order for the operation to be carried out.  This operation only applies to control points.  The client can specify that the vertex be fixed (on), that the vertex can be moved (off), of that the current setting is to be toggled.
This routine enumerates all the segments in the active trajectory.  Client specified routines are called for each line segment, and bezier curve in the trajectory.  The moveToProc is called for the first point (FP) of the active trajectory.
This routine determines the vertex in the active trajectory which is closest to the specified point.  Only those vertices which are in the active trajectory and within a threshold distance of the point are considered.  This routine returns an indication of whether the point is close to a vertex, and if so, the position of the closest vertex and its type.
This routine determines the curve segment  in the active trajectory which is closest to the specified point.  Only those segments which are in the active trajectory and within a threshold distance of the point are considered.  This routine returns an indication of whether the point is close to a curve segment, and if so, the position of the vertices of the segment, its type, and the point on the curve closest to the specified point.
This routine invalidates the contents of the vertex and curve hit caches.  This routine is called whenever an operation is performed which may cause the contents to be out of date and inaccurate.
This routine requests that the image be refreshed, after updating the information the refresh process requires about the image.

Κν–

"Cedar" style˜Iproc–

"Cedar" styleš
œ™K–

"Cedar" styleš
œ5™5J™7J™J™9J˜š
Οk	˜	J˜Jšœ
œ.˜=Jšœ	œ9˜GJšœœ˜.Jšœ
œT˜cJšœ
œ+˜:Jšœ
œ4˜CJšœ
œ£
˜²
JšœœΊ˜ΟJš
œ˜Jšœ	œI˜WJšœœœ˜Jšœœ
˜—J˜šœœ
˜Jšœj˜qJšœ˜—J˜Jšœ
œ€
˜Š
J˜Jšœœœ˜!šœœœ˜KšœœΟc˜>Kšœœž˜@Kšœœž˜<Kšœ$ž˜9Kšœ!œž˜GKšœœœž˜<Kšœ#œž)˜RKšœœž%˜HKšœœž"˜FKšœœž+˜NKšœ!œž/˜Všœœ	ž'˜AKšœœ
˜K˜
Kšœœ
˜K˜K˜
K˜—šœ
œ
ž&˜@Kšœœ
˜K˜
Kšœœ
˜K˜K˜K˜K˜
—Jš
œ˜—J˜J™+J˜šΟnœœ
	œ
œœ
œ(œœœ˜±
J™Jšœœ˜#Jš
œ˜Jš
œ˜š
œ ˜ Jš
œ˜Jš
œ˜J˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œP˜PJš
œ˜J˜—J˜šŸœ˜J™@Jšœœ
˜$Jšœ$œ˜*J˜—J˜šŸœ˜J™0Jšœœ
˜$J˜*J™Jš
œ*˜*J˜—J˜šŸ	œ˜J™JJšœœ
˜$Jšœœ
œ-˜LJ˜—J˜šŸœœ
	œ-˜OJ™€
Jšœœ˜"Jš
œ*˜*J˜—J˜šŸœœ
	œœ˜IJ™SJšœœ˜"J˜*J˜—J˜šŸ
œœ˜5Jš
œM™MJšœœ˜"šŸœ˜$šŸ
œ˜JšœCœ˜IJšœœEœ˜nJ˜—J˜0J˜—Jš
œ<˜<Jš
œ*˜*Jšœœ
˜Jš
œ˜J˜J˜—J˜J™.J™šŸ
œœ˜8J™‹Jšœœ˜"Jšœœ
˜Jšœœ˜#J˜—J˜šŸœœ$œœ˜„
J™ΟJšœœ˜"Jš
œ˜Jš
œL˜LJš
œ-˜-Jšœ&œ
˜*J˜—J˜šŸœ	œ7˜WJšœŸ
œ™€
šŸœ˜!JšœNœ˜TJšœIœ˜OJ˜—šŸœ˜!JšœTœ˜[J˜—Jšœœœ˜$šœ,œ˜4Jš
œL˜Lšœœ
œ
˜&Jš
œI˜I—Jš
œ+˜+šœœ
œ
˜&Jš
œI˜I—Jš
œ#˜#J˜—J˜—J˜šŸœœœ	œ˜UJš
œL™LJšœœ˜"Jšœœ
œ*œ˜WJ˜—J˜šŸœœ˜AJ™+Jšœœ˜"šŸœ˜JšœNœ˜TJ˜—Jš
œ8˜8Jš
œ?˜?J˜\Jšœœ˜#J˜—J˜
	modheaderšŸœœ%œ˜QJ™Œ
Jšœœ˜"Jš
œ<˜<Jš
œ>˜>Jšœœ
œ%˜4šœ˜Jš
œ˜Jšœœ
œ˜6J˜—Jšœœ˜#Jš
œ˜J˜—L˜šŸœœ%œ˜SJ™[Jšœœ˜"Jš
œ5˜5J˜—J˜šŸœœc˜Š
J™ξ
Jšœœ˜"šŸœ˜'Jš
œ˜Jš
œI˜IJ˜—Jš
œ?˜?Jš
œ?˜?Jš
œ/˜/J˜—J˜Jš
œB™BJ™šŸœœ*˜JJš
œb™bJšœœ˜"Jšœœ ˜2Jšœœ˜7Jš
œ˜šœœ
œœ˜@Jšœœ˜#Jšœjœ˜oJšœœ
˜J˜—Jšœœ
œ
œ
˜-šœ*œ
œ˜6Jš
œD˜DJš
œ<˜<J˜—JšœAœ˜FJšœnœ˜sJš
ϡ
˜°
Jš
œy˜yJ˜J˜—J˜šŸœœ0˜QJš
œΑ
™Α
Jšœœ˜"Jšœœ˜4Jšœœ˜2Jšœœ˜2Jšœœ˜7Jšœœ
œ
œ
˜-šœ*œ
œ˜6Jš
œD˜DJš
œ<˜<JšœŠ
œ˜
JšœŠ
œ˜
Jš
œN˜NJšœGœ˜LJšœnœ˜sJš
œΊ
˜Ί
Jš
œH˜HJ˜—Jšœœœ˜$J˜J˜—J˜šŸ
œœ*˜IJš
œa™aJšœœ˜"Jšœœ ˜2Jšœœ
˜&Jš
œ˜Jš
œœ
œ*œ
œ#˜xšœ˜JšœAœ˜FJš
œΆ
˜Ά
Jš
œv˜vJš
œ?˜?J˜J˜—J˜—J˜šŸœœ0˜PJš
œΕ
™Ε
Jšœœ˜"Jšœœ˜4Jšœœ˜2Jšœœ˜2Jšœœ˜7Jš
œ˜Jšœœ
œ
œ
˜-šœ*œ
œ˜6JšœGœ˜LJšœFœ˜KJšœFœ˜KJš
œ,˜,Jš
œΆ
˜Ά
Jš
œq˜qJ˜—Jšœœœ˜$J˜J˜—J˜šŸœœ'˜EJš
œΰ™ΰJšœœ˜"Jš
œ˜Jš
œ
˜
Jšœœ
˜Jš
œ˜Jš
œ˜Jšœœ
œ
œ
˜-Jš
œT˜TJš
œ0˜0Jš
œ*˜*Jšœ,œœ˜KJš
œ5˜5Jš
œu˜uJš
œk˜kJšœ/œ
˜4Jš
œ6˜6Jš
œ;˜;Jš
œ˜
˜˜
JšœOœ˜UJš
œU˜UJš
œ_˜_Jšœœœ˜$J˜J˜—J˜šŸœœ'˜KJ™QJšœœ˜"Jš
œ˜Jš
œ˜Jšœœ
˜Jšœœ
œ
œ
˜-šœœ
˜#Jš
œ¬
˜¬
Jšœ[œ˜aJšœeœ˜kJš
œO˜OJ˜—Jš
œ]˜]šœœ
œ˜#šœ!œ˜*Jšœ[œ˜aJšœeœ˜kJš
œU˜UJš
œ9˜9J˜—Jš
œ*˜*Jšœœ
˜Jš
œ˜—Jšœœ
œ˜2Jšœ0˜4Jš
œ˜Jšœœœ˜$J˜J˜—J˜šŸœœ˜=J™|Jšœœ˜"Jšœœ
œ
œ
˜-šœœ
œ˜#JšœUœ˜[Jš
œ%˜%Jšœœ
˜Jš
œT˜TJš
œY˜YJš
œ5˜5Jš
œ:˜:Jš
œ˜—J˜J˜—J˜šŸœœ1˜RJš
œπ™πJšœœ˜"Jšœœ ˜4Jšœœ
˜ Jš
œ˜Jš
œ˜Jšœœ
˜Jšœ#œ
˜,Jšœ
œ
˜Jš
œ˜Jšœœ
˜
Jšœœ
œ
œ
˜-Jš
œ]˜]šœœ
œ˜Jš
œ=˜=šœœ˜5J˜J˜
Jšœ˜
—J˜2šœœ˜JšœLœ˜RJšœœ˜0šœ˜Jš
œ
˜
Jš
œ 
˜ 
Jš	œœ	œ
œ
œ˜EJ˜—Jš
œn˜nJš
œl˜lJ˜J˜—J˜—Jš
œ5˜5J˜—J˜šŸœœ˜@J™=Jšœœ˜"J˜Jšœœ
œ
œ
˜-šœ;œ˜DJš
œ<˜<Jš
œw˜wJšœ2œœ
œ
œ
œ
˜UJš
œb˜bJ˜—Jšœœœ˜$J˜—J˜šŸœœ˜?J™<Jšœœ˜"Jš
œ˜šŸœ˜šœœ˜JšœAœ˜GJš
œ‚
˜‚
Jš
œ˜—J˜—Jšœœ
œ
œ
˜-šœ;œ˜DJšœhœ˜nJš
œS˜SJš
œV˜VJš
œ;˜;Jšœ2œ
˜6J˜—Jšœœœ˜$J˜—J˜šŸœœ(˜FJ™―Jšœœ˜"Jš
œ,˜,Jš
œ0˜0Jšœœ
œ
œ
˜-Jš
œ`˜`Jš
œE˜EJš
œE˜Ešœœ
œ˜šœ œ˜(Jš
œ5˜5JšœMœ˜SJšœPœ˜VJš
œ^˜^Jš
œJ˜JJš
œ4˜4J˜
—šœ˜šœ
œ
˜š
œ)˜)Jš
œ5˜5Jšœ[œ˜aJš
œq˜qJ˜—š
œ#˜#Jš
œ5˜5Jšœ[œ˜ašœ˜&Jš
œq˜q—šœ˜Jš
œ:˜:Jšœ`œ˜fJš
œa˜aJš
œw˜wJš
œU˜UJš
œ4˜4J˜—J˜—š
œ"˜"Jš
œ5˜5Jšœ[œ˜aJš
œr˜rJš
œ˜—Jšœ?˜F—Jš
œ˜—šœœ˜%Jš
œ!˜!Jš
œ˜J˜—Jšœ œF˜mJšœ œF˜mJš
œ˜J˜—Jšœœœ˜$J˜J˜—J˜šŸ
œ	œ/˜GJ™πšŸœ˜JšœAœ˜GJš
œL˜LJ˜—Jš
œ˜Jš
œ˜Jšœœ
œ
˜*Jš
œ2˜2Jš
œ7˜7JšœMœ˜SJšœRœ˜XJš
œ(˜(Jšœœ
œ˜;Jš
œ)˜)Jš
œ-˜-Jšœ"œ
˜&šœ!˜*JšœJœ˜PJš
œ5˜5J˜—Jš
œV˜VJš
œt˜tJš
œG˜GJš
œ1˜1J˜—J˜šŸœœ$œœ˜zJ™αJšœœ˜"J˜J˜Jšœœ
œ
˜8Jšœ^˜bJš
œ7˜7Jšœ!œ
˜%Jšœœ#˜:J˜—J˜šŸœ	œK˜gJš
œ½
™½
šœœ
œ˜Jšœœ
˜Jšœœ
˜J˜
—šœ˜Jš
œ#˜#Jš
œ%˜%J˜—J˜—J˜šŸœœœœ˜lJ™mJšœœ˜"Jšœ(œ
˜,Jšœœ*˜AJ˜—J˜šŸœœ-˜OJ™Š
Jšœœ˜"šœœ
œ˜#Jš
œ˜Jš
œ˜J˜—J˜J˜—J˜šŸ
œœH˜gJ™έJšœœ˜"Jš
œ˜Jš
œ˜Jšœœ
œ
œ
˜-Jš
œV˜Všœœ˜Jš
œ(˜(JšœIœ˜Ošœ˜Jšœœ
˜#Jšœœ
˜%Jš
œ9˜9Jšœ
˜—Jš
œC˜CJšœ%œv˜‘
Jš
œ'˜'J˜—J˜—J˜šŸœœ
	œ;˜dJ™TJš
œ˜Jš
œ?˜?Jš
œA˜AJš
œl˜lJ˜—J˜šŸœœK˜lJ™€Jšœœ˜"Jš
œ˜Jš
œ˜Jšœœ
œ
œ
˜-Jš
œ^˜^šœ
œ
œœ˜1Jš
œ(˜(JšœIœ˜Ošœ˜Jšœœ
˜#Jšœœ
˜%Jš
œ9˜9Jšœ
˜—Jš
œC˜CJš
œ'˜'J˜—J˜—J˜šŸœœc˜Ž
J™π
Jšœœ˜"šŸœ˜!Jšœœ
˜Jš
œ4˜4šœ
œ
˜Jš
œF˜FJš
œC˜CJš
œ
˜
Jš
œ—
˜—
Jšœ
˜—J˜—Jšœœ
œ
œ
˜-Jš
œI˜IJ˜—J˜šŸœœ$œœ,˜
J™δJšœœ˜"J˜J˜šœœ œ˜GJš
œ/˜/šœœ˜Jš
œ)˜)Jš
œ!˜!J˜—J˜
—šœ˜Jšœœ
œ
˜5JšœX˜\Jšœœ
˜ šœœ˜Jš
œ˜šœ
œ
œ
˜Jšœœ)˜?Jšœœ'˜=Jš
œ'˜'Jšœ˜—J˜—Jšœœ
˜"Jš
œ/˜/šœœ˜Jš
œ)˜)Jš
œ!˜!J˜—J˜—J˜—J˜šŸ
œœ$œœC˜€
J™΄Jšœœ˜"Jšœœ
˜J˜Jšœœ
˜J˜šœœœ˜EJš
œ,˜,šœœ˜Jš
œ&˜&Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ$˜$J˜—J˜
—šœ˜Jšœœ
œ˜6Jšœ^˜bJšœœ
˜ šœœ˜Jš
œ=˜=J˜+Jš
œ˜Jš
œ˜J˜J˜šœœ˜&J˜J˜
Jšœ˜—Jšœœ˜(J˜—Jšœœ
˜!Jš
œ,˜,šœ
œ˜Jš
œ&˜&Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ$˜$J˜—J˜—J˜—J˜šŸœ	œ˜2J™Γ
Jšœœ
˜#Jšœœ
˜"J˜—L˜šŸœ	œ˜0J™J˜SJ˜#J˜—L˜Lšœ
˜J™—…—xΆy