
<<File: SVViewerUserImplA.mesa>>
<<Author: Eric Bier in October 1982>>
<<Last edited by Bier on August 19, 1983 1:29 pm>>
<<Contents: Code to respond to button presses made in an SVViewer>>

DIRECTORY
BitMap3d,
CastRays,
CGDevice,
Containers,
CoordSys,
CSG,
CSGGraphics,
DisplayList3d,
Draw3d,
Graphics,
GraphicsBasic,
GraphicsColor,
IO,
Matrix3d,
Menus,
MessageWindow,
Preprocess3d,
Real,
Rope,
SV2d,
SVBoundBox,
SVEditUser,
SVFiles,
SVVector3d,
SVViewerTool,
SVViewerUser,
System,
TFI3d,
TFO3d,
Time,
ViewerClasses,
ViewerOps,
ViewerTools;

SVViewerUserImplA: CEDAR PROGRAM
IMPORTS BitMap3d, CastRays, CoordSys, DisplayList3d, Draw3d, Graphics, IO, Matrix3d, MessageWindow, Preprocess3d, Real, Rope, 
SVEditUser, SVFiles, SVViewerUser, TFI3d, TFO3d, Time, ViewerOps, ViewerTools
EXPORTS GraphicsBasic, SVViewerUser =

BEGIN

Assembly: TYPE = DisplayList3d.Assembly;
BoundBox: TYPE = SVBoundBox.BoundBox;
Camera: TYPE = CSGGraphics.Camera;
Color: TYPE = GraphicsColor.Color;
CoordSysGenerator: TYPE = DisplayList3d.CoordSysGenerator;
CoordSystem: TYPE = CoordSys.CoordSystem;
CSGTree: TYPE = DisplayList3d.CSGTree;
DeviceObject: PUBLIC TYPE = CGDevice.Rep;
DrawStyle: TYPE = CSGGraphics.DrawStyle;
FileCamera: TYPE = DisplayList3d.FileCamera;
EditToolData: TYPE = SVEditUser.EditToolData;
MasterObject: TYPE = DisplayList3d.MasterObject;
Matrix4by4: TYPE = Matrix3d.Matrix4by4;
MouseButton: TYPE = Menus.MouseButton;
Point2d: TYPE = SV2d.Point2d;
Primitive: TYPE = CSG.Primitive;
Scene: TYPE = DisplayList3d.Scene;
Vector: TYPE = SVVector3d.Vector;
Viewer: TYPE = ViewerClasses.Viewer;

ViewerToolData: TYPE = REF ViewerToolDataObj;
ViewerToolDataObj: TYPE = SVViewerTool.ViewerToolDataObj;

ViewerTextData: TYPE = SVViewerTool.ViewerTextData;

ViewerPictureData: TYPE = REF ViewerPictureDataObj;
ViewerPictureDataObj: TYPE = SVViewerUser.ViewerPictureDataObj;

InteractionMode: TYPE = SVViewerUser.InteractionMode;-- {select, cast};

DCProc: TYPE = SVViewerUser.DCProc;


ReadTwoReals: PUBLIC PROC [textViewer: Viewer] RETURNS [x, y: REAL] = TRUSTED {
wholeRope: Rope.ROPE _ ViewerTools.GetContents[textViewer];
wholeStream: IO.STREAM _ IO.RIS[wholeRope];
TFI3d.ReadBlank[wholeStream];
x _ TFI3d.ReadReal[wholeStream];
TFI3d.ReadBlankAndRope[wholeStream, ","];
y _ TFI3d.ReadReal[wholeStream];
};

DrawSceneEtc: PUBLIC PROC [dc: Graphics.Context, viewerToolData: ViewerToolData] = TRUSTED {
<<May also draw coordinate systems, drawing planes, etc depending on the current selected modes.>>
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
IF viewerPictureData.doubleBuffer THEN {
BitMap3d.Erase[viewerPictureData.altDC];
DisplayList3d.DrawScene[viewerPictureData.altDC.dc, scene, camera];
IF viewerPictureData.showCoordSys
THEN DrawAllCS[viewerPictureData.altDC.dc, viewerToolData];
SVEditUser.DrawAnySelections[dc, viewerToolData]; 
BitMap3d.DrawAltDisplayContext[dc, viewerPictureData.altDC];
}
ELSE {
editToolData: EditToolData _ NARROW[viewerToolData.editToolData];
assem: Assembly;
success: BOOL;
DisplayList3d.DrawScene[dc, scene, camera];
Graphics.SetColor[dc, GraphicsColor.black];
<<IF viewerPictureData.showCoordSys THEN DrawAllCS[dc, viewerToolData];>>
IF viewerPictureData.showCoordSys THEN
IF editToolData.sceneSection.currentScene = scene THEN {
[assem, success] _ SVEditUser.GetAssembly[editToolData.sceneSection.assemblyName, scene];
IF success THEN DrawOneCS[dc, viewerToolData, assem.coordSys];
};
SVEditUser.DrawAnySelections[dc, viewerToolData];
};
}; -- end of DrawSceneEtc

EraseAndDrawSceneEtc: PUBLIC PROC [dc: Graphics.Context, viewerToolData: ViewerToolData] = TRUSTED {
<<May also draw coordinate systems, drawing planes, etc depending on the current selected modes.>>
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
IF viewerPictureData.doubleBuffer THEN {
BitMap3d.Erase[viewerPictureData.altDC];
DisplayList3d.DrawScene[viewerPictureData.altDC.dc, scene, camera];
IF viewerPictureData.showCoordSys THEN DrawAllCS[viewerPictureData.altDC.dc, viewerToolData];
SVEditUser.DrawAnySelections[dc, viewerToolData]; 
BitMap3d.DrawAltDisplayContext[dc, viewerPictureData.altDC];
}
ELSE {
Graphics.SetColor[dc, GraphicsColor.white];
Graphics.DrawBox[dc, Graphics.GetBounds[dc]];
DisplayList3d.DrawScene[dc, scene, camera];
Graphics.SetColor[dc, GraphicsColor.black];
IF viewerPictureData.showCoordSys THEN DrawAllCS[dc, viewerToolData];
SVEditUser.DrawAnySelections[dc, viewerToolData];
};
};

DrawAllCS: PUBLIC PROC [dc: Graphics.Context, viewerToolData: ViewerToolData] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
g: CoordSysGenerator _ DisplayList3d.GetCoordSysGenerator[scene];
mat: Matrix4by4;
FOR cs: CoordSystem _ DisplayList3d.NextCoordSys[g], DisplayList3d.NextCoordSys[g]
UNTIL cs = NIL DO
mat _ CoordSys.FindInTermsOfCamera[cs, camera.coordSys];
<<Make sure you have up to date coordSys positions.>>
Draw3d.DrawCoordSys[dc, mat, camera];
ENDLOOP;
};

DrawOneCS: PUBLIC PROC [dc: Graphics.Context, viewerToolData: ViewerToolData, cs: CoordSystem] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
camera: Camera _ viewerPictureData.camera;
<<assume that cs has valid cs.wrtCamera and cs.wrtWorld fields.>>
Draw3d.DrawCoordSys[dc, cs.wrtCamera, camera];
};

UpdateHeader: PUBLIC PROC [pictureFile: Rope.ROPE, viewerToolData: ViewerToolData] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
headerRope: Rope.ROPE;
aisName: Rope.ROPE;
viewName: Rope.ROPE _ viewerPictureData.camera.viewName;
IF pictureFile = NIL THEN pictureFile _ viewerPictureData.scene.name;
headerRope _ Rope.Cat[viewName, " View of Solid Scene: ", pictureFile];
aisName _ Rope.Concat[SVFiles.FilenameMinusExtension[pictureFile], ".ais"];
viewerToolData.outer.name _ headerRope;
<<ViewerTools.SetContents[viewerToolData.textSection.ais, aisName, TRUE];>>
ViewerOps.PaintViewer[viewerToolData.outer, caption, FALSE, NIL];
};

NotifyOfSplit: PUBLIC PROC [viewer: Viewer] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[viewer.data];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
UpdateHeader[viewerPictureData.scene.name, viewerToolData];
};

UnSplit: PUBLIC PROC [viewerToolData: ViewerToolData] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
UpdateHeader[viewerPictureData.scene.name, viewerToolData];
};

DrawOneCSInViewer: PUBLIC PROC [viewerToolData: ViewerToolData, cs: CoordSystem] = TRUSTED {
DoDrawOneCSInViewer: PROC [dc: Graphics.Context] = TRUSTED {
DrawOneCS[dc, viewerToolData, cs];
};
Painter[DoDrawOneCSInViewer, viewerToolData];
};

Painter: PUBLIC PROC [proc: DCProc, viewerToolData: ViewerToolData _ NIL] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
viewerPictureData.proc _ proc;
ViewerOps.PaintViewer[viewer: viewerToolData.viewerPicture,
hint: client,
whatChanged: viewerToolData,
clearClient: FALSE];
}; -- end of Painter

DrawScene: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
<<Menus.MenuProc>>
<<viewer is a SolidWindow. clientData is viewerToolData>>
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
DoDrawScene: PROC [dc: Graphics.Context] = TRUSTED {
DrawSceneEtc[dc, viewerToolData];
};
Painter[DoDrawScene, viewerToolData];
};

DrawSceneInternal: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {-- 
like DrawScene but erases the screen before drawing.
<<Menus.MenuProc>>
<<viewer is a SolidWindow. clientData is viewerToolData.>>
viewerToolData: ViewerToolData _ NARROW[clientData];
DoDrawScene: PROC [dc: Graphics.Context] = TRUSTED {
EraseAndDrawSceneEtc[dc, viewerToolData];
};
Painter[DoDrawScene, viewerToolData];
};

PlaceOrigin: PUBLIC PROC [viewer: Viewer] = TRUSTED {
<<viewer is the viewerPicture>>
<< Find the center of the solid window in solid window coordinates.>>
originX, originY: REAL;
transMat: Matrix4by4;
viewerPictureData: ViewerPictureData _ NARROW[viewer.data];
screenCS: CoordSystem;
camera: Camera _ viewerPictureData.camera;
screenCS _ camera.screenCS;
originX _ viewer.cw;-- convert window width to real
originY _ viewer.ch;-- convert window height to real
originX _ originX/2.0;-- find the midpoint in window coords
originY _ originY/2.0;
transMat _ Matrix3d.MakeTranslateMat[-originX,-originY,0];
CoordSys.TPlaceAwrtB[screenCS,camera.coordSys,transMat];
}; -- end of PlaceOrigin

ResizeBitMap: PUBLIC PROC [viewer: Viewer] = TRUSTED {
<<viewer is the viewerPicture>>
<< resize its bitMap>>
viewerPictureData: ViewerPictureData _ NARROW[viewer.data];
BitMap3d.ResizeBitMap[viewer, viewerPictureData.altDC];
};

Empty: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
<<Creates a new empty scene for the viewer to view.>>
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
oldScene: Scene _ viewerPictureData.scene;
newScene: Scene;
fileCamera: FileCamera;
cameraName: Rope.ROPE;

newScene _ viewerPictureData.scene _ DisplayList3d.CreateScene["NoName.pic"];
UpdateHeader[newScene.name, viewerToolData];
SVViewerUser.Selected[parent, clientData, mouseButton, shift, control];

IF newScene.cameraOrder = NIL THEN fileCamera _ newScene.cameras.first
ELSE {
success: BOOL;
cameraName _ newScene.cameraOrder.first;
[fileCamera, success] _ DisplayList3d.FindFileCameraFromName[cameraName, newScene];
IF NOT success THEN {
fileCamera _ newScene.cameras.first;
MessageWindow.Append[Rope.Cat["Camera ", cameraName, " not found"], TRUE];
MessageWindow.Blink[];
};
};
viewerPictureData.camera _ DisplayList3d.CameraFromFileCamera[fileCamera, viewerPictureData.camera.coordSys.withRespectTo, 
viewerPictureData.camera.screenCS, viewerPictureData.camera.style];

Erase[parent, clientData, mouseButton, shift, control];
SVEditUser.NotifyOfEmpty[viewerToolData: viewerToolData, from: oldScene, to: viewerPictureData.scene];

SceneOldVersion[viewerToolData];
<<This must be done after NotifyOfEmpty since SVEditUser expects to register to the newly created NoName scene before it resets the 
[New Version] headers.
>>
ViewerTools.SetContents[viewerToolData.textSection.ais, "default.ais"];

};

ConfirmEmpty: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
stream: IO.STREAM;
rope: Rope.ROPE;
dirty: BOOL;
stream _ IO.CreateOutputStreamToRope[];
dirty _ viewerToolData.outer.newVersion;
IF dirty THEN stream.PutF["Confirm discard of edits"]
ELSE stream.PutF["Confirm emptying of viewer"];
rope _ IO.GetOutputStreamRope[stream];
MessageWindow.Append[rope, TRUE];
};

ClearScene: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
DisplayList3d.ClearScene[viewerPictureData.scene];
};

Erase: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
DoErase: PROC [dc: Graphics.Context] = TRUSTED {
mark: Graphics.Mark _ Graphics.Save[dc];
Graphics.SetColor[dc, Graphics.white];
Graphics.DrawBox[dc,Graphics.GetBounds[dc]];
Graphics.SetColor[dc, Graphics.white];
Graphics.Restore[dc,mark];
};
Painter[DoErase, viewerToolData];
};

DrawCoordSystems: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
DoDrawCoordSys: PROC [dc: Graphics.Context] = TRUSTED {
DrawAllCS[dc, viewerToolData];
};
Painter[DoDrawCoordSys, viewerToolData];
};

DrawBoundBoxes: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
<<viewer is Container>>
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
tree: CSG.CSGTree;
DoDrawBoundBoxes: PROC [dc: Graphics.Context] = TRUSTED {
Draw3d.DrawBoundBoxes[dc, tree, camera];
};
tree _ DisplayList3d.SceneToTree[scene, camera];  -- does a TellAboutCameraAndWorld
[] _ Preprocess3d.Preprocess[tree, camera];
Painter[DoDrawBoundBoxes, viewerToolData];
}; -- end of DrawBoundBoxes

SceneNewVersion: PUBLIC PROC [viewerToolData: ViewerToolData] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
SVEditUser.SceneNewVersion[viewerToolData, scene];
};

NewVersion: PUBLIC PROC [viewer: Viewer] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[viewer.data];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
scene.dirty _ TRUE;
viewerToolData.outer.newVersion _ TRUE;
UpdateHeader[scene.name, viewerToolData];
};

SceneOldVersion: PUBLIC PROC [viewerToolData: ViewerToolData] = TRUSTED {
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
SVEditUser.SceneOldVersion[viewerToolData, scene];
};

OldVersion: PUBLIC PROC [viewer: Viewer] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[viewer.data];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
scene.dirty _ FALSE;
viewerToolData.outer.newVersion _ FALSE;
UpdateHeader[scene.name, viewerToolData];
};

Reset: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
success: BOOL;
scene: Scene _ viewerPictureData.scene;
[scene, success] _ SVEditUser.LoadScene[viewerToolData, scene.name];
<<Reload this scene from its backing file.>>
IF success THEN {
viewerPictureData.scene _ scene;
SceneOldVersion[viewerToolData];
UpdateHeader[scene.name, viewerToolData];
DrawSceneInternal[parent, clientData, mouseButton, shift, control];
SVViewerUser.Selected[parent, clientData, mouseButton, shift, control];
};
}; -- end of Reset

ConfirmReset: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
stream: IO.STREAM;
rope: Rope.ROPE;
dirty: BOOL;
stream _ IO.CreateOutputStreamToRope[];
dirty _ viewerToolData.outer.newVersion;
IF dirty THEN stream.PutF["Confirm discard of edits"]
ELSE stream.PutF["Confirm reset of %g", [rope[scene.name]]];
rope _ IO.GetOutputStreamRope[stream];
MessageWindow.Append[rope, TRUE];
}; -- end of ConfirmReset

Save: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
success: BOOL;
scene: Scene _ viewerPictureData.scene;
success _ SVEditUser.SaveScene[viewerToolData, scene.name];
IF success THEN {
SVViewerUser.Selected[parent, clientData, mouseButton, shift, control];
SceneOldVersion[viewerToolData];
UpdateHeader[scene.name, viewerToolData];
};
}; -- end of Save

ConfirmSave: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
exists: BOOL;
stream: IO.STREAM;
rope: Rope.ROPE;
stream _ IO.CreateOutputStreamToRope[];
exists _ SVFiles.FileExists[scene.name];
IF exists THEN stream.PutF["Confirm Save to %g [Old File]", [rope[scene.name]]]
ELSE {
stream.PutF["%g doesn't exist. Use Store", [rope[scene.name]]];
MessageWindow.Blink[]
};
rope _ IO.GetOutputStreamRope[stream];
MessageWindow.Append[rope, TRUE];
};

Get: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
success: BOOL;
<<picName: Rope.ROPE _ ViewerTools.GetContents[viewerToolData.textSection.fileName];>>
picName: Rope.ROPE _ ViewerTools.GetSelectionContents[];
aisName: Rope.ROPE;
scene: Scene;
IF Rope.Length[picName] = 0 THEN {
MessageWindow.Append["Please select a file name.", TRUE];
MessageWindow.Blink[];
RETURN;
};
[scene, success] _ SVEditUser.LoadScene[viewerToolData, picName];
IF success THEN {
fileCamera: FileCamera;
cameraName: Rope.ROPE;
IF scene.cameraOrder = NIL THEN fileCamera _ scene.cameras.first
ELSE {
cameraName _ scene.cameraOrder.first;
[fileCamera, success] _ DisplayList3d.FindFileCameraFromName[cameraName, scene];
IF NOT success THEN {
fileCamera _ scene.cameras.first;
MessageWindow.Append[Rope.Cat["Camera ", cameraName, " not found"], TRUE];
MessageWindow.Blink[];
};
};
viewerPictureData.scene _ scene;
viewerPictureData.camera _ DisplayList3d.CameraFromFileCamera[fileCamera, viewerPictureData.camera.coordSys.withRespectTo, 
viewerPictureData.camera.screenCS, viewerPictureData.camera.style];
SceneOldVersion[viewerToolData];
UpdateHeader[picName, viewerToolData];
aisName _ Rope.Concat[SVFiles.FilenameMinusExtension[picName], ".ais"];
ViewerTools.SetContents[viewerToolData.textSection.ais, aisName];
DrawSceneInternal[parent, clientData, mouseButton, shift, control];
SVViewerUser.Selected[parent, clientData, mouseButton, shift, control];
};
}; -- end of Get

ConfirmGet: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
<<picName: Rope.ROPE _ ViewerTools.GetContents[viewerToolData.textSection.fileName];>>
picName: Rope.ROPE _ ViewerTools.GetSelectionContents[];
stream: IO.STREAM;
rope: Rope.ROPE;
dirty: BOOL;
stream _ IO.CreateOutputStreamToRope[];
dirty _ viewerToolData.outer.newVersion;
IF dirty THEN stream.PutF["Confirm discard of edits"]
ELSE stream.PutF["Confirm load of %g", [rope[picName]]];
rope _ IO.GetOutputStreamRope[stream];
MessageWindow.Append[rope, TRUE];
}; -- end of ConfirmGet

Store: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
success: BOOL;
aisName: Rope.ROPE;
picName: Rope.ROPE _ ViewerTools.GetSelectionContents[];
scene: Scene _ viewerPictureData.scene;
success _ SVEditUser.StoreScene[viewerToolData, scene, picName];
IF success THEN {
UpdateHeader[picName, viewerToolData];
SVViewerUser.Selected[parent, clientData, mouseButton, shift, control];
SceneOldVersion[viewerToolData];
UpdateHeader[scene.name, viewerToolData];
aisName _ Rope.Concat[SVFiles.FilenameMinusExtension[picName], ".ais"];
ViewerTools.SetContents[viewerToolData.textSection.ais, aisName];};
}; -- end of Store

ConfirmStore: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
picName: Rope.ROPE _ ViewerTools.GetSelectionContents[];
exists: BOOL;
stream: IO.STREAM;
rope: Rope.ROPE;
stream _ IO.CreateOutputStreamToRope[];
exists _ SVFiles.FileExists[picName];
IF exists THEN stream.PutF["Confirm Store of %g [Old File]", [rope[picName]]]
ELSE stream.PutF["Confirm Store to %g [New File]", [rope[picName]]];
rope _ IO.GetOutputStreamRope[stream];
MessageWindow.Append[rope, TRUE];
};

Split: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
<<Create a new viewer onto this scene.  Update the ring of links joining all viewers onto this scene,>>
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
SVEditUser.Split[viewerToolData, scene];
};

RayCast: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
editToolData: EditToolData _ NARROW[viewerToolData.editToolData];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
tree: CSGTree;
startTime: System.GreenwichMeanTime;
endTime: System.GreenwichMeanTime;
totalTime: LONG CARDINAL;
timeStream: IO.STREAM _ IO.CreateOutputStreamToRope[];
outStream: IO.STREAM _ SVEditUser.GetOutHandle[];
timeRope: Rope.ROPE;
aisFileRope: Rope.ROPE _ ViewerTools.GetContents[viewerToolData.textSection.ais];
success: BOOL;
<<For now, I delete any old file if it exists.>>
startTime _ Time.Current[];
tree _ DisplayList3d.SceneToTree[scene, camera];
success _ CastRays.DrawTree[NIL, tree, scene.lightSources, camera, aisFileRope, mouseButton = blue, SVViewerUser.RayCastProgress, 
viewerToolData, outStream];
IF NOT success THEN {
outStream.PutF["...Raycast aborted."];
RETURN;
};
endTime _ Time.Current[];
totalTime _ endTime - startTime;
outStream.PutF[" Raycast took (%r)\n",[cardinal[totalTime]]];
timeStream.PutF[" Raycast took (%r)",[cardinal[totalTime]]];
timeRope _ IO.GetOutputStreamRope[timeStream];
MessageWindow.Append[timeRope, TRUE];
SVViewerUser.DrawBlackAndWhite[parent, clientData, mouseButton, shift, control];
}; -- end of RayCast

ConfirmRayCast: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
exists: BOOL;
aisFileRope: Rope.ROPE _ ViewerTools.GetContents[viewerToolData.textSection.ais];
redRope: Rope.ROPE _ Rope.Concat[SVFiles.FilenameMinusExtension[aisFileRope], "-red.ais"];
greenRope: Rope.ROPE _ Rope.Concat[SVFiles.FilenameMinusExtension[aisFileRope], "-green.ais"];
blueRope: Rope.ROPE _ Rope.Concat[SVFiles.FilenameMinusExtension[aisFileRope], "-blue.ais"];
stream: IO.STREAM;
rope: Rope.ROPE;
stream _ IO.CreateOutputStreamToRope[];
IF mouseButton = blue THEN { -- black and white only
exists _ SVFiles.FileExists[aisFileRope];
stream.PutF["Confirm raycast to %g.", [rope[aisFileRope]]];
IF exists THEN stream.PutF[" [Old File]"]
ELSE stream.PutF[" [New File]"];
}
ELSE {
exists _ SVFiles.FileExists[aisFileRope] OR SVFiles.FileExists[redRope] OR SVFiles.FileExists[greenRope] OR 
SVFiles.FileExists[blueRope];
stream.PutF["Confirm raycast to %g [-red, -green, -blue, plain].ais",
[rope[SVFiles.FilenameMinusExtension[aisFileRope]]]];
IF exists THEN stream.PutF[" [Old Files]"]
ELSE stream.PutF[" [New Files]"];
};
rope _ IO.GetOutputStreamRope[stream];
MessageWindow.Append[rope, TRUE];
};

Stop: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
camera: Camera _ viewerPictureData.camera;
camera.abort _ TRUE;
};

ARay: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {
viewerToolData: ViewerToolData _ NARROW[clientData];
viewerPictureData: ViewerPictureData _ NARROW[viewerToolData.viewerPicture.data];
scene: Scene _ viewerPictureData.scene;
camera: Camera _ viewerPictureData.camera;
<<Get x and y from appropriate slots.  Interpret this as camera coordinates and draw a cross.>>
x, y: REAL;
xInt, yInt: INTEGER;
outHandle: IO.STREAM;
tree: CSGTree _ DisplayList3d.SceneToTree[scene, camera];
color: Color;
[x, y] _ ReadTwoReals[viewerToolData.textSection.xyz];
xInt _ Real.FixI[x];  yInt _ Real.FixI[y];
outHandle _ SVEditUser.GetOutHandle[];
color _ CastRays.SingleRay[xInt, yInt,
  tree, scene.lightSources, viewerPictureData.camera, TRUE, outHandle];
outHandle.PutF["[%g,%g]: ",[real[x]], [real[y]]];
TFO3d.FileoutColor[outHandle, color];
}; -- end of ARay

END.