DIRECTORY
AtomButtons, AtomButtonsTypes, Basics, BasicTime, CodeTimer, Containers, SVCoordSys, SVSceneToTree, Feedback, FileNames, FS, GGFileOps, GGViewerOps, Imager, IO, Menus, Random, Real, Rope, SlackProcess, SV2d, SV3d, SVAlign, SVAssembly, SVBasicTypes, SVBoundBox, SVCaret, SVCastRays, SVDrawMonitor, SVEditUser, SVEvent, SVFiles, SVGravity, SVInterfaceTypes, SVModelTypes, SVMouseEvent, SVRefresh, SVScene, SVSceneTypes, SVSelect, SVSelections, SVSessionLog, SVState, SVUserInput, SVViewersOnScene, SVViewerTool, SVWindow, SVParseOut, ViewerClasses, ViewerOps, ViewerTools;

SVEventImplA: CEDAR PROGRAM
IMPORTS AtomButtons, BasicTime, CodeTimer, GGFileOps, GGViewerOps, SVBoundBox, SVCoordSys, SVSceneToTree, Feedback, FileNames, FS, IO, Random, Rope, SlackProcess, SVAlign, SVAssembly, SVCaret, SVCastRays, SVEditUser, SVEvent, SVFiles, SVGravity, SVMouseEvent, SVRefresh, SVScene, SVSelect, SVSelections, SVSessionLog, SVState, SVUserInput, SVViewersOnScene, SVWindow, SVParseOut, ViewerOps, ViewerTools
EXPORTS SVEvent =

BEGIN

AlignBag: TYPE = SVInterfaceTypes.AlignBag;
AssemblyGenerator: TYPE = SVScene.AssemblyGenerator;
BoundBox: TYPE = SVBasicTypes.BoundBox;
BoundBlock: TYPE = SVBasicTypes.BoundBlock;
Camera: TYPE = SVModelTypes.Camera;
Color: TYPE = Imager.Color;
CoordSysGenerator: TYPE = SVScene.CoordSysGenerator;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CSGTree: TYPE = SVSceneTypes.CSGTree;
DisplayContextProc: TYPE = SVInterfaceTypes.DCProc;
DrawStyle: TYPE = SVModelTypes.DrawStyle;
EditToolData: TYPE = SVInterfaceTypes.EditToolData;
FeatureData: TYPE = SVInterfaceTypes.FeatureData;
FeedbackData: TYPE = AtomButtonsTypes.FeedbackData;
FileCamera: TYPE = SVSceneTypes.FileCamera;
GravityType: TYPE = SVInterfaceTypes.GravityType;
MasterObject: TYPE = SVSceneTypes.MasterObject;
Matrix4by4: TYPE = SV3d.Matrix4by4;
MouseButton: TYPE = Menus.MouseButton;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = SV3d.Point3d;
Primitive: TYPE = SVSceneTypes.Primitive;
Scene: TYPE = SVSceneTypes.Scene;
Slice: TYPE = SVSceneTypes.Slice;
SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = SVSceneTypes.SliceDescriptorGenerator;
SortedButtonHandle: TYPE = AtomButtonsTypes.SortedButtonHandle;
TriggerBag: TYPE = SVInterfaceTypes.TriggerBag;
TwoState: TYPE = AtomButtons.TwoState;
Vector2d: TYPE = SV2d.Vector2d;
Vector3d: TYPE = SV3d.Vector3d;
Viewer: TYPE = ViewerClasses.Viewer;
SVData: TYPE = SVInterfaceTypes.SVData;

GravityChoiceChange: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
forward: BOOL _ event.rest.first = $FlipForward;
SVState.CycleGravityType[svData, forward];
};

GravityExtentChange: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
extent: REAL _ SVState.GetGravityExtent[svData]; -- in inches
success: BOOL _ TRUE;
SELECT event.rest.first FROM
$ValueUp => {
IF extent < 256.0 THEN extent _ extent*2.0
ELSE {
Feedback.PutF[svData.feedback, oneLiner, "Can't extend gravity further than 256 inches."];
Feedback.Blink[svData.feedback];
success _ FALSE;
};
};
$ValueDown => extent _ extent/2.0;
ENDCASE => extent _ SVEditUser.GetDefaultGravityExtent[];
IF success THEN {
SVState.SetGravityExtent[svData, extent];
};
};

ToggleGravity: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.ToggleGravity[svData];
};

ToggleMidpoints: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.ToggleMidpoints[svData];
};
InitializeAlignments: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AllAlignmentsOff[NIL, svData];
SVState.SetShowAlignments[svData, TRUE];
SVState.SetGravity[svData, TRUE];
SVState.SetGravityType[svData, pointsPreferred];
SVEvent.InchScaleUnit[NIL, svData];
SVState.SetHeuristics[svData, TRUE];
};
AllAlignmentsOff: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SlopeLinePrompt[event, svData];
SlopePlanePrompt[event, svData];
SVState.SetMidpoints[svData, FALSE];
};

StandardSlopes: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.BuildScalarButtons[svData.hitTest.slopeHandle, svData, SVUserInput.EventNotify, NIL,
LIST[
["150", 150.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 150.0]]], FALSE],
["135", 135.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 135.0]]], FALSE],
["120", 120.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 120.0]]], FALSE],
["90", 90.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 90.0]]], FALSE],
["60", 60.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 60.0]]], FALSE],
["45", 45.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 45.0]]], FALSE],
["30", 30.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 30.0]]], FALSE],
["0", 0.0, LIST[LIST[$ChooseSlope, NEW[REAL _ 0.0]]], TRUE]
]];
};

StandardAzimuths: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.BuildScalarButtons[svData.hitTest.azimuthHandle, svData, SVUserInput.EventNotify, NIL,
LIST[
["150", 150.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 150.0]]], FALSE],
["135", 135.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 135.0]]], FALSE],
["120", 120.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 120.0]]], FALSE],
["90", 90.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 90.0]]], FALSE],
["60", 60.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 60.0]]], FALSE],
["45", 45.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 45.0]]], FALSE],
["30", 30.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 30.0]]], FALSE],
["0", 0.0, LIST[LIST[$ChooseAzimuth, NEW[REAL _ 0.0]]], TRUE]
]];
};

StandardSlopeLines: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.BuildSortedButtons[svData.hitTest.slopeLineHandle, svData, SVUserInput.EventNotify, NIL,
LIST[
["(0 0)",NEW[Vector2d_[0,0]], LIST[LIST[$ToggleSlopeLine,NEW[Vector2d_[0,0]]]],TRUE],
["(0 90)",NEW[Vector2d_[0,90]],LIST[LIST[$ToggleSlopeLine,NEW[Vector2d_[0,90]]]],FALSE],
["(90 0)",NEW[Vector2d_[90,0]], LIST[LIST[$ToggleSlopeLine,NEW[Vector2d_[90,0]]]],FALSE]
]];
IF event.first = $StandardSlopeLines THEN
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

StandardSlopePlanes: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.BuildSortedButtons[svData.hitTest.slopePlaneHandle, svData, SVUserInput.EventNotify, NIL,
LIST[
["(0 0)",NEW[Vector2d_[0,0]],LIST[LIST[$ToggleSlopePlane,NEW[Vector2d_[0,0]]]],FALSE],
["(0 90)",NEW[Vector2d_[0,90]],LIST[LIST[$ToggleSlopePlane,NEW[Vector2d_[0,90]]]],FALSE],
["(90 0)",NEW[Vector2d_[90,0]],LIST[LIST[$ToggleSlopePlane,NEW[Vector2d_[90,0]]]],TRUE]
]];
IF event.first = $StandardSlopePlanes THEN
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
StandardRadii: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.BuildScalarButtons[svData.hitTest.radiusHandle, svData, SVUserInput.EventNotify, NIL, LIST[
["1/18", 1.0/18.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 1.0/18.0]]], FALSE],
["1/9", 1.0/9.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 1.0/9.0]]], FALSE],
["1/8", 0.125, LIST[LIST[$ToggleRadius, NEW[REAL _ 0.125]]], FALSE],
["1/4", 0.25, LIST[LIST[$ToggleRadius, NEW[REAL _ 0.25]]], FALSE],
["1/3", 1.0/3.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 1.0/3.0]]], FALSE],
["1/2", 0.5, LIST[LIST[$ToggleRadius, NEW[REAL _ 0.5]]], FALSE],
["2/3", 2.0/3.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 2.0/3.0]]], FALSE],
["3/4", 0.75, LIST[LIST[$ToggleRadius, NEW[REAL _ 0.75]]], FALSE],
["1", 1.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 1.0]]], FALSE],
["2", 2.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 2.0]]], FALSE],
["4", 4.0, LIST[LIST[$ToggleRadius, NEW[REAL _ 4.0]]], FALSE]
]];
IF event.first = $StandardRadii THEN
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
AzimuthPrompt: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
GetAzimuth: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
AddAzimuth: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
azimuth: REAL;
success, alreadyThere: BOOL;
[azimuth, success] _ SVState.GetAzimuthValue[svData];
IF NOT success THEN RETURN;
alreadyThere _ SVState.AddAzimuth[svData, azimuth];
IF NOT alreadyThere THEN { -- a new button was added
SVWindow.RestoreScreenAndInvariants[paintAction: $None, svData: svData, remake: none, backgndOK: TRUE, edited: TRUE, okToClearFeedback: TRUE];
};
};

DeleteAzimuth: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.DeleteAzimuth[svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

ChooseAzimuth: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
azimuth: REAL _ NARROW[event.rest.first, REF REAL]^;
AtomButtons.SetAllScalarStates[svData, svData.hitTest.azimuthHandle, FALSE];
AtomButtons.SetScalarState[svData, svData.hitTest.azimuthHandle, azimuth, TRUE];
};
SlopePrompt: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
};

GetSlope: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
};

AddSlope: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
slope: REAL;
success, alreadyThere: BOOL;
[slope, success] _ SVState.GetSlopeValue[svData];
IF NOT success THEN RETURN;
alreadyThere _ SVState.AddSlope[svData, slope];
IF NOT alreadyThere THEN { -- a new button was added
SVWindow.RestoreScreenAndInvariants[paintAction: $None, svData: svData, remake: none, backgndOK: TRUE, edited: TRUE, okToClearFeedback: TRUE];
};
};

DeleteSlope: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.DeleteSlope[svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

ChooseSlope: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
slope: REAL _ NARROW[event.rest.first, REF REAL]^;
AtomButtons.SetAllScalarStates[svData, svData.hitTest.slopeHandle, FALSE];
AtomButtons.SetScalarState[svData, svData.hitTest.slopeHandle, slope, TRUE];
};
SlopeLinePrompt: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.SetAllScalarStates[svData, svData.hitTest.slopeLineHandle, FALSE];
IF event.first = $SlopeLinePrompt THEN SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
GetSlopeLine: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
AddSlopeLine: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AddAzimuth[event, svData];
AddSlope[event, svData];
NewSlopeLine[event, svData];
};

NewSlopeLine: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
azimuth, slope: REAL;
alreadyThere: BOOL;
azimuth _ SVState.GetSelectedAzimuth[svData];
slope _ SVState.GetSelectedSlope[svData];
alreadyThere _ SVState.AddSlopeLine[svData, azimuth, slope];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

DeleteSlopeLine: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.DeleteSlopeLines[svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

ToggleSlopeLine: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
restoreNow: BOOL _ event.first = $ToggleSlopeLine;
ToggleAlignmentAux[event, svData, svData.hitTest.slopeLineHandle, restoreNow];
};

ToggleAlignmentAux: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData, handle: SortedButtonHandle, restoreNow: BOOL] = {
FindAzimuthSlope: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [newState: BOOL, newName: Rope.ROPE _ NIL, newValue: REF ANY, done: BOOL _ FALSE] = {
azimuthSlope: Vector2d _ NARROW[value, REF Vector2d]^;
IF ABS[azimuthSlope[1]-azimuth] < epsilon AND ABS[azimuthSlope[2]-slope] < epsilon
THEN {totalNewState _ newState _ NOT state; done _ TRUE}
ELSE newState _ state;
newName _ name;
newValue _ value;
};
epsilon: REAL = 0.001;
totalNewState: BOOL _ FALSE;
azimuth, slope: REAL;
azimuthSlope: Vector2d;
azimuthSlope _ NARROW[event.rest.first, REF Vector2d]^;
azimuth _ azimuthSlope[1];
slope _ azimuthSlope[2];
AtomButtons.WriteSortedButtons[handle, FindAzimuthSlope, svData]; -- alters totalNewState
IF restoreNow AND totalNewState THEN
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE]
ELSE SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

SlopePlanePrompt: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.SetAllScalarStates[svData, svData.hitTest.slopePlaneHandle, FALSE];
IF event.first = $SlopePlanePrompt THEN SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

GetSlopePlane: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
};

AddSlopePlane: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AddAzimuth[event, svData];
AddSlope[event, svData];
NewSlopePlane[event, svData];
};
NewSlopePlane: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
azimuth, slope: REAL;
alreadyThere: BOOL;
azimuth _ SVState.GetSelectedAzimuth[svData];
slope _ SVState.GetSelectedSlope[svData];
alreadyThere _ SVState.AddSlopePlane[svData, azimuth, slope];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
DeleteSlopePlane: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.DeleteSlopePlanes[svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
ToggleSlopePlane: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
restoreNow: BOOL _ event.first = $ToggleSlopePlane;
ToggleAlignmentAux[event, svData, svData.hitTest.slopePlaneHandle, restoreNow];
};
RadiusPrompt: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AtomButtons.SetAllScalarStates[svData, svData.hitTest.radiusHandle, FALSE];
IF event.first = $RadiusPrompt THEN SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
GetRadius: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
};
AddRadius: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
radius: REAL;
success, alreadyThere: BOOL;
[radius, success] _ SVState.GetRadiusValue[svData];
IF NOT success THEN RETURN;
alreadyThere _ SVState.AddRadius[svData, radius];
IF NOT alreadyThere THEN { -- a new button was added
SVWindow.RestoreScreenAndInvariants[paintAction: $None, svData: svData, remake: none, backgndOK: TRUE, edited: TRUE, okToClearFeedback: TRUE];
};
};
DeleteRadius: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVState.DeleteRadii[svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
ToggleRadius: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
restoreNow: BOOL _ event.first = $ToggleSlopePlane;
FindRadius: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [newState: BOOL, newName: Rope.ROPE _ NIL, newValue: REF ANY, done: BOOL _ FALSE] = {
eachRad: REAL _ NARROW[value, REF REAL]^;
IF ABS[eachRad-radius] < epsilon THEN {totalNewState _ newState _ NOT state; done _ TRUE}
ELSE newState _ state;
newName _ name;
newValue _ value;
};
epsilon: REAL = 0.001;
totalNewState: BOOL _ FALSE;
radius: REAL;
handle: SortedButtonHandle _ svData.hitTest.radiusHandle;
radius _ NARROW[event.rest.first, REF REAL]^;
AtomButtons.WriteSortedButtons[handle, FindRadius, svData]; -- alters totalNewState
IF restoreNow AND totalNewState THEN
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE]
ELSE SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
MeasureSlopeHit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
viewer: Viewer _ svData.measure.slopeView;
ViewerTools.SetSelection[viewer];
};
MeasureAzimuthHit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
viewer: Viewer _ svData.measure.azimuthView;
ViewerTools.SetSelection[viewer];
};
MeasureRadiusHit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
viewer: Viewer _ svData.measure.radiusView;
ViewerTools.SetSelection[viewer];
};
Painter: PUBLIC PROC [proc: DisplayContextProc, svData: SVData _ NIL] = {
}; -- end of Painter

UpdateHeader: PUBLIC PROC [pictureFile: Rope.ROPE, svData: SVData] = {
headerRope: Rope.ROPE;
aisName: Rope.ROPE;
viewName: Rope.ROPE _ svData.camera.viewName;
IF pictureFile = NIL THEN pictureFile _ svData.scene.name;
headerRope _ Rope.Cat[viewName, " View of Solid Scene: ", pictureFile];
aisName _ Rope.Concat[SVFiles.FilenameMinusExtension[pictureFile], ".ais"];
svData.outer.name _ headerRope;
ViewerOps.PaintViewer[svData.outer, caption, FALSE, NIL];
};

NewVersion: PUBLIC PROC [viewer: Viewer] = {
svData: SVData _ NARROW[viewer.data];
scene: Scene _ svData.scene;
scene.dirty _ TRUE;
svData.scene.tree.outOfDate _ TRUE;
svData.outer.newVersion _ TRUE;
UpdateHeader[scene.name, svData];
};

SceneOldVersion: PUBLIC PROC [svData: SVData] = {
scene: Scene _ svData.scene;
SVViewersOnScene.SceneOldVersion[svData, scene];
};

OldVersion: PUBLIC PROC [viewer: Viewer] = {
svData: SVData _ NARROW[viewer.data];
scene: Scene _ svData.scene;
scene.dirty _ FALSE;
svData.scene.tree.outOfDate _ TRUE; -- OldVersion may result from loading a new scene, or creating an empty scene.  In either case, the ray tracing tree is out of date.  Set flag just in case.
svData.outer.newVersion _ FALSE;
UpdateHeader[scene.name, svData];
};

EraseAndDrawScene: PUBLIC PROC [svData: SVData] = {
SVWindow.RestoreScreenAndInvariants[$PaintEntireScene, svData];
};

DrawSceneButton: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVWindow.RestoreScreenAndInvariants[$PaintEntireScene, svData];
};

Clear: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
oldScene: Scene _ svData.scene;
newScene: Scene;
oldScreenCS: CoordSystem;
fileCamera: FileCamera;
cameraName: Rope.ROPE;
drawStyle: DrawStyle;

oldScreenCS _ svData.camera.screenCS;
newScene _ svData.scene _ SVScene.CreateScene["NoName.pic"];
SVSelections.KillSkitterAndSelections[editToolData];
UpdateHeader[newScene.name, svData];
SVEvent.Selected[event, svData];

IF newScene.cameraOrder = NIL THEN fileCamera _ newScene.cameras.first
ELSE {
success: BOOL;
cameraName _ newScene.cameraOrder.first;
[fileCamera, success] _ SVScene.FindFileCameraFromName[cameraName, newScene];
IF NOT success THEN {
fileCamera _ newScene.cameras.first;
Feedback.Append[svData.feedback, Rope.Cat["Camera ", cameraName, " not found"], oneLiner];
Feedback.Blink[svData.feedback];
};
};
drawStyle _ SVEvent.CurrentStyle[svData];
svData.camera _ SVScene.CreateCamera[newScene.coordSysRoot, SVCoordSys.CopyCoordSysFromAnyTree[oldScreenCS, "SCREEN", NIL, NIL], drawStyle];
SVScene.StuffCameraFromFileCamera[svData.camera, fileCamera, svData.camera.style, newScene];

SVViewersOnScene.NotifyOfEmpty[svData: svData, from: oldScene, to: svData.scene];

SceneOldVersion[svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, svData: svData, remake: triggerBag, backgndOK: FALSE, edited: FALSE, okToClearFeedback: TRUE];
};

Restore: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
success: BOOL;
wdir: Rope.ROPE;
scene: Scene _ svData.scene;

wdir _ editToolData.originalWorkingDirectory;
[scene, success] _ SVViewersOnScene.LoadScene[svData, scene.name, wdir];
IF success THEN {
svData.scene _ scene;
SVSelections.KillSkitterAndSelections[editToolData];
SceneOldVersion[svData];
UpdateHeader[scene.name, svData];
EraseAndDrawScene[svData];
SVEvent.Selected[event, svData];
};
}; -- end of Reset

Save: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
success: BOOL;
sceneName: Rope.ROPE;
scene: Scene _ svData.scene;
sceneName _ FileNames.StripVersionNumber[scene.name];
success _ SVViewersOnScene.SaveScene[svData, sceneName];
IF success THEN {
SVEvent.Selected[event, svData];
SceneOldVersion[svData];
UpdateHeader[scene.name, svData];
};
}; -- end of Save

MergeScene: PROC [realScene, tempScene: Scene, feedback: FeedbackData] = {
sceneAssembly, sliceParent, sliceCopy: Slice;
g: AssemblyGenerator _ SVScene.PrimAssembliesInScene[tempScene];
sceneAssembly _ realScene.assembly;
SVSelect.DeselectAll[realScene, normal];
FOR slice: Slice _ SVScene.NextAssembly[g], SVScene.NextAssembly[g] UNTIL slice = NIL DO
[----, sliceParent] _ SVScene.FindAssemblyFromName[slice.name, tempScene];
sliceCopy _ SVScene.CopyAssemblyAndSonsUniqueNames[slice, tempScene, realScene, sceneAssembly, feedback];
SVSelect.SelectEntireSlice[sliceCopy, realScene, normal];
ENDLOOP;
};

GetMergeAux: PROC [fullName: Rope.ROPE, wdir: Rope.ROPE, versionSpecified: BOOL _ FALSE, event: ATOM, opName: Rope.ROPE, svData: SVData] = {
success: BOOL;
scene: Scene;
oldScreenCS: CoordSystem _ svData.camera.screenCS;
startTime: BasicTime.GMT;
endTime: BasicTime.GMT;
totalTime: INT;
timeRope: Rope.ROPE;
drawStyle: DrawStyle;
cameraName: Rope.ROPE;

startTime _ BasicTime.Now[];
IF event = $Get THEN {
fileCamera: FileCamera;
[scene, success] _ SVViewersOnScene.LoadScene[svData, fullName, wdir];
IF NOT success THEN RETURN;
IF scene.cameraOrder = NIL THEN fileCamera _ scene.cameras.first
ELSE {
cameraName _ scene.cameraOrder.first;
[fileCamera, success] _ SVScene.FindFileCameraFromName[cameraName, scene];
IF NOT success THEN {
fileCamera _ scene.cameras.first;
Feedback.Append[svData.feedback, Rope.Cat["Camera ", cameraName, " not found"], oneLiner];
Feedback.Blink[svData.feedback];
};
};
drawStyle _ SVEvent.CurrentStyle[svData];
svData.camera _ SVScene.CreateCamera[scene.coordSysRoot, SVCoordSys.CopyCoordSysFromAnyTree[oldScreenCS, "SCREEN", NIL, NIL], drawStyle];
SVScene.StuffCameraFromFileCamera[svData.camera, fileCamera, svData.camera.style, scene];
svData.scene _ scene;
UpdateHeader[fullName, svData];
SceneOldVersion[svData];
}
ELSE {
[scene, success] _ SVFiles.OpenScene[fullName, wdir, svData.feedback];
IF NOT success THEN RETURN;
MergeScene[svData.scene, scene, svData.feedback];
};
endTime _ BasicTime.Now[];

totalTime _ BasicTime.Period[startTime, endTime];
timeRope _ IO.PutFR[" Done in time (%r)", [integer[totalTime]]];
Feedback.Append[svData.feedback, timeRope, oneLiner];

SVEvent.Selected[NIL, svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, svData: svData, remake: triggerBag, backgndOK: FALSE, edited: event=$Merge, okToClearFeedback: FALSE];
};

Get: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ NARROW[svData.editToolData];
picName: Rope.ROPE _ NARROW[event.rest.first];
success: BOOL;
fullName: Rope.ROPE;
wdir: Rope.ROPE;

wdir _ editToolData.originalWorkingDirectory;
[----, fullName, success] _ GetSolidviews3dFileName[event.rest, wdir, svData.feedback];
IF NOT success THEN GOTO Abort;
ClearAux[event, svData];
GetMergeAux[fullName, wdir, FALSE, $Get, "Get", svData];
EXITS
Abort => {
Feedback.Append[svData.feedback, "Could not find requested file", oneLiner];
Feedback.Blink[svData.feedback];
};
}; -- end of Get

Merge: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ NARROW[svData.editToolData];
fullName: Rope.ROPE;
wdir: Rope.ROPE;
success, versionSpecified: BOOL _ FALSE;

wdir _ editToolData.originalWorkingDirectory;
[----, fullName, success] _ GetSolidviews3dFileName[event.rest, wdir, svData.feedback];
IF NOT success THEN {
Feedback.Append[svData.feedback, "Could not find requested file", oneLiner];
GOTO Abort;
};
GetMergeAux[fullName, wdir, versionSpecified, $Merge, "Merge", svData];
EXITS
Abort => Feedback.Blink[svData.feedback];
};

ClearAux: PROC [event: LIST OF REF ANY, svData: SVData] = {
svData.refresh.overlayList _ NIL;
SVSelect.DeselectAllAllClasses[svData.scene];
svData.editToolData.skitter _ SVCaret.Create[];
svData.scene.anchor _ SVCaret.Create[];
svData.aborted _ ALL[FALSE];
};

Store: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ NARROW[svData.editToolData];
wdir: Rope.ROPE;
success: BOOL _ TRUE;
picName: Rope.ROPE _ NARROW[event.rest.first];
fullName: Rope.ROPE;
scene: Scene _ svData.scene;
emergency: BOOL _ FALSE;

wdir _ editToolData.originalWorkingDirectory;
[----, fullName, success] _ GetSolidviews3dFileName[event.rest, svData.currentWDir, svData.feedback, emergency];
IF NOT success THEN RETURN;
success _ SVViewersOnScene.StoreScene[svData, scene, fullName];
IF success THEN {
UpdateHeader[fullName, svData];
SVEvent.Selected[event, svData];
SceneOldVersion[svData];
UpdateHeader[scene.name, svData];
};
}; -- end of Store

GetSolidviews3dFileName: PROC [event: LIST OF REF ANY, currentWDir: Rope.ROPE, feedback: FeedbackData, emergency: BOOL _ FALSE] RETURNS [fileName, fullName: Rope.ROPE _ NIL, success: BOOL _ TRUE] = {
RopeFromRef: PROC [ref: REF ANY] RETURNS [rope: Rope.ROPE] ~ {
WITH ref SELECT FROM
text: REF TEXT => RETURN[Rope.FromRefText[text] ];
r: Rope.ROPE => RETURN[r];
ENDCASE => ERROR;
};
fileName _ IF event#NIL AND event.first#NIL THEN RopeFromRef[event.first] ELSE "NoName";
[fullName, success, ----] _ GGFileOps.GetGenericFileName[fileName, currentWDir, "gg3d", LIST["gargoyle", "ip", "interpress", "script", "log", "ais"], feedback, emergency];
};
Split: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
scene: Scene _ svData.scene;
SVViewersOnScene.Split[svData, scene];
};

OpenScript: PUBLIC Menus.ClickProc = {
svData: SVData _ NARROW[clientData];
name: Rope.ROPE _ ViewerTools.GetSelectionContents[];
SVSessionLog.OpenScript[name, svData];
IF svData.debug.logStream#NIL THEN [] _ SlackProcess.EnableSessionLogging[svData.slackHandle];
};
AppendToScript: PUBLIC Menus.ClickProc = {
svData: SVData _ NARROW[clientData];
name: Rope.ROPE _ ViewerTools.GetSelectionContents[];
SVSessionLog.AppendScript[name, svData];
IF svData.debug.logStream#NIL THEN [] _ SlackProcess.EnableSessionLogging[svData.slackHandle];
};
CloseScript: PUBLIC Menus.ClickProc = {
svData: SVData _ NARROW[clientData];
[] _ SlackProcess.DisableSessionLogging[svData.slackHandle];
SVSessionLog.CloseScript[svData];
};
PlaybackScript: PUBLIC Menus.ClickProc = {
svData: SVData _ NARROW[clientData];
name: Rope.ROPE _ ViewerTools.GetSelectionContents[];
SVSessionLog.PlaybackFromFile[name, svData];
};
FastPlayScript: PUBLIC Menus.ClickProc = {
svData: SVData _ NARROW[clientData];
name: Rope.ROPE _ ViewerTools.GetSelectionContents[];
SVUserInput.EventNotify[svData, LIST[$DisableRefresh]];
SVSessionLog.PlaybackFromFile[name, svData];
SVUserInput.EventNotify[svData, LIST[$EnableRefresh]];
SVUserInput.EventNotify[svData, LIST[$Refresh, $DoNotClearFeedback]];
};

RayCast: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ NARROW[svData.editToolData];
scene: Scene _ svData.scene;
camera: Camera _ svData.camera;
feedback: FeedbackData _ svData.feedback;
tree: CSGTree;
startTime: BasicTime.GMT;
afterTreeTime: BasicTime.GMT;
endTime: BasicTime.GMT;
totalTime: INT;
msgRope, wdir: Rope.ROPE;
aisFileRope: Rope.ROPE;
success: BOOL;
maxRed, maxGreen, maxBlue, maxBlack: NAT;

aisFileRope _ Rope.Concat[SVFiles.FilenameMinusExtension[scene.name], ".ais"];
wdir _ editToolData.originalWorkingDirectory;
success _ TRUE;
[aisFileRope,,] _ FS.ExpandName[aisFileRope, wdir
! FS.Error => IF error.group = user THEN {
Feedback.Append[svData.feedback, Rope.Concat["RayCast: ", error.explanation], oneLiner];
success _ FALSE;
CONTINUE;
}
];
IF NOT success THEN RETURN;

startTime _ BasicTime.Now[];
tree _ SVSceneToTree.AssemblyToTree[scene.assembly, scene, camera];
afterTreeTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[from: startTime, to: afterTreeTime];
Feedback.PutF[svData.feedback, oneLiner, "Building tree took (%r)",[integer[totalTime]]];
[success, maxRed, maxGreen, maxBlue, maxBlack] _ SVCastRays.DrawTree[tree, scene.lightSources, camera, aisFileRope, event.first=$RayCast, SVEvent.RayCastProgress, svData, feedback];
IF NOT success THEN {
Feedback.PutF[feedback, end, "...Raycast aborted."];
RETURN;
};
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[from: afterTreeTime, to: endTime];
Feedback.PutF[svData.feedback, begin, " Raycast took (%r).",[integer[totalTime]]];
msgRope _ IO.PutFR[" Max values were: red: (%g) green: (%g) blue: (%g) black: (%g)\n",
[integer[maxRed]], [integer[maxGreen]], [integer[maxBlue]], [integer[maxBlack]]];
Feedback.AppendTypescript[svData.feedback, msgRope, end];
SVEvent.DrawBlackAndWhite[event, svData];
}; -- end of RayCast

StopRays: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
camera: Camera _ svData.camera;
camera.abort _ TRUE;
};

ARay: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
scene: Scene _ svData.scene;
camera: Camera _ svData.camera;
outHandle: IO.STREAM _ Feedback.GetTypescriptStream[$Solidviews];
x, y: REAL;
tree: CSGTree _ SVSceneToTree.AssemblyToTree[scene.assembly, scene, camera];
color: Color;
[x, y] _ GGViewerOps.GetTwoReals[svData.textSection.xyz];
color _ SVCastRays.SingleRay[[x, y], tree, scene.lightSources, camera, svData.feedback, TRUE];
Feedback.PutFTypescript[svData.feedback, begin, "[%g,%g]: ",[real[x]], [real[y]]];
SVParseOut.FileoutColor[outHandle, color];
Feedback.PutFTypescript[svData.feedback, end, "\n"];
}; -- end of ARay

CycleSelection: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
scene: Scene _ svData.scene;
pointWorld: Point3d;
normalWorld: Vector3d;
feature: FeatureData;
hitData: REF ANY;
featureCycler: SVGravity.FeatureCycler _ SVState.GetSelectionCycler[svData];
direction: ATOM _ NARROW[event.rest.first];

SELECT direction FROM
$Forward => [pointWorld, normalWorld, feature, hitData] _ SVGravity.NextFeature[featureCycler];
$Backward => [pointWorld, normalWorld, feature, hitData] _ SVGravity.PreviousFeature[featureCycler];
ENDCASE => ERROR;
SVMouseEvent.SelectFromFeature[svData, featureCycler.cameraPt, pointWorld, normalWorld, feature, hitData];
};
BlockSelectNew: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
AreaSelectAux[svData: svData, new: TRUE, paint: TRUE];
};

BlockSelectNewAndDelete: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
IF SVSelect.NoSelections[svData.scene, normal] THEN RETURN
ELSE { -- there were some original selections
oldSelectedGen: SliceDescriptorGenerator _ SVSelect.SelectedSlices[svData.scene, normal];
startBox: BoundBox _ SVBoundBox.BoundBoxOfSelected[svData.scene, svData.camera, normal];
AreaSelectAux[svData: svData, new: TRUE, paint: FALSE];
FOR sliceD: SliceDescriptor _ SVSelect.NextSliceDescriptor[oldSelectedGen], SVSelect.NextSliceDescriptor[oldSelectedGen] UNTIL sliceD=NIL DO
SVSelect.DeselectSliceAllClasses[sliceD.slice, svData.scene];
SVScene.DeleteSlice[svData.scene, sliceD.slice];
ENDLOOP;
SVCaret.NoAttractor[editToolData.skitter];
svData.refresh.startBoundBox^ _ startBox^;
SVWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, svData: svData, remake: triggerBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
};

AreaSelectAux: PROC [svData: SVData, new: BOOL _ TRUE, paint: BOOL _ TRUE] = {
selectedGen: SliceDescriptorGenerator;
blockD: SliceDescriptor;
block: BoundBlock;
IF SVSelect.NoSelections[svData.scene, normal] THEN RETURN;
selectedGen _ SVSelect.SelectedSlices[svData.scene, normal];
IF new THEN SVSelect.DeselectAll[svData.scene, normal]; -- get rid of old selection
blockD _ SVSelect.NextSliceDescriptor[selectedGen];
block _ SVAssembly.GetBoundBlock[blockD.slice];
SVScene.SelectInBlock[svData.scene, block, normal];
IF paint THEN SVWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
}; -- end AreaSelectAux

MakeHot: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
sliceDescGen: SliceDescriptorGenerator _ SVSelect.SelectedSlices[svData.scene, normal];
FOR sliceD: SliceDescriptor _ SVSelect.NextSliceDescriptor[sliceDescGen], SVSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
SVSelect.SelectSlice[sliceD, svData.scene, hot];
ENDLOOP;
sliceDescGen _ SVSelect.SelectedSlices[svData.scene, hot];
FOR sliceD: SliceDescriptor _ SVSelect.NextSliceDescriptor[sliceDescGen], SVSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
sliceFeature: FeatureData _ SVAlign.AddHotSlice[sliceD, svData.hitTest.triggerBag]; -- fix triggerBag
alignObjects: LIST OF FeatureData _ SVAlign.IncrementalFilters[sliceFeature, svData.hitTest, NOT SVState.GetShowAlignments[svData], svData.hitTest.alignBag];
SVRefresh.NoteNewForeground[alignObjects, svData]; -- fix foreground plane
ENDLOOP;
SVWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeHot, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

MakeCold: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
sliceDescGen: SliceDescriptorGenerator _ SVSelect.SelectedSlices[svData.scene, normal];
FOR sliceD: SliceDescriptor _ SVSelect.NextSliceDescriptor[sliceDescGen], SVSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
SVSelect.DeselectSlice[sliceD.slice, sliceD.parts, svData.scene, hot];
ENDLOOP;
SVCaret.NoAttractor[svData.editToolData.skitter];
SVWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeCold, svData: svData, remake: triggerBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];

};

MakeAllHot: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
triggerBag: TriggerBag _ svData.hitTest.triggerBag;
alignBag: AlignBag _ svData.hitTest.alignBag;
sliceDescGen: SliceDescriptorGenerator;
sliceGen: SVScene.AssemblyGenerator _ SVScene.PrimAssembliesInScene[svData.scene];
FOR slice: Slice _ SVScene.NextAssembly[sliceGen], SVScene.NextAssembly[sliceGen] UNTIL slice = NIL DO
sliceD: SliceDescriptor _ SVAssembly.NewParts[slice, NIL, [0,0,0], topLevel];
SVSelect.SelectSlice[sliceD, svData.scene, hot];
ENDLOOP;
sliceDescGen _ SVSelect.SelectedSlices[svData.scene, hot]; -- expects only outline types !!
FOR sliceD: SliceDescriptor _ SVSelect.NextSliceDescriptor[sliceDescGen], SVSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
feature: FeatureData _ SVAlign.AddHotSlice[sliceD, triggerBag];
alignObjects: LIST OF FeatureData;
alignObjects _ SVAlign.IncrementalFilters[feature, svData.hitTest, NOT SVState.GetShowAlignments[svData], alignBag];
SVRefresh.NoteNewForeground[alignObjects, svData];
ENDLOOP;
SVWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeHot, svData: svData, remake: triggerBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

MakeAllCold: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
sliceDescGen: SliceDescriptorGenerator _ SVSelect.SelectedSlices[svData.scene, hot];
FOR sliceD: SliceDescriptor _ SVSelect.NextSliceDescriptor[sliceDescGen], SVSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
SVSelect.DeselectSlice[sliceD.slice, sliceD.parts, svData.scene, hot];
ENDLOOP;
SVCaret.NoAttractor[svData.editToolData.skitter];
SVWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeCold, svData: svData, remake: triggerBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

DropAnchor: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
SVCaret.Copy[from: editToolData.skitter, to: svData.scene.anchor];
[] _ SVAlign.CreateAnchorTrigger[SVState.GetAnchor[svData], svData.hitTest.triggerBag]; -- anchor can trigger
SVWindow.RestoreScreenAndInvariants[paintAction: $AnchorAdded, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};

LiftAnchor: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
IF SVCaret.Exists[svData.scene.anchor] THEN {
SVCaret.Kill[svData.scene.anchor];
SVWindow.RestoreScreenAndInvariants[paintAction: $AnchorRemoved, svData: svData, remake: triggerBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
};
StandardAlignments: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
ToggleShowColors: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
stateInfo: TwoState _ svData.refresh.showColors;
AtomButtons.SwitchBinaryState[stateInfo];
SVWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireViewer, svData: svData, remake: none, backgndOK: FALSE, edited: FALSE, okToClearFeedback: TRUE];
};

DrawCoordSystems: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVWindow.RestoreScreenAndInvariants[$DrawCoordSystems, svData];
};

DrawBoundBoxes: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVWindow.RestoreScreenAndInvariants[$DrawBoundBoxes, svData];
}; -- end of DrawBoundBoxes

DrawBoundSpheres: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVWindow.RestoreScreenAndInvariants[$DrawBoundSpheres, svData];
}; -- end of DrawBoundSpheres

DrawPt: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
camera: Camera _ svData.camera;
SVWindow.RestoreScreenAndInvariants[$DrawPt, svData];
};
CrossHairs: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SVWindow.RestoreScreenAndInvariants[$DrawCrossHairs, svData];
}; -- end of CrossHairs

TestGravity: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
xRandomStream, yRandomStream: Random.RandomStream;
testPoint: Point2d;
pointCount: INT _ NARROW[event.rest.first, REF INT]^;
x, y: INT;
totalCount, hitCount, diffCount: NAT _ 0;
surfacePtWORLD: Point3d;
camera: Camera _ svData.camera;
scene: Scene _ svData.scene;
screenCS: CoordSystem _ camera.screenCS;
feature: FeatureData;
gravityType: GravityType _ SVState.GetGravityType[svData];

xRandomStream _ Random.Create[svData.actionArea.cw];
yRandomStream _ Random.Create[svData.actionArea.ch];
UNTIL totalCount >= pointCount DO
x _ Random.NextInt[xRandomStream];
y _ Random.NextInt[yRandomStream];
testPoint _ [x, y];
testPoint _ SVCoordSys.ScreenToCamera[testPoint, screenCS];
svData.refresh.spotPoint _ testPoint;
[surfacePtWORLD, ----, feature] _ SVGravity.RayMap[testPoint, svData.hitTest.t, NIL, svData.hitTest.sceneBag, svData];
totalCount _ totalCount + 1;
IF feature = NIL THEN {
SVWindow.RestoreScreenAndInvariants[paintAction: $PaintSpot, svData: svData];
}
ELSE {
hitCount _ hitCount + 1;
svData.refresh.hitPoint _ surfacePtWORLD;
SVWindow.RestoreScreenAndInvariants[paintAction: $PaintHitLine, svData: svData];
};
ENDLOOP;
Feedback.PutF[svData.feedback, oneLiner, "Tested %g total points.  %g hits.", [integer[totalCount]], [integer[hitCount]]];
}; -- end TestGravity

ResetStatistics: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
CodeTimer.ResetTable[CodeTimer.GetTable[$Solidviews]];
};
PrintStatistics: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
f: IO.STREAM _ Feedback.GetTypescriptStream[$Solidviews];
CodeTimer.PrintTable[f, CodeTimer.GetTable[$Solidviews]];
};

RaiseSIGNAL: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
scene: SVSceneTypes.Scene _ svData.scene;
firstSlice, secondSlice: SVSceneTypes.Slice;
sliceGen: SVScene.AssemblyGenerator;
sliceGen _ SVScene.PrimAssembliesInScene[scene];
firstSlice _ SVScene.NextAssembly[sliceGen];
secondSlice _ SVScene.NextAssembly[sliceGen];
SIGNAL Feedback.Problem[msg: "Client requested SIGNAL"];
};

END.

่File: SVEventImplA.mesa
Author: Eric Bier in October 1982
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Last edited by Bier on September 24, 1987 2:43:47 pm PDT
Contents: Code to respond to button presses made in an SVViewer
Gravity Line Operations

Alignment Lines

["", 999.9, LIST[$NoOp, NEW[REAL _ 999.9]], FALSE],  -- dummy first button
["", 999.9, LIST[$NoOp, NEW[REAL _ 999.9]], FALSE],  -- dummy first button

Azimuth Line
adds azimuth from azimuth viewer in measure line 
If azimuthViewValue was set internally, viewer and value will be consistent.
If AzimuthValue viewer was set by typein, viewer and value will be inconsistent.

Slope Line
Since slopes are mutually exclusive, there is no reason to turn them all off.  We could set the slope to 0 or do nothing at all.
adds slope from angle viewer in measure line 
If slopeViewValue was set internally, viewer and value will be consistent.
If SlopeValue viewer was set by typein, viewer and value will be inconsistent.

Slope Line Line
Slope Plane Line

Radius Line

Coordinate Line

MISCELLANEOUS

Tell EditTool that scene is no longer dirty.  EditTool will call back all affected viewers using OldVersion (see below).
DRAW SOMETHING IN A SOLID VIEWER (Fetches a display context first)


MENU PROCS

Creates a new empty scene for the viewer to view.
This must be done after NotifyOfEmpty since SVViewersOnScene expects to register to the newly created NoName scene before it resets the [New Version] headers.

Reload this scene from its backing file.
TIMING VARIABLES
Choose a Tripod (set up the camera)
Finish Up
ASSERT: event.first=$Merge, event.rest=filename
svData.scene _ SVScene.CreateScene["NoName.pic"];
aisName _ Rope.Concat[SVFiles.FilenameMinusExtension[fullName], ".ais"];

Create a new viewer onto this scene.  Update the ring of links joining all viewers onto this scene,
Script Menu
in SVEventImplA.OpenScript
IF mouseButton = red OR mouseButton = blue THEN {
[success, maxRed, maxGreen, maxBlue, maxBlack] _ SVCastRays.DrawTree[tree, scene.lightSources, camera, aisFileRope, mouseButton = blue, SVEvent.RayCastProgress, svData, feedback];
}
ELSE { -- yellow bug
cameraPoint: Point2d;
[cameraPoint, ----] _ SVSelections.GetPositionSkitter[];

[success, maxRed, maxGreen, maxBlue, maxBlack] _ SVCastRays.DrawTreeWithStartLine[cameraPoint[2], tree, scene.lightSources, camera, aisFileRope, mouseButton = blue, SVEvent.RayCastProgress, svData, feedback];
};
Get x and y from appropriate slots.  Interpret this as camera coordinates and draw a cross.
Select Menu

Select all objects within selected block and delete original selection.

Hot Spots Menu
Make slices hot.
Fix the trigger bags, object bags, and Foreground plane (for efficiency).
Repaint
Update the hot and current trigger bags.
SVAlign.RemoveAnchorTrigger[svData.hitTest.triggerBag]; -- don't trigger
SVAlign.RemoveAnchorTrigger[svData.hitTest.sceneBag]; -- don't be gravity active


Other Style Buttons
viewer is Container
get x and y from appropriate slots.  Interpret this as camera coordinates and draw a cross.
viewer is the crossHairs button
Within the bounds of the viewer, randomly choose mouse positions.  See if that mouse position is in range of any object.  If so, draw a dot at that point.  Repeat until 100 points have been drawn.
ส,a˜Iheadš
œ™Jš
œ!™!Jšœ
ฯm
œ1™<Jš
œ8™8Jš
œ?™?J˜š
ฯk	˜	Jšœxžœ žœ›˜บ—J˜šœžœ
ž˜Jšžœxžœžœ˜’Jšžœ
˜—J˜Jš
ž˜˜Jšœ
žœ˜+Jšœžœ˜4Jšœ
žœ˜'Jšœžœ˜+Jšœžœ˜#Jšœžœ˜Jšœžœ˜4Jšœ
žœ˜-Jšœ	žœ˜%Jšœžœ˜3Jšœžœ˜)Jšœžœ!˜3Jšœ
žœ ˜1Jšœžœ!˜3Jšœžœ˜+Jšœ
žœ ˜1Jšœžœ˜/Jšœžœ˜#Jšœ
žœ˜&Jšœ	žœ˜Jšœ	žœ˜Jšœžœ˜)Jšœžœ˜!Jšœžœ˜!Jšœžœ ˜5Icodešœžœ)˜GJšœžœ'˜?Jšœžœ˜/Jšœ
žœ˜&Jšœ
žœ˜Jšœ
žœ˜Jšœžœ˜$Jšœžœ˜'J˜—Iproc™šฯnœžœ
žœ	žœ
žœ
žœ
žœ˜MMšœ	žœ#˜0Mš
œ*˜*M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜MLšœžœ%ฯc˜=Lšœ	žœžœ
˜šžœž˜š
œ
˜
Lšžœžœ˜*šžœ˜Lš
œZ˜ZLš
œ ˜ Lšœ
žœ
˜L˜—L˜—Lš
œ"˜"Lšžœ2˜9—šžœ	žœ˜Lš
œ)˜)L˜—M˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GLš
œ˜M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ILš
œ ˜ M˜—J™M™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜NMšœžœ
˜Mšœ"žœ˜(Mšœžœ˜!Mš
œ0˜0Mšœžœ
˜#Mšœžœ˜$M˜—J™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JLš
œ˜Lš
œ ˜ Lšœžœ˜$L˜L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜Hšœ\žœ
˜`šžœ
˜Lš
œžœžœ
žœžœ ™JLšœžœ
žœžœ
žœ
žœ˜CLšœžœ
žœžœ
žœ
žœ˜CLšœžœ
žœžœ
žœ
žœ˜CLšœ
žœ
žœžœ
žœžœ˜@Lšœ
žœ
žœžœ
žœžœ˜@Lšœ
žœ
žœžœ
žœžœ˜@Lšœ
žœ
žœžœ
žœžœ˜@Lšœžœ
žœžœ
žœžœ
˜;L˜——M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜Jšœ^žœ
˜bšžœ
˜Lš
œžœžœ
žœžœ ™JLšœžœ
žœžœ
žœ
žœ˜ELšœžœ
žœžœ
žœ
žœ˜ELšœžœ
žœžœ
žœ
žœ˜ELšœ
žœ
žœžœ
žœžœ˜BLšœ
žœ
žœžœ
žœžœ˜BLšœ
žœ
žœžœ
žœžœ˜BLšœ
žœ
žœžœ
žœžœ˜BLšœžœ
žœžœ
žœžœ
˜=L˜——M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜Lšœ`žœ
˜dšžœ
˜Lšœ	žœžœ
žœžœžœ˜ULšœ
žœžœ
žœžœžœ˜XLšœ
žœžœ
žœžœžœ
˜XL˜——šžœ#ž˜)Lšœxžœ
žœžœ˜ฆ
—M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜Mšœažœ
˜eLšžœ
˜Lšœ	žœžœ
žœžœžœ˜VLšœ
žœžœ
žœžœžœ˜YLšœ
žœžœ
žœžœžœ
˜WL˜—šžœ$ž˜*Lšœxžœ
žœžœ˜ฆ
—M˜—J™šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜Gšœ]žœžœ
˜gLšœžœ
žœžœ
žœžœ˜KLšœžœ
žœžœ
žœžœ˜Hšœžœ
žœžœ
žœ
žœ˜DLšœžœ
žœžœ
žœžœ˜BLšœžœ
žœžœ
žœžœ˜HLšœ
žœ
žœžœ
žœžœ˜@Lšœžœ
žœžœ
žœžœ˜HLšœžœ
žœžœ
žœžœ˜BLšœžœ
žœžœ
žœžœ˜>Lšœžœ
žœžœ
žœžœ˜>Lšœžœ
žœžœ
žœžœ
˜=L˜——šžœž˜$Lšœxžœ
žœžœ˜ฆ
—M˜—Mš
œ™šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GM˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DM˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜D™1Lš
œL™LLš
œP™P—Lšœ	ž˜Lšœžœ
˜Lš
œ5˜5Lšžœ
žœ	žœ
žœ
˜Lš
œ3˜3šžœ
žœžœ ˜4Lšœažœ
žœžœ˜Ž
L˜—M˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GLš
œ˜Lšœxžœ
žœžœ˜ฆ
M˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GMš	œ	žœžœžœ
žœ˜4MšœEžœ˜LMšœJžœ˜PM˜—J™M™
šŸœžœ
žœ	žœ
žœ
žœ
žœ˜EM™€
M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜BL˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜B™-Lš
ฯbJ™JLš
กN™N—Lšœž˜Lšœžœ
˜Lš
œ1˜1Lšžœ
žœ	žœ
žœ
˜Lš
œ/˜/šžœ
žœžœ ˜4Lšœažœ
žœžœ˜Ž
L˜—M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ELš
œ˜Lšœxžœ
žœžœ˜ฆ
M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜EMš	œžœžœžœ
žœ˜2MšœCžœ˜JMšœFžœ˜LM˜—M™J™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ILšœGžœ˜NLš
žœ žœyžœ
žœžœ˜อ
M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FM˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FMš
œ˜Mš
œ˜Mš
œ˜M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FMšœžœ
˜Mšœžœ
˜Mš
œ-˜-Mš
œ)˜)Mš
œ<˜<Lšœvžœ
žœžœ˜ค
M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ILš
œ!˜!Lšœxžœ
žœžœ˜ฆ
M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜IMšœžœ"˜2Mš
œN˜NM˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ:žœ˜zš Ÿœžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœžœžœ
žœžœžœ˜ธ
Mšœžœžœ˜6Mšžœ
žœ$žœ
žœ!˜RMšžœžœžœ
˜8Mšžœ˜Mš
œ˜Mš
œ˜M˜—Mšœ	žœ	˜Mšœžœ
˜Mšœžœ
˜Mš
œ˜Mšœžœžœ˜7Mš
œ˜Mš
œ˜MšœB ˜Yšžœžœž˜$Lšœvžœ
žœžœ
˜ฃ
Lšžœyžœ
žœžœ˜ซ
—M˜—M˜J™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JLšœHžœ˜OLš
žœ!žœyžœ
žœžœ˜ฮ
L˜L˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GM˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GMš
œ˜Mš
œ˜Mš
œ˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GMšœžœ
˜Mšœžœ
˜Mš
œ-˜-Mš
œ)˜)Mš
œ=˜=Lšœvžœ
žœžœ˜ค
M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JLš
œ"˜"Lšœxžœ
žœžœ˜ฆ
M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JMšœžœ#˜3Mš
œO˜OM˜—J™M™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FLšœDžœ˜KLš
žœžœyžœ
žœžœ˜ส
M˜—šŸ	œžœ
žœ	žœ
žœ
žœ
žœ˜CM˜—šŸ	œžœ
žœ	žœ
žœ
žœ
žœ˜CLšœž˜
Lšœžœ
˜Lš
œ3˜3Lšžœ
žœ	žœ
žœ
˜Lš
œ1˜1šžœ
žœžœ ˜4Lšœažœ
žœžœ˜Ž
L˜—M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FLš
œ˜Lšœxžœ
žœžœ˜ฆ
M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FMšœžœ#˜3š Ÿ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœžœžœ
žœžœžœ˜ฒ
Mš	œ	žœžœžœ
žœ˜)Mš
žœ
žœžœžœžœ
˜YMšžœ˜Mš
œ˜Mš
œ˜M˜—Mšœ	žœ	˜Mšœžœžœ
˜Mšœžœ
˜
Mš
œ9˜9Mšœ	žœžœ
žœ˜-Mšœ< ˜Sšžœžœž˜$Lšœvžœ
žœžœ
˜ฃ
Lšžœyžœ
žœžœ˜ซ
—M˜—J™L™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ILš
œ*˜*Lš
œ!˜!L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜KLš
œ,˜,Lš
œ!˜!L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JLš
œ+˜+Lš
œ!˜!L˜—J™J™
M™šŸœžœ
žœ-žœ˜IJšœ ˜J˜—šŸœžœ
žœžœ˜FJšœžœ
˜Jšœžœ
˜Jšœžœ˜-Jšžœžœ
žœ!˜:Jš
œG˜GJš
œK˜KJš
œ˜Jšœ-žœžœ˜9Jš
œ˜J˜—šŸ
œžœ
žœ˜,Jšœžœ˜%Jš
œ˜Jšœžœ
˜Jšœžœ
˜#Jšœžœ
˜Jš
œ!˜!Jš
œ˜J˜—šŸœžœ
žœ˜1J™xJš
œ˜Jš
œ0˜0Jš
œ˜J˜—šŸ
œžœ
žœ˜,Jšœžœ˜%Jš
œ˜Jšœžœ
˜Jšœžœ œ
˜ภ
Jšœžœ
˜ Jš
œ!˜!Jš
œ˜—J˜M™BM™šŸœžœ
žœ˜3Jš
œ?˜?Jš
œ˜J˜—M™Mš
œ
™
M™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜IJš
œ?˜?Jš
œ˜—J˜šŸœžœ
žœ	žœ
žœ
žœ
žœ˜?Jš
œ1™1Jš
œ1˜1Jš
œ˜Jš
œ˜J˜Jš
œ˜Jšœžœ
˜J˜J˜Jš
œ%˜%Jšœ"กœ˜<Jš
œ4˜4Jš
œ$˜$Jš
œ!˜!Jšžœžœ
žœ$˜Fšžœ˜Jšœ	žœ
˜Jš
œ(˜(Jš
œM˜Mšžœ
žœ	žœ˜Jš
œ$˜$Jš
œZ˜ZJš
œ ˜ J˜—Jš
œ˜—Jš
œ)˜)JšœกœRžœžœ˜Œ
Jš
œ]˜]Jš
œR˜RJš
œ˜Jš
œŸ
™Ÿ
Lšœsžœ
žœžœ˜ข
Jš
œ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜AJš
œ1˜1Jšœ	žœ
˜Jšœžœ
˜Jš
œ˜J˜Jš
œ-˜-Jš
œH˜HJš
œ(™(šžœ	žœ˜Jš
œ˜Jš
œ4˜4Jš
œ˜Jš
œ!˜!Jš
œ˜Jš
œ ˜ Jš
œ˜—Jšœ ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜>Jšœ	žœ
˜Jšœžœ
˜Jš
œ˜Jš
œ5˜5Jš
œ8˜8šžœ	žœ˜Jš
œ ˜ Jš
œ˜Jš
œ!˜!Jš
œ˜—Jšœ ˜J˜—šŸ
œžœ:˜JJš
œ-˜-Lš
œ@˜@Lš
œ#˜#Lš
œ(˜(šžœAžœ	žœ
ž˜XLšœ
 œE˜JJš
œi˜iJš
œ9˜9Jšžœ
˜—L˜L˜—šŸœžœžœ
žœžœžœ	žœžœ˜Œ
Jšœ	žœ
˜Jš
œ
˜
Jš
œ2˜2Jš
œ™Jš
œ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jšœžœ
˜J˜Jš
ก˜šžœžœ˜Jš
œ˜Jš
œF˜FJšžœ
žœ	žœ
žœ
˜Jš
ก#™#Jšžœžœ
žœ!˜@šžœ˜Jš
œ%˜%Jš
œJ˜Jšžœ
žœ	žœ˜Jš
œ!˜!Jš
œZ˜ZJš
œ ˜ J˜—J˜—Jš
œ)˜)Jšœsžœžœ˜‰
Jš
œY˜YJš
œ˜Jš
œ˜Jš
œ˜J˜
—šžœ˜Jš
œF˜FJšžœ
žœ	žœ
žœ
˜Jš
œ1˜1J˜—Jš
ก˜J˜Jš
œ1˜1Jš
œ@˜@Jš
œ5˜5J˜Jš
ก	™	Jšœžœ
˜Lšœsžœ+žœ˜ช
L˜L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜=Jšœžœ˜9Jšœžœžœ˜.Jšœ	žœ
˜Jšœžœ
˜Jšœžœ
˜J˜Jš
œ-˜-Lš
œW˜WLšžœ
žœ	žœ
žœ˜Jš
œ˜Jšœžœ˜8š
ž˜š
œ
˜
Lš
œL˜LLš
œ ˜ L˜——Jšœ 
˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜?Lšžœ)™/Jšœžœ˜9Lšœžœ
˜Jšœžœ
˜Lšœžœžœ
˜(L˜Jš
œ-˜-Lš
œW˜Wšžœ
žœ	žœ˜Lš
œL˜LLšžœ˜Lš
œ˜—Lš
œG˜Gš
ž˜Lš
œ)˜)—Lš
œ˜L˜—šŸœžœ	žœ
žœ
žœ
žœ˜;Lšœžœ
˜!Lš
œ-˜-Lš
œ1™1Lš
œ/˜/Lš
œ'˜'Lšœžœ
žœ˜Lš
œ˜L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜?Jšœžœ˜9Jšœžœ
˜Jšœ	žœžœ
˜Jšœžœžœ˜.Jšœžœ
˜Jš
œ˜Jšœžœžœ
˜J˜Jš
œ-˜-Lš
œp˜pJšžœ
žœ	žœ
žœ
˜Jš
œ?˜?šžœ	žœ˜Jš
œ˜Jš
œ ˜ Jš
œ˜Jš
œ!˜!Jš
œH™HJ˜—Jšœ ˜J˜—šŸœžœ	žœ
žœ
žœ
žœžœ%žœžœžœžœžœžœžœ˜ว
šŸœžœžœ
žœžœ
žœ˜>šžœžœ
ž˜Lšœžœ
žœžœ˜2Lšœžœžœ˜Lšžœžœ
˜—L˜—Lš
œžœžœ
žœ
žœ
žœžœ
˜XLšœ œ@žœO˜ซ
L˜L™—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜?Jš
œc™cJš
œ˜Jš
œ&˜&Jš
œ˜—J˜™Mš
œ™—šŸ
œžœ˜&Lšœžœ
˜$Lšœžœ&˜5Lš
œ&˜&Lšžœžœ
žœ<˜^M˜—šŸœžœ˜*Lšœžœ
˜$Lšœžœ&˜5Lš
œ(˜(Lšžœžœ
žœ<˜^M˜—šŸœžœ˜'Lšœžœ
˜$Lš
œ<˜<Lš
œ!˜!M˜—šŸœžœ˜*Lšœžœ
˜$Lšœžœ&˜5Lš
œ,˜,M˜—šŸœžœ˜*Lšœžœ
˜$Lšœžœ&˜5Lšœ žœ˜7Lš
œ,˜,Lšœ žœ˜6Lšœ žœ!˜EM˜—J˜šŸœžœ
žœ	žœ
žœ
žœ
žœ˜AJšœžœ˜9Jš
œ˜Jš
œ˜Jš
œ)˜)Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœž˜Jšœ	žœ
˜Jš
œ)˜)J˜Jš
œN˜NJš
œ-˜-Jšœ
žœ
˜šœžœ˜1šœžœ
žœžœ˜*J•StartOfExpansion[]š
œX˜XJšœ
žœ
˜Jšžœ
˜	J˜
—Jš
œ˜—Jšžœ
žœ	žœ
žœ
˜J˜Jš
ก˜Jšœกœ ˜CJš
ก ˜ Jšœ#ก	œก
œ˜AJš
œY˜Yšžœžœžœ™1Jšœ<กœo™ณ
Jš
œต
˜ต
J™
—šžœ 
™Jš
œ™Jšœ œ&™8J™Jšœ<กœ™ะ
J™—šžœ
žœ	žœ˜Jš
œ4˜4Jšžœ
˜J˜—Jš
ก˜Jšœ#ก
œกœ˜?Jš
œR˜Ršœ
žœJ˜VJ˜Q—Jš
œ9˜9Jš
œ)˜)Jšœ ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜BJš
œ˜Jšœžœ
˜Jš
œ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜>Jš
œ˜Jš
œ˜Jšœžœ
žœ-˜AJš
œ[™[Jšœžœ
˜Jš
œL˜LJš
œ
˜
Jš
œ9˜9JšœVžœ˜^Jš
œR˜RJš
œ*˜*Jš
œ4˜4Jšœ ˜—J˜Mš
œ™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜HMš
œ˜Lšœฯuœ
˜Lšœขœ˜Lš
œ˜Lšœ	žœ
žœ
˜Mš
œL˜LLšœžœžœ˜+L˜šžœž˜Lšœขœขœ;˜_Lšœขœขœ?˜dLšžœžœ
˜—MšœDขœขœ˜jM˜—L™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜HLšœ#žœ	žœ˜6M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜QL™GL–K[scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass]š
œ1˜1Lšžœ-žœ
ž˜:šžœ &˜-Lš
œY˜YLš
œX˜XLšœ#žœ	žœ˜7šžœvžœžœ
ž˜Œ
Lš
œ=˜=Lš
œ0˜0Lšžœ
˜—Lš
œ*˜*Lš
œ*˜*Lšœ€
žœ
žœžœ˜ฎ
Lš
œ˜—M˜M˜—šŸ
œžœžœžœ	žœžœ˜NLš
œ&˜&Lš
œ˜L˜L–_[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass]šžœ-žœ
žœ
˜;Lš
œ<˜<Lšžœžœ- ˜SLš
œ3˜3Lš
œ/˜/Lš
œ3˜3Lš
žœžœnžœ
žœžœ˜ฉ
Lšœ ˜L˜—L™Lš
œ™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ALš
œW˜WLš
ก™šžœržœžœ
ž˜ˆ
Lš
œ0˜0Lšžœ
˜—Lš
กI™IJšœ5กœ˜:šžœržœžœ
ž˜ˆ
Jšœ$กœ% ˜eLš	œžœ
žœHžœ	กœ#˜
Lšœ3 ˜JJšžœ
˜—Lš
ก™Lšœmžœ
žœžœ˜›
M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜BLšœOกœ˜Wšžœržœžœ
ž˜ˆ
Lš
œF˜FLšžœ
˜—Lš
œ1˜1Lšœtžœ
žœžœ˜ข
M˜M˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DLš
œ3˜3Lš
œ-˜-Lš
œ'˜'Lš
œR˜RšžœOžœ	žœ
ž˜fLšœ5žœ˜MLš
œ0˜0Lšžœ
˜Lš
ก(™(—Lšœ5กœ  ˜[šžœržœžœ
ž˜ˆ
Lšœกœ˜?Lšœžœ
žœ
˜"Lš
œt˜tLš
œ2˜2Lšžœ
˜—Lšœsžœ
žœžœ˜ก
M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ELšœOกœ˜Tšžœržœžœ
ž˜ˆ
Lš
œF˜FLšžœ
˜—Lš
œ1˜1Lšœtžœ
žœžœ˜ข
M˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DLš
œ1˜1Lš
œB˜BLšœX ˜mLšœlžœ
žœžœ˜š
L˜L˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜Dšžœ%žœ˜-Lš
œ"˜"Lšœ8 ™HLšœ6 ™PLšœpžœ
žœžœ˜ž
L˜—L˜L™—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜LM˜M˜—L™Lš
œ™šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JLš
œ0˜0Lš
œ)˜)Lšœnžœ
žœžœ˜
J˜—J˜šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JJš
œ?˜?Jš
œ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜HJš
œ™Jš
œ=˜=Jšœ ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜JJš
œ?˜?Jšœ ˜—J˜šŸœžœ
žœ	žœ
žœ
žœ
žœ˜@Jš
œ˜Jš
œ[™[Jš
œ5˜5Jš
œ˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DJš
œ™Jš
œ=˜=Jš
œ˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜EL™ฤ
Lš
œ2˜2Lš
œ˜Lš	œžœžœžœ
žœ˜5Lšœžœ
˜
Lšœ!žœ˜)Lšœ	ขœ
˜Lš
œ˜Lš
œ˜Lš
œ(˜(Lš
œ˜Lš
œ:˜:L˜Lš
œ4˜4Lš
œ4˜4šžœž˜!Lš
œ"˜"Lš
œ"˜"L˜Lš
œ;˜;Lš
ก%˜%Lšœ œ;žœ#˜vL˜šžœžœ
žœ˜Lš
œM˜ML˜
—šžœ˜L˜Lšœ#ขœ
˜)Lš
œP˜PL˜—Lšžœ
˜—Lš
œz˜zLšœ ˜L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ILš
œ6˜6L˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ILšœžœ
žœ-˜9Lš
œ9˜9L˜—J˜šŸœžœ
žœ	žœ
žœ
žœ
žœ˜ELš
œ)˜)Lš
œ,˜,Jš
œ$˜$Jš
œ0˜0Jš
œ,˜,Jš
œ-˜-Jšžœ2˜8L˜L˜—Jšžœ
˜J˜—…—2ึ{