DIRECTORY
CodeTimer, SVGraphics, Feedback, Imager, ImagerBackdoor, ImagerPath, IO, Matrix3d, Rope, SV2d, SV3d, SVAlign, SVAssembly, SVBasicTypes, SVDescribe, SVGravity, SVInterfaceTypes, SVModelTypes, SVMouseEvent, SVRayTypes, SVRefresh, SVScene, SVSceneTypes, SVSelect, SVSelections, SVState, SVWindow, TIPUser, ViewerClasses;

SVMouseEventImplB: CEDAR PROGRAM
IMPORTS CodeTimer, SVGraphics, Feedback, Imager, ImagerBackdoor, Matrix3d, Rope, SVAlign, SVAssembly, SVDescribe, SVGravity, SVRefresh, SVScene, SVSelect, SVSelections, SVState, SVWindow
EXPORTS SVMouseEvent =

BEGIN
ArtworkToolData: TYPE = SVInterfaceTypes.ArtworkToolData;
Slice: TYPE = SVSceneTypes.Slice;
BoundBox: TYPE = SVBasicTypes.BoundBox;
Camera: TYPE = SVModelTypes.Camera;
Classification: TYPE = SVRayTypes.Classification;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
EditToolData: TYPE = SVInterfaceTypes.EditToolData;
FeatureData: TYPE = SVInterfaceTypes.FeatureData;
FileCamera: TYPE = SVSceneTypes.FileCamera;
FrameBox: TYPE = SVModelTypes.FrameBox;
MasterObject: TYPE = SVSceneTypes.MasterObject;
Matrix4by4: TYPE = SV3d.Matrix4by4;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = SV3d.Point3d;
Primitive: TYPE = SVRayTypes.Primitive;
Ray: TYPE = SVRayTypes.Ray;
Scene: TYPE = SVSceneTypes.Scene;
Selection: TYPE = SVInterfaceTypes.Selection;
SelectionGenerator: TYPE = SVInterfaceTypes.SelectionGenerator;
SelectMode: TYPE = SVSceneTypes.SelectMode;
SkitterMode: TYPE = SVSceneTypes.SkitterMode;
SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor;
ToolData: TYPE = SVSceneTypes.ToolData;
TrigLine: TYPE = SV2d.TrigLine;
Vector3d: TYPE = SV3d.Vector3d;
SVData: TYPE = SVInterfaceTypes.SVData;

MouseProc: TYPE = SVMouseEvent.MouseProc;
StartProc: TYPE = SVMouseEvent.StartProc;
Problem: SIGNAL [msg: Rope.ROPE] = Feedback.Problem;


FrameUpLeft: PUBLIC StartProc = {
camera: Camera _ svData.camera;
camera.frame.fullScreen _ FALSE;
camera.frame.downLeft[1] _ cameraPoint[1];
camera.frame.upRight[2] _ cameraPoint[2];
camera.frame.downLeft[2] _ cameraPoint[2] - 50.0; -- Just to give the frame an initial size.
camera.frame.upRight[1] _ cameraPoint[1] + 50.0;
SVWindow.RestoreScreenAndInvariants[$DuringMotion, svData];
};

FrameDownRightMove: PUBLIC MouseProc = {
camera: Camera _ svData.camera;
DoDrawFrame: PROC [dc: Imager.Context] = {
Imager.SetColor[dc, ImagerBackdoor.invert];
SVGraphics.DrawFrame [dc, camera];
};
camera.frame.downLeft[2] _ cameraPoint[2];
camera.frame.upRight[1] _ cameraPoint[1];
SVWindow.RestoreScreenAndInvariants[$DuringMotion, svData];
};

FrameDownRightEnd: PUBLIC MouseProc = {
camera: Camera _ svData.camera;
fileCamera: FileCamera;
success: BOOL;
FrameDownRightMove[event, svData, cameraPoint];
[fileCamera, success] _ SVScene.FindFileCameraFromName[camera.viewName, svData.scene];
IF success THEN {
fileCamera.frame.downLeft _ camera.frame.downLeft;
fileCamera.frame.upRight _ camera.frame.upRight;
fileCamera.frame.fullScreen _ FALSE;
};
};

DeleteFrame: PUBLIC MouseProc = {
camera: Camera _ svData.camera;
frame: FrameBox _ camera.frame;
DoDrawFrame: PROC [dc: Imager.Context] = {
Imager.SetColor[dc, ImagerBackdoor.invert];
SVGraphics.DrawFrame [dc, camera];
};
SVWindow.RestoreScreenAndInvariants[$FrameChanged, svData];
frame.fullScreen _ TRUE;
};


SaveSavedState: PROC [svData: SVData] = {
SVScene.SaveSelections[svData.scene];
};


StartSelectJoint: PUBLIC StartProc = {
svData.drag.selectState _ joint;
StartSelectAux[svData, cameraPoint];
DuringSelect[NIL, svData, cameraPoint];
};

StartSelectSegment: PUBLIC StartProc = {
svData.drag.selectState _ segment;
StartSelectAux[svData, cameraPoint];
DuringSelect[NIL, svData, cameraPoint];
};

StartSelectTraj: PUBLIC StartProc = {
svData.drag.selectState _ traj;
StartSelectAux[svData, cameraPoint];
DuringSelect[NIL, svData, cameraPoint];
};

StartSelectTopLevel: PUBLIC StartProc = {
svData.drag.selectState _ topLevel;
StartSelectAux[svData, cameraPoint];
DuringSelect[NIL, svData, cameraPoint];
};

StartSelectAux: PROC [svData: SVData, cameraPoint: Point2d] = {
IF NOT SVRefresh.EmptyOverlay[svData] THEN ERROR;
SaveSavedState[svData];
};

DuringSelect: PUBLIC MouseProc = {
opRope: Rope.ROPE = "Selecting ";
worldPt: Point3d;
normalVec: Vector3d;
feature: FeatureData;
hitData: REF ANY;
scene: Scene _ svData.scene;
selectMode: SelectMode _ SVState.GetSelectMode[svData];

IF selectMode = joint THEN
[worldPt, normalVec, feature, hitData] _ SVGravity.PointsPreferred[cameraPoint, svData.hitTest.criticalR, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE]
ELSE [worldPt, normalVec, feature, hitData] _ SVGravity.StrictDistance[cameraPoint, svData.hitTest.criticalR, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
SetCaretAttractorEndpoint[svData, cameraPoint, worldPt, normalVec, feature, hitData];
SVSelect.DeselectAll[scene, normal];
IF feature#NIL THEN SelectAndDescribeSlicePart[feature, hitData, worldPt, svData, selectMode, opRope] ELSE DescribeOperationOnNothing[svData, opRope];
SVWindow.RestoreScreenAndInvariants[paintAction: $DuringSelect, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
}; -- end DuringSelect

SelectAndDescribeSlicePart: PUBLIC PROC [feature: FeatureData, hitData: REF ANY, hitPoint: Point3d, svData: SVData, mode: SelectMode, opRope: Rope.ROPE] = {
selectedD: REF ANY _ SelectSlicePart[feature, hitData, hitPoint, svData, mode];
description: Rope.ROPE _ WITH selectedD SELECT FROM
sliceD: SliceDescriptor => SVAssembly.Describe[sliceD],
ENDCASE => SVDescribe.DescribeFeature[feature, hitData, svData];
Feedback.PutFHerald[svData.feedback, oneLiner, "%g %g", [rope[opRope]], [rope[description]] ];
};

SelectSlicePart: PUBLIC PROC [feature: FeatureData, hitData: REF ANY, hitPoint: Point3d, svData: SVData, mode: SelectMode] RETURNS [selectedD: REF ANY] = {
SELECT feature.type FROM
slice => {
slice: Slice _ NARROW[feature.shape, SliceDescriptor].slice;
selectedSliceD: SliceDescriptor;
selectedSliceD _ SVAssembly.NewParts[slice, hitData, hitPoint, mode];
SVSelect.SelectSlice[selectedSliceD, svData.scene, normal];
selectedD _ selectedSliceD;
};
slopeLine, angleLine, distanceLine, intersectionPoint, radiiCircle, midpoint => ERROR;
ENDCASE => ERROR Problem[msg: "unimplemented result type"];
};

DescribeOperationOnNothing: PUBLIC PROC [svData: SVData, opRope: Rope.ROPE] = {
Feedback.PutFHerald[svData.feedback, oneLiner, "%g %g", [rope[opRope]], [rope["nothing"]] ];
};

SetCaretAttractorEndpoint: PUBLIC PROC [svData: SVData, cameraPoint: Point2d, worldPt: Point3d, normal: Vector3d, feature: FeatureData, hitData: REF ANY] = {
assembly: Slice;
assembly _ IF feature = NIL THEN NIL ELSE NARROW[feature.shape, SliceDescriptor].slice;
IF feature=NIL THEN [] _ SVSelections.PositionSkitter[cameraPoint, worldPt, normal, assembly, svData] ELSE {
shape: REF ANY _ feature.shape;
SELECT feature.type FROM
slice => {
jointPos: Point3d;
jointNormal: Vector3d;
sliceD: SliceDescriptor _ NARROW[shape];
jointD: SliceDescriptor;
[jointD, jointPos, jointNormal] _ SVAssembly.ClosestJointToHitData[sliceD, worldPt, normal, hitData];
[] _ SVSelections.PositionSkitter[cameraPoint, jointPos, jointNormal, assembly, svData];
};
ENDCASE => [] _ SVSelections.PositionSkitter[cameraPoint, worldPt, normal, assembly, svData];
};
};

EndSelect: PUBLIC MouseProc = {
pointWORLD: Point3d;
normalWORLD: Vector3d;
feature: FeatureData;
hitData: REF ANY;
scene: Scene _ svData.scene;
selectMode: SelectMode _ SVState.GetSelectMode[svData];

IF selectMode = joint THEN
[pointWORLD, normalWORLD, feature, hitData] _ SVGravity.PointsPreferred[cameraPoint, svData.hitTest.criticalR, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE]
ELSE [pointWORLD, normalWORLD, feature, hitData] _ SVGravity.StrictDistance[cameraPoint, svData.hitTest.criticalR, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
SetCaretAttractorEndpoint[svData, cameraPoint, pointWORLD, normalWORLD, feature, hitData];
SVWindow.NewCaretPos[svData];
SVSelect.DeselectAll[scene, normal];
SELECT selectMode FROM
joint => EndSelectAux[svData, cameraPoint, feature, hitData, pointWORLD, joint, "joint"];
segment => EndSelectAux[svData, cameraPoint, feature, hitData, pointWORLD, segment, "segment"];
traj => EndSelectAux[svData, cameraPoint, feature, hitData, pointWORLD, traj, "trajectory"];
topLevel => EndSelectAux[svData, cameraPoint, feature, hitData, pointWORLD, topLevel, "object"];
ENDCASE => ERROR;
SVState.SetSelectMode[svData, none]; -- added to help DescribeFeature work. KAP.
}; -- end EndSelect

EndSelectAux: PROC [svData: SVData, cameraPoint: Point2d, feature: FeatureData, hitData: REF ANY, hitPoint: Point3d, mode: SelectMode, opName: Rope.ROPE] = {
IF feature = NIL THEN {
Feedback.PutFHerald[svData.feedback, oneLiner, "No near %g found.", [rope[opName]]];
}
ELSE {
SELECT mode FROM
joint => SVState.SetExtendMode[svData, joint];
segment => SVState.SetExtendMode[svData, segmentRange];
traj => SVState.SetExtendMode[svData, traj];
topLevel => SVState.SetExtendMode[svData, topLevel];
ENDCASE => ERROR;
SELECT feature.type FROM
slice => {
sliceD: SliceDescriptor _ NARROW[SelectSlicePart[feature, hitData, hitPoint, svData, mode]];
Feedback.AppendHerald[svData.feedback, Rope.Concat[SVAssembly.Describe[sliceD], " selected"], oneLiner];
SVState.SetSliceToExtend[svData, sliceD];
};
ENDCASE => ERROR Problem[msg: "Unexpected feature type"];
};
SVWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
}; -- end EndSelectAux

StartExtendSelectJoint: PUBLIC StartProc = {
svData.drag.extendMode _ joint;
RETURN[StartExtendSelection[event, svData, cameraPoint]];
};

StartExtendSelectSegment: PUBLIC StartProc = {
svData.drag.extendMode _ segment;
RETURN[StartExtendSelection[event, svData, cameraPoint]];
};

StartExtendSelectTraj: PUBLIC StartProc = {
svData.drag.extendMode _ traj;
RETURN[StartExtendSelection[event, svData, cameraPoint]];
};

StartExtendSelectTopLevel: PUBLIC StartProc = {
svData.drag.extendMode _ topLevel;
RETURN[StartExtendSelection[event, svData, cameraPoint]];
};

StartExtendSelection: PUBLIC StartProc = {
IF NOT SVRefresh.EmptyOverlay[svData] THEN ERROR;
SaveSavedState[svData]; -- must do this before any possible aborts occur
svData.drag.currentPoint _ cameraPoint;
svData.drag.transform _ Matrix3d.Identity[];
DuringExtendSelection[NIL, svData, cameraPoint];
};

DuringExtendSelection: PUBLIC MouseProc= {
opRope: Rope.ROPE = "Extending to ";
surfacePtWORLD: Point3d;
normalWORLD: Vector3d;
feature: FeatureData;
hitData: REF ANY;
scene: Scene _ svData.scene;

CodeTimer.StartInt[$DuringExtendSelection, $Solidviews];
IF SVState.GetExtendMode[svData] = joint THEN
[surfacePtWORLD, normalWORLD, feature, hitData] _ SVGravity.PointsPreferred[cameraPoint, svData.hitTest.criticalR, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE]
ELSE [surfacePtWORLD, normalWORLD, feature, hitData] _ SVGravity.StrictDistance[cameraPoint, svData.hitTest.criticalR, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
SetCaretAttractorEndpoint[svData, cameraPoint, surfacePtWORLD, normalWORLD, feature, hitData];
SVSelect.DeselectAll[scene, normal];
SVScene.RestoreSelections[scene];
IF feature#NIL THEN {
SELECT svData.drag.extendMode FROM
joint, segment, segmentRange, traj, topLevel  => DuringExtendSelectionFeedback[feature, hitData, surfacePtWORLD, svData];
slice, none  => NULL;
ENDCASE => ERROR;
}
ELSE DescribeOperationOnNothing[svData, opRope];
SVWindow.RestoreScreenAndInvariants[paintAction: $DuringSelect, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
CodeTimer.StopInt[$DuringExtendSelection, $Solidviews];
}; -- end DuringExtendSelection

DuringExtendSelectionFeedback: PROC [feature: FeatureData, hitData: REF ANY, hitPoint: Point3d, svData: SVData] = {
opRope: Rope.ROPE _ "Extending to ";
SELECT svData.drag.extendMode FROM
joint, segment, traj, topLevel => [] _ SelectAndDescribeSlicePart[feature, hitData, hitPoint, svData, SVState.GetExtendMode[svData], opRope];
segmentRange => {
GOTO RegularSelectMechanism;
EXITS
RegularSelectMechanism => [] _ SelectAndDescribeSlicePart[feature, hitData, hitPoint, svData, segment, opRope];
};
ENDCASE => ERROR; -- should have been weeded about before calling this Proc
};

EndExtendSelection: PUBLIC MouseProc = {
SVWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
}; -- end EndExtendSelection

InitStats: PROC [] = {
interval: CodeTimer.Interval;
interval _ CodeTimer.CreateInterval[$DuringExtendSelection];
CodeTimer.AddInt[interval, $Solidviews];
};
InitStats[];

END.
φFile: SVMouseEventImplB.mesa
Last edited by Bier on May 26, 1987 8:30:22 pm PDT
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Contents: Procedures for responding to button clicks made in a solidviewer.
Controlpoint is in camera coordinates.
Controlpoint is in camera coordinates.
Draw the new frame.
Once last update with the final position.
Tell the appropriate file camera about the new frame.
Erase the old frame.
SVWindow.SaveCaretPos[gargoyleData];
SVCaret.Copy[from: svData.caret, to: svData.drag.savedCaret];
Selection Procs
While a joint, segment, traj, or top level object is being selected, gravity is forced to be StrictDistance.  The object bag should consist only of trajectories and slices.  The caret is moved to the segment endpoint of the nearest segment or traj as appropriate or tracks the cursor if none are nearby.  Feedback is in the form of highlighted joints.
Find out which point is being selected and highlight it.
SitTheCaret: PROC [caret: Caret, outlineD: OutlineDescriptor, hitData: REF ANY, mode: SelectMode] = {
SELECT mode FROM
joint => GGCaret.SitOn[caret, outlineD];
segment, traj, topLevel => {
jointParts: SliceParts;
jointSeq: Sequence;
jointD: OutlineDescriptor;
jointNum: NAT;
traj: Traj;
IF outlineD.slice.class.type = $Outline THEN {
[jointNum, traj] _ GGOutline.NearestJointToHitData[hitData];
jointSeq _ GGSequence.CreateFromJoint[traj, jointNum];
jointParts _ GGOutline.PartsFromSequence[outlineD.slice, jointSeq];
jointD _ GGOutline.DescriptorFromParts[outlineD.slice, jointParts];
GGCaret.SitOn[caret, jointD];
}
ELSE GGCaret.SitOn[caret, NIL];
};
ENDCASE => ERROR;
};

Prepare for a subsequent Add operation and for Extend.
GGCaret.SitOn[svData.caret, NIL];
Make Selection and Prepare for Extend.
IF mode = traj OR mode = topLevel THEN GGCaret.SitOn[svData.caret, NIL]
ELSE GGCaret.SitOn[svData.caret, sliceD];

Extend selection procs.
Put Caret on a joint (if any).
Reselect all.
depending on extend mode, check if feature is in that mode, then select the new feature.
Κ£˜Iheadš
œ™Jš
œ2™2Jšœ
Οm
œ1™<Jš
œK™KJ˜š
Οk	˜	JšœEžœφ
˜½—J˜šœž
˜ Jšžœ³
˜Ί
Jšžœ˜—J˜š
ž˜Jšœžœ$˜9Jšœžœ˜!Jšœ
žœ˜'Jšœžœ˜#Jšœžœ˜1Jšœ
žœ˜-Jšœžœ!˜3Jšœ
žœ ˜1Jšœžœ˜+Jšœ
žœ˜'Jšœžœ˜/Jšœžœ˜#Jšœ	žœ˜Jšœ	žœ˜Jšœžœ˜'Jšœžœ˜Jšœžœ˜!Jšœžœ˜-Jšœžœ'˜?Jšœžœ˜+Jšœ
žœ˜-Jšœžœ ˜5Jšœ
žœ˜'Jšœ
žœ˜Jšœ
žœ˜Jšœžœ˜'J˜Icodešœžœ˜)Lšœžœ˜)LšΟnœžœžœ˜4J˜—J˜šŸœžœ˜!Jš
œ&™&Jš
œ˜Jšœžœ
˜ Jš
œ*˜*Jš
œ)˜)Jšœ2Οc*˜\Jš
œ0˜0Jš
œ;˜;Jš
œ˜J˜—šŸœžœ˜(Jš
œ&™&Jš
œ˜šŸœžœ˜*J˜+Jš
œ"˜"Jš
œ˜—Jš
œ*˜*š
œ)˜)J™—Jš
œ;˜;Jš
œ˜J˜—šŸœžœ˜'Jš
œ˜Jš
œ˜Jšœ	žœ
˜š
œ/˜/J™)J™5—Jš
œV˜Všžœ	žœ˜Jš
œ2˜2Jš
œ0˜0Jšœžœ
˜$J˜—Jš
œ˜J˜—šŸœžœ
˜!Jš
œ˜Jš
œ˜šŸœžœ˜*Jš
œ+˜+Jš
œ"˜"Jš
œ˜J™—Jš
œ;˜;Jšœžœ
˜Jš
œ˜J˜—J˜šŸœžœ˜)Lš
œ%˜%Lš
œ$™$Lš
œ=™=L˜L˜—L˜L™šŸœžœ˜&Lš
œ ˜ Lš
œ$˜$Lšœ
žœ˜'L˜L˜—šŸœžœ˜(Lš
œ"˜"Lš
œ$˜$Lšœ
žœ˜'L˜L˜—šŸœžœ˜%Lš
œ˜Lš
œ$˜$Lšœ
žœ˜'L˜L˜—šŸœžœ˜)Lš
œ#˜#Lš
œ$˜$Lšœ
žœ˜'L˜L˜—šŸœžœ+˜?Lšžœ
žœ žœ
žœ
˜1Lš
œ˜L˜L˜—šŸœžœ˜"L™ίLšœ
žœ˜!Lš
œ˜L˜Lš
œ˜Lšœ	žœ
žœ
˜L˜Lš
œ7˜7L˜šžœž˜Lšœ’
žœ
˜§
—Lšžœ’
žœ˜¬
LšŸœ<˜ULšœ	Οbœ˜$Lšžœ	žœ
žœSžœ,˜–
Lšœižœ
žœžœ˜˜
Lš
œ˜L˜—šŸœžœ
žœ!žœ
žœDžœ˜œ
Lšœžœ
žœ=˜Ošœžœžœžœ
ž˜3L˜7Lšžœ9˜@—Lš
œ^˜^L˜L˜—šŸœžœ
žœ!žœ
žœ7žœ
žœ
žœ˜›
L™8šžœž˜š
œ
˜
Lšœžœ'˜<Lš
œ ˜ Lš
œE˜ELš
œ;˜;Lš
œ˜Lš
œ˜—LšœPžœ
˜VLšžœžœ+˜;—Lš
œ˜L˜—šŸœžœ
žœžœ˜OLš
œ\˜\L˜L˜—š
Ÿœžœ
žœkžœ
žœ˜
Jš
œ˜Jš
œžœžœ
žœ
žœ
žœ
žœ'˜Wšžœ	žœ
žœSžœ˜lLšœžœ
žœ˜šžœž˜š
œ
˜
Lš
œ˜Lš
œ˜Lšœžœ˜(Lš
œ˜Lš
œe˜eLš
œX˜XL˜—LšžœV˜]—L˜—L˜L˜—šŸ	œžœ˜LšœΟuœ
˜Lšœ’œ˜Lš
œ˜Lšœ	žœ
žœ
˜Lš
œ˜Lš
œ7˜7L˜šžœž˜Lšœ’œ’œ
žœ
˜¬
—Lšžœ’œ’œŽ
žœ˜±
LšŸœ’œ’œ˜ZLš
œ˜Lš
œ$˜$šžœž˜LšœB’œ˜YLšœD’œ˜_LšœA’œ˜\LšœE’œ˜`Lšžœžœ
˜—Lšœ% +˜PLšœ ˜L˜—šŸœžœ6žœ
žœ™ešžœž™Lš
œ(™(™L™Lš
œ™Lš
œ™Lšœ
žœ
™L™šžœ&žœ™.Lš
œ<™<Lš
œ6™6Lš
œC™CLš
œC™CLš
œ™L™
—Lšžœžœ™L™—Lšžœžœ
™L™L™——š
ŸœžœGžœ
žœ4žœ˜
Lš
‘6™6šžœžœ
žœ˜Lšœžœ™!Lš
œT˜TL˜
—šžœ˜Lš
‘&™&šžœž˜Lš
œ.˜.Lš‘œ"‘œ˜7Lš
œ,˜,Lš
œ4˜4Lšžœžœ
˜—šžœž˜˜
Lšœžœ<˜\Lšžœ
žœžœžœ
™GLšžœ%™)Lš
œh˜hLš
œ)˜)L˜—Lšžœžœ)˜9—L˜—Lšœmžœ
žœžœ˜œ
Lšœ ˜L˜—L™L™šŸΠbnŸœžœ˜,Lš
œ˜Lšžœ3˜9L˜L˜—šŸ£Ÿœžœ˜.Lš
œ!˜!Lšžœ3˜9L˜L˜—šŸ£Ÿœžœ˜+Lš
œ˜Lšžœ3˜9L˜L˜—šŸ£Ÿœžœ˜/Lš
œ"˜"Lšžœ3˜9L˜L˜—šŸœžœ˜*Lšžœ
žœ žœ
žœ
˜1Lšœ 0˜HLš
œ'˜'Lš
œ,˜,Lšœžœ˜0L˜L˜—šŸœžœ
˜*Lšœ
žœ˜$Lšœ	’œ
˜Lšœ’œ˜Lš
œ˜Lšœ	žœ
žœ
˜Lš
œ˜L˜Lš
œ8˜8šžœ'ž˜-Lšœ
’œ’œ
žœ
˜°
—Lšžœ’œ’œŽ
žœ˜΅
Lš
‘™Lšœ8’œ’œ˜^Lš
‘
™
Lš
œ$˜$Lš
œ!˜!šžœ	žœ
žœ˜šžœž˜"Lšœj’œ
˜yLšœžœ
˜Lšžœžœ
˜—L˜
—Lšžœ,˜0Lšœižœ
žœžœ˜˜
Lš
œ7˜7Lš
œ˜L˜—šŸœžœ!žœ
žœ(˜sL™XLšœ
žœ˜$šžœž˜"Lš
œ
˜
š
œ˜Lšžœ˜š
ž˜LšœŸœ6˜o—L˜—Lšžœžœ 9˜K—L˜L˜—šŸ£œžœ˜(Lšœmžœ
žœžœ˜œ
Lšœ ˜L˜—šŸ	œžœ˜Jš
œ˜Jš
œ<˜<Jš
œ(˜(J˜—š
œ˜J˜—Jšžœ
˜—…—1μF…