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

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

BEGIN
ArtworkToolData: TYPE = SVInterfaceTypes.ArtworkToolData;
BoundBox: TYPE = SVBasicTypes.BoundBox;
Camera: TYPE = SVModelTypes.Camera;
Classification: TYPE = SVSceneTypes.Classification;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
EditToolData: TYPE = SVInterfaceTypes.EditToolData;
ExtendMode: TYPE = SVSceneTypes.ExtendMode;
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 = SVSceneTypes.Primitive;
Ray: TYPE = SVSceneTypes.Ray;
Scene: TYPE = SVSceneTypes.Scene;
Selection: TYPE = SVInterfaceTypes.Selection;
SelectionGenerator: TYPE = SVInterfaceTypes.SelectionGenerator;
SelectMode: TYPE = SVSceneTypes.SelectMode;
Skitter: TYPE = SVSceneTypes.Skitter;
SkitterMode: TYPE = SVSceneTypes.SkitterMode;
Slice: TYPE = SVSceneTypes.Slice;
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];

SELECT selectMode FROM
joint => [worldPt, normalVec, feature, hitData] _ SVGravity.PointsPreferred[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
segment => [worldPt, normalVec, feature, hitData] _ SVGravity.LinesPreferred[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
traj, topLevel => [worldPt, normalVec, feature, hitData] _ SVGravity.FacesPreferred[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData];
ENDCASE => ERROR;
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] = {
sliceD: SliceDescriptor;
skitter: Skitter _ svData.editToolData.skitter;
sliceD _ IF feature = NIL THEN NIL ELSE NARROW[feature.shape];
IF feature=NIL THEN SVCaret.SetAttractor[skitter, cameraPoint, worldPt, normal, sliceD]
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];
SVCaret.SetAttractor[skitter, cameraPoint, jointPos, jointNormal, sliceD];
};
ENDCASE => SVCaret.SetAttractor[skitter, cameraPoint, worldPt, normal, sliceD];
};
};

EndSelect: PUBLIC MouseProc = {
pointWorld: Point3d;
normalWorld: Vector3d;
feature: FeatureData;
hitData: REF ANY;
scene: Scene _ svData.scene;
featureCycler: SVGravity.FeatureCycler;
selectMode: SelectMode _ SVState.GetSelectMode[svData];

SELECT selectMode FROM
joint => featureCycler _ SVGravity.PointsPreferredCycler[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE, 1];
segment => featureCycler _ SVGravity.LinesPreferredCycler[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE, 1];
traj, topLevel => {
featureCycler _ SVGravity.FacesPreferredCycler[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData];
};
ENDCASE => ERROR;
[pointWorld, normalWorld, feature, hitData] _ SVGravity.FirstFeature[featureCycler];
SVState.SetSelectionCycler[svData, featureCycler];
SelectFromFeature[svData, cameraPoint, pointWorld, normalWorld, feature, hitData];
}; -- end EndSelect

SelectFromFeature: PUBLIC PROC [svData: SVData, cameraPt: Point2d, pointWorld: Point3d, normalWorld: Vector3d, feature: FeatureData, hitData: REF ANY] = {
selectMode: SelectMode _ SVState.GetSelectMode[svData];
scene: Scene _ svData.scene;
SetCaretAttractorEndpoint[svData, cameraPt, pointWorld, normalWorld, feature, hitData];
SVWindow.NewCaretPos[svData];
SVSelect.DeselectAll[scene, normal];
SELECT selectMode FROM
joint => EndSelectAux[svData, cameraPt, feature, hitData, pointWorld, joint, "joint"];
segment => EndSelectAux[svData, cameraPt, feature, hitData, pointWorld, segment, "segment"];
traj => EndSelectAux[svData, cameraPt, feature, hitData, pointWorld, traj, "trajectory"];
topLevel => EndSelectAux[svData, cameraPt, feature, hitData, pointWorld, topLevel, "object"];
ENDCASE => ERROR;
};

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]];
featureCycler: SVGravity.FeatureCycler _ SVState.GetSelectionCycler[svData];
cycleCount: NAT _ featureCycler.count;
IF cycleCount > 1 THEN Feedback.PutFHerald[svData.feedback, oneLiner, Rope.Concat[SVAssembly.Describe[sliceD], " selected (%g more)"], [integer[cycleCount-1]]]
ELSE 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;
extendMode: ExtendMode _ SVState.GetExtendMode[svData];

CodeTimer.StartInt[$DuringExtendSelection, $Solidviews];
SELECT extendMode FROM
joint => {
[surfacePtWorld, normalWorld, feature, hitData] _ SVGravity.PointsPreferred[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
};
segment, segmentRange => {
[surfacePtWorld, normalWorld, feature, hitData] _ SVGravity.LinesPreferred[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData, TRUE];
};
traj, slice, topLevel => {
[surfacePtWorld, normalWorld, feature, hitData] _ SVGravity.FacesPreferred[cameraPoint, svData.hitTest.t, SVAlign.emptyAlignBag, svData.hitTest.sceneBag, svData];
};
ENDCASE => ERROR;
SetCaretAttractorEndpoint[svData, cameraPoint, surfacePtWorld, normalWorld, feature, hitData];
SVSelect.DeselectAll[scene, normal];
SVScene.RestoreSelections[scene];
IF feature#NIL THEN {
SELECT 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 July 10, 1987 12:17:54 pm PDT
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Contents: Procedures for responding to button clicks made in a solidviewer.
Bloomenthal, June 16, 1987 7:29:53 pm PDT
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.
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š
œ4™4Jšœ
ฯm
œ1™<š
œK™KIcode™)—J˜š
ฯk	˜	Jšœ9žœ๑
˜ฌ—J˜šœž
˜ Jšžœฎ
˜ต
Jšžœ˜—J˜š
ž˜Jšœžœ$˜9Jšœ
žœ˜'Jšœžœ˜#Jšœžœ˜3Jšœ
žœ˜-Jšœžœ!˜3Jšœžœ˜+Jšœ
žœ ˜1Jšœžœ˜+Jšœ
žœ˜'Jšœžœ˜/Jšœžœ˜#Jšœ	žœ˜Jšœ	žœ˜Jšœžœ˜)Jšœžœ˜Jšœžœ˜!Jšœžœ˜-Jšœžœ'˜?Jšœžœ˜+Jšœ	žœ˜%Jšœ
žœ˜-Jšœžœ˜!Jšœžœ ˜5Jšœ
žœ˜'Jšœ
žœ˜Jšœ
žœ˜Jšœžœ˜'J˜Lšœžœ˜)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š
œซ
˜ซ
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š
œ/˜/Jš
œ	žœžœ
žœ
žœ
žœ
žœ˜>Lšžœ	žœ
žœD˜Wšžœ˜Lšœžœ
žœ˜šžœž˜š
œ
˜
Lš
œ˜Lš
œ˜Lšœžœ˜(Lš
œ˜Lš
œe˜eLš
œJ˜JL˜—LšžœH˜O—L˜—L˜L˜—šŸ	œžœ˜Lšœฯuœ
˜Lšœขœ˜Lš
œ˜Lšœ	žœ
žœ
˜Lš
œ˜L˜'Lš
œ7˜7L˜šžœž˜Lšœ
žœ˜™
Lšœ‘
žœ˜š
š
œ˜Lš
Ϡ
˜†
L˜—Lšžœžœ
˜—Lšœขœขœ<˜TLš
œ2˜2Lšœ,ขœขœ˜RLšœ ˜L˜—šŸœžœ
žœ*ขœขœ+žœ
žœ˜š
Lš
œ7˜7Lš
œ˜Lšœ1ขœขœ˜WLš
œ˜Lš
œ$˜$šžœž˜Lšœ?ขœ˜VLšœAขœ˜\Lšœ>ขœ˜YLšœBขœ˜]Lšžœžœ
˜—L˜L˜—š
ŸœžœGžœ
žœ4žœ˜
Lš
ก6™6šžœžœ
žœ˜Lšœžœ™!Lš
œT˜TL˜
—šžœ˜Lš
ก&™&šžœž˜Lš
œ.˜.Lšกœ"กœ˜7Lš
œ,˜,Lš
œ4˜4Lšžœžœ
˜—šžœž˜˜
Lšœžœ<˜\Lš
œL˜LLšœžœ˜&Lšžœ
žœžœžœ
™GLšžœ%™)Lšžœžœ‰
˜Ÿ
Lšžœi˜mLš
œ)˜)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š
œ7˜7L˜Lš
œ8˜8šžœž˜š
œ
˜
Lšœ
ขœขœ‡
žœ˜ฉ
L˜—˜Lšœ
ขœขœ†
žœ˜จ
L˜—š
œ˜Lšœ
ขœขœ†
˜ข
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šžœ
˜—…—7IŽ