DIRECTORY
CoordSys, Feedback, Imager, IO, Matrix3d, Menus, Rope, SVScratchpad, SV2d, SV3d, SVAssembly, SVEditUser, SVHalfSpaces, SVInterfaceTypes, SVMasterObject, SVMasterObjectTypes, SVModelTypes, SVPolygon2d, SVScene, SVSceneTypes, SVSelections, SVViewersOnScene, SVViewerTools, SweepGeometry, ViewerClasses, ViewerTools;

SVEditUserImplB: CEDAR PROGRAM
IMPORTS CoordSys, Feedback, IO, Matrix3d, Rope, SVScratchpad, SVAssembly, SVEditUser, SVMasterObject, SVPolygon2d, SVScene, SVSelections, SVViewersOnScene, SVViewerTools, SweepGeometry, ViewerTools
EXPORTS SVEditUser =

BEGIN

Slice: TYPE = SVSceneTypes.Slice;
SliceList: TYPE = SVSceneTypes.SliceList;
AssemblyGenerator: TYPE = SVScene.AssemblyGenerator;
Color: TYPE = Imager.Color;
EditToolData: TYPE = SVInterfaceTypes.EditToolData;
LightSource: TYPE = SVModelTypes.LightSource;
LinearMesh: TYPE = SweepGeometry.LinearMesh;
MasterObject: TYPE = SVSceneTypes.MasterObject;
Matrix4by4: TYPE = SV3d.Matrix4by4;
MouseButton: TYPE = Menus.MouseButton;
NameAlreadyPresent: SIGNAL = SVScene.NameAlreadyPresent;
Point3d: TYPE = SV3d.Point3d;
Polygon: TYPE = SV2d.Polygon;
RevoluteMesh: TYPE = SweepGeometry.RevoluteMesh;
Path: TYPE = SV2d.Path;
Scene: TYPE = SVSceneTypes.Scene;
SelectionGenerator: TYPE = SVInterfaceTypes.SelectionGenerator;
Shape: TYPE = SVSceneTypes.Shape;
Vector3d: TYPE = SV3d.Vector3d;
Viewer: TYPE = ViewerClasses.Viewer;
ViewerCell: TYPE = SVInterfaceTypes.ViewerCell;
SVData: TYPE = SVInterfaceTypes.SVData;


HalfSpaceRec: TYPE = SVHalfSpaces.HalfSpaceRec;
SphereRec: TYPE = SVMasterObjectTypes.SphereRec;
BlockData: TYPE = SVMasterObjectTypes.BlockData;
CylinderRec: TYPE = SVMasterObjectTypes.CylinderRec;
ConeRec: TYPE = SVMasterObjectTypes.ConeRec;
TorusRec: TYPE = SVMasterObjectTypes.TorusRec;

AddHalfSpace: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ editToolData.sceneSection.currentScene;
errorRope: Rope.ROPE;
addSucceeds: BOOL _ TRUE;
halfSpaceName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
newAssembly, superAssembly, assembly: Slice;
success: BOOL;
arg: ATOM _ NARROW[event.rest.first];

halfSpaceMO: MasterObject;
moFound: BOOL _ TRUE;
halfSpaceRec: HalfSpaceRec;

[halfSpaceMO, moFound] _ SVScene.FindObjectFromName["halfSpace", scene];
IF NOT moFound THEN ERROR;
halfSpaceRec _ NARROW[halfSpaceMO.mainBody];

IF arg = $Add THEN {
[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
[newAssembly, ----, addSucceeds] _ SVAssembly.CreatePrimitive[halfSpaceName, "halfSpace", scene];
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, [1, 1, 1], superAssembly, Matrix3d.Identity[], scene];
IF NOT addSucceeds THEN RETURN;
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
SVViewersOnScene.PaintSceneAllViewers[$ObjectAdded, editToolData, scene];
}
ELSE IF arg = $Replace THEN {
mo, oldMo: MasterObject;
shape: Shape;
assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
[mo, moFound] _ SVScene.FindObjectFromName["halfSpace", scene];
IF NOT moFound THEN ERROR;
IF NOT ISTYPE[assembly.shape, Shape] THEN {
errorRope _ IO.PutFR["Can't replace cluster assembly [%g] with a halfSpace.",[rope[assembly.name]]];
Feedback.AppendRaw[$Solidviews, errorRope, oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN};
shape _ NARROW[assembly.shape];
oldMo _ shape.mo;
shape.mo _ mo;
IF NOT SVScene.MasterObjectIsUsed[oldMo, scene] THEN moFound _ SVScene.DeleteMasterObjectNamed[oldMo.name, scene];
IF NOT moFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Old master object ", oldMo.name, "mysteriously disappeared.  Save your work"], oneLiner];
Feedback.BlinkRaw[$Solidviews] };
CoordSys.SetScalars[shape.coordSys, [1, 1, 1]];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectChangedBoundBoxProvided, editToolData: editToolData, scene: scene, edited: TRUE];
};
}; -- end of  AddHalfSpace

AddSphere: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ editToolData.sceneSection.currentScene;
errorRope: Rope.ROPE;
addSucceeds: BOOL _ TRUE;
sphereName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
radius: REAL _ SVViewerTools.GetReal[editToolData.sphereSection.radius, 200];
newAssembly, superAssembly, assembly: Slice;
success: BOOL;
arg: ATOM _ NARROW[event.rest.first];

sphereMO: MasterObject;
moFound: BOOL _ TRUE;
sphereRec: SphereRec;
moRadius: REAL;

[sphereMO, moFound] _ SVScene.FindObjectFromName["sphere", scene];
IF NOT moFound THEN ERROR;
sphereRec _ NARROW[sphereMO.mainBody];
moRadius _ sphereRec.radius;
radius _ radius/moRadius;


IF arg = $Add THEN {
[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
[newAssembly, ----, addSucceeds] _ SVAssembly.CreatePrimitive[sphereName, "sphere", scene];
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, [radius, radius, radius], superAssembly, Matrix3d.Identity[], scene];
IF NOT addSucceeds THEN RETURN;
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectAdded, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
}
ELSE IF arg = $Replace THEN {
mo, oldMo: MasterObject;
shape: Shape;
assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
[mo, moFound] _ SVScene.FindObjectFromName["sphere", scene];
IF NOT moFound THEN ERROR;
IF NOT ISTYPE[assembly.shape, Shape] THEN {
errorRope _ IO.PutFR["Can't substitue a sphere for a cluster assembly [%g]",[rope[assembly.name]]];
Feedback.AppendRaw[$Solidviews, errorRope, oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN};
shape _ NARROW[assembly.shape];
oldMo _ shape.mo;
shape.mo _ mo;
IF NOT SVScene.MasterObjectIsUsed[oldMo, scene] THEN moFound _ SVScene.DeleteMasterObjectNamed[oldMo.name, scene];
IF NOT moFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Old master object ", oldMo.name, "mysteriously disappeared.  Save your work"], oneLiner];
Feedback.BlinkRaw[$Solidviews] };
CoordSys.SetScalars[shape.coordSys, [radius, radius, radius]];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectChangedBoundBoxProvided, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
}; -- end of  AddSphere

AddBlock: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
x, y, z: REAL;
blockName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
arg: ATOM _ NARROW[event.rest.first];
scalars: Vector3d;

blockMO: MasterObject;
blockMO _ SVMasterObject.BlockMakeMasterObject[blockName];
[x, y, z] _ SVViewerTools.GetThreeReals[editToolData.blockSection.xyz];
scalars _ [x/2.0, y/2.0, z/2.0];

AddUnsharedAux[editToolData, blockMO, blockName, arg, "Block", scalars];
};

AddCyl: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ editToolData.sceneSection.currentScene;
errorRope: Rope.ROPE;
addSucceeds: BOOL _ TRUE;
cylName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
radius: REAL _ SVViewerTools.GetReal[editToolData.cylinderSection.radius, 200];
height: REAL _ SVViewerTools.GetReal[editToolData.cylinderSection.height, 300];
newAssembly, superAssembly, assembly: Slice;
success: BOOL;
arg: ATOM _ NARROW[event.rest.first];

cylMO: MasterObject;
moFound: BOOL _ TRUE;
cylinderRec: CylinderRec;
[cylMO, moFound] _ SVScene.FindObjectFromName["cylinder", scene];
IF NOT moFound THEN ERROR;
cylinderRec _ NARROW[cylMO.mainBody];

radius _ radius/cylinderRec.radius;  height _ height/cylinderRec.height;

IF arg = $Add THEN {
[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
[newAssembly, ----, addSucceeds] _ SVAssembly.CreatePrimitive[cylName, "cylinder", scene];
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, [radius, height, radius], superAssembly, Matrix3d.Identity[], scene];
IF NOT addSucceeds THEN RETURN;
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectAdded, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
}
ELSE IF arg = $Replace THEN {
mo, oldMo: MasterObject;
shape: Shape;
assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
[mo, moFound] _ SVScene.FindObjectFromName["cylinder", scene];
IF NOT moFound THEN ERROR;
IF NOT ISTYPE[assembly.shape, Shape] THEN {
errorRope _ IO.PutFR["Can't substitute a cylinder for a cluster assembly [%g]",[rope[assembly.name]]];
Feedback.AppendRaw[$Solidviews, errorRope, oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN};
shape _ NARROW[assembly.shape];
oldMo _ shape.mo;
shape.mo _ mo;
IF NOT SVScene.MasterObjectIsUsed[oldMo, scene] THEN moFound _ SVScene.DeleteMasterObjectNamed[oldMo.name, scene];
IF NOT moFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Old master object ", oldMo.name, "mysteriously disappeared.  Save your work"], oneLiner];
Feedback.BlinkRaw[$Solidviews] };
CoordSys.SetScalars[shape.coordSys, [radius, height, radius]];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectChangedBoundBoxProvided, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
}; -- end of AddCyl

AddCone: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
coneName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
radius: REAL _ SVViewerTools.GetReal[editToolData.coneSection.radius, 200];
height: REAL _ SVViewerTools.GetReal[editToolData.coneSection.height, 300];
arg: ATOM _ NARROW[event.rest.first];
scalars: Vector3d;
addSucceeds: BOOL _ TRUE;
errorRope: Rope.ROPE;
newAssembly, superAssembly, assembly: Slice;
success: BOOL;
scene: Scene _ editToolData.sceneSection.currentScene;

coneMO: MasterObject;
moFound: BOOL _ TRUE;
coneRec: ConeRec;
[coneMO, moFound] _ SVScene.FindObjectFromName["cone", scene];
IF NOT moFound THEN ERROR;
coneRec _ NARROW[coneMO.mainBody];
radius _ radius/coneRec.radius;  height _ height/coneRec.height;
scalars _ [radius, height, radius];

IF arg = $Add THEN {
[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
[newAssembly, ----, addSucceeds] _ SVAssembly.CreatePrimitive[coneName, "cone", scene];
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, scalars, superAssembly, Matrix3d.Identity[], scene];
IF NOT addSucceeds THEN RETURN;
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectAdded, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
}
ELSE IF arg = $Replace THEN {
mo, oldMo: MasterObject;
shape: Shape;
assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
[mo, moFound] _ SVScene.FindObjectFromName["cone", scene];
IF NOT moFound THEN ERROR;
IF NOT ISTYPE[assembly.shape, Shape] THEN {
errorRope _ IO.PutFR["Can't substitue a cone for a cluster assembly [%g]",[rope[assembly.name]]];
Feedback.AppendRaw[$Solidviews, errorRope, oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN};
shape _ NARROW[assembly.shape];
oldMo _ shape.mo;
shape.mo _ mo;
IF NOT SVScene.MasterObjectIsUsed[oldMo, scene] THEN moFound _ SVScene.DeleteMasterObjectNamed[oldMo.name, scene];
IF NOT moFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Old master object ", oldMo.name, "mysteriously disappeared.  Save your work"], oneLiner];
Feedback.BlinkRaw[$Solidviews] };
CoordSys.SetScalars[shape.coordSys, scalars];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectChangedBoundBoxProvided, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
}; -- end of AddCone

AddTorus: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
mo: MasterObject;
torusName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
bigRadius, sectionRadius: REAL;
arg: ATOM _ NARROW[event.rest.first];

bigRadius _ SVViewerTools.GetReal[editToolData.torusSection.bigRadius, 100];
sectionRadius _ SVViewerTools.GetReal[editToolData.torusSection.sectionRadius, 100];
mo _ SVMasterObject.TorusMakeMasterObject[torusName, bigRadius, sectionRadius];
AddUnsharedAux[editToolData, mo, torusName, arg, "Torus"];
}; -- end of AddTorus

AddRevo: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scratchpad: Viewer _ editToolData.scratchpad;
linesOfLongitude: NAT _ 10;
scene: Scene _ editToolData.sceneSection.currentScene;
errorRope: Rope.ROPE;
addSucceeds: BOOL _ TRUE;
revName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];
mo, oldMo: MasterObject;
path: Path;
newAssembly, superAssembly, assembly: Slice;
success: BOOL;
arg: ATOM _ NARROW[event.rest.first];

path _ SVScratchpad.GetPath[scratchpad];
IF path.len = 0 THEN {
Feedback.AppendRaw[$Solidviews, "There is no 2d shape in the scratchpad", oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN};
mo _ SVMasterObject.RevoSweepMakeMasterObject[revName, path, linesOfLongitude];

IF arg = $Add THEN {
[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
SVScene.AddMasterObjectToScene[mo, scene
! NameAlreadyPresent => {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Revolute sweep name ", mo.name, " is already registered.  Try another."], oneLiner];
Feedback.BlinkRaw[$Solidviews]; addSucceeds _ FALSE; CONTINUE}
];
IF NOT addSucceeds THEN RETURN;
[newAssembly, ----, addSucceeds] _ SVAssembly.CreatePrimitive[revName, revName, scene];
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, [1,1,1], superAssembly, Matrix3d.Identity[], scene];
IF NOT addSucceeds THEN RETURN;
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectAdded, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
}
ELSE IF arg = $Replace THEN {
oldMoWasRevo, moFound: BOOL _ TRUE;
shape: Shape;
assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
IF NOT ISTYPE[assembly.shape, Shape] THEN {
errorRope _ IO.PutFR["Can't substitue a revolute sweep for a cluster assembly [%g]",[rope[assembly.name]]];
Feedback.AppendRaw[$Solidviews, errorRope, oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN};
mo.name _ SVScene.UniqueObjectNameFrom[mo.name, scene];
SVScene.AddMasterObjectToScene[mo, scene];
shape _ NARROW[assembly.shape];
oldMo _ shape.mo;
oldMoWasRevo _ Rope.Equal[oldMo.class.name, "revoluteSweep", TRUE];
shape.mo _ mo;
IF NOT SVScene.MasterObjectIsUsed[oldMo, scene] THEN moFound _ SVScene.DeleteMasterObjectNamed[oldMo.name, scene];
IF NOT moFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Old master object ", oldMo.name, "mysteriously disappeared.  Save your work"], oneLiner];
Feedback.BlinkRaw[$Solidviews] };
IF NOT oldMoWasRevo THEN CoordSys.SetScalars[shape.coordSys, [1, 1, 1]];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectChangedBoundBoxProvided, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
}; -- end of AddRevolute

AddLinear: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scratchpad: Viewer _ editToolData.scratchpad;
sweepOK: BOOL _ TRUE;
frontDepth, backDepth: REAL;
lengthRope: Rope.ROPE;
mo: MasterObject;
linMesh: LinearMesh;
path: Path;
poly: Polygon;
arg: ATOM _ NARROW[event.rest.first];
linName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];

lengthRope _ ViewerTools.GetContents[editToolData.linSection.depth];
frontDepth _ SVViewerTools.GetReal[editToolData.linSection.depth, 100]/2.0;
backDepth _ -frontDepth;

path _ SVScratchpad.GetPath[scratchpad];
poly _ SVPolygon2d.PathToPolygon[path];
linMesh _ SweepGeometry.LinearSweep[poly, frontDepth, backDepth
! SweepGeometry.TooFewPointsForShadedSweep => {
Feedback.AppendRaw[$Solidviews, "Too few points for a linear sweep.", oneLiner];
Feedback.BlinkRaw[$Solidviews];
sweepOK _ FALSE;
CONTINUE;
};
];
IF NOT sweepOK THEN RETURN;
mo _ SVMasterObject.LinSweepMakeMasterObject[linName, linMesh];
AddUnsharedAux[editToolData, mo, linName, arg, "Linear sweep", [1,1,1], "linearSweep"];
}; -- end of AddLinear

AddUnsharedAux: PROC [editToolData: EditToolData, mo: MasterObject, newName: Rope.ROPE, arg: ATOM, objType: Rope.ROPE, scalars: Vector3d _ [1,1,1], leaveScalarsClass: Rope.ROPE _ NIL] = {
newAssembly, superAssembly, assembly: Slice;
oldMo: MasterObject;
moFound: BOOL _ TRUE;
scene: Scene _ editToolData.sceneSection.currentScene;
addSucceeds: BOOL _ TRUE;
success: BOOL;

IF arg = $Add THEN {
[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
SVScene.AddMasterObjectToScene[mo, scene
! NameAlreadyPresent => {
Feedback.PutFRaw[$Solidviews, oneLiner, "%g name %g is already registered.  Try another.", [rope[objType]], [rope[mo.name]]];
Feedback.BlinkRaw[$Solidviews]; addSucceeds _ FALSE; CONTINUE}
];
IF NOT addSucceeds THEN RETURN;
[newAssembly, moFound, addSucceeds] _ SVAssembly.CreatePrimitive[newName, newName, scene];
IF NOT moFound THEN ERROR;
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, scalars, superAssembly, Matrix3d.Identity[], scene];
IF NOT addSucceeds THEN RETURN;
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectAdded, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
}
ELSE IF arg = $Replace THEN {
shape: Shape;
assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
IF NOT ISTYPE[assembly.shape, Shape] THEN {
Feedback.PutFRaw[$Solidviews, oneLiner, "Can't substitute a %g for a cluster assembly (%g)", [rope[objType]], [rope[assembly.name]] ];
Feedback.BlinkRaw[$Solidviews];
RETURN};
mo.name _ SVScene.UniqueObjectNameFrom[mo.name, scene];
SVScene.AddMasterObjectToScene[mo, scene];
shape _ NARROW[assembly.shape];
oldMo _ shape.mo;
IF NOT (leaveScalarsClass # NIL AND Rope.Equal[oldMo.class.name, leaveScalarsClass, TRUE]) THEN CoordSys.SetScalars[shape.coordSys, scalars];
shape.mo _ mo;
IF NOT SVScene.MasterObjectIsUsed[oldMo, scene] THEN moFound _ SVScene.DeleteMasterObjectNamed[oldMo.name, scene];
IF NOT moFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Old master object ", oldMo.name, "mysteriously disappeared.  Save your work"], oneLiner];
Feedback.BlinkRaw[$Solidviews]
};
SVViewersOnScene.PaintSceneAllViewers[paintAction: $ObjectChangedBoundBoxProvided, editToolData: editToolData, scene: scene, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
};


Copy: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ editToolData.sceneSection.currentScene;
parentToBe, assembly, assemblyCopy: Slice;
found, success: BOOL;

assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
[parentToBe, found] _ SVEditUser.GetParent[editToolData];
IF NOT found THEN RETURN;
success _ TRUE;
assemblyCopy _ SVScene.CopyAssemblyAndSonsUniqueNames[assembly, scene, scene, parentToBe, editToolData.currentSVData.feedback
!SVScene.NameAlreadyPresent => {success _ FALSE; CONTINUE}];
IF NOT success THEN {
Feedback.AppendRaw[$Solidviews, "Some name in assembly is already present", oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN;
};
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
}; -- end of Copy

Rename: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ editToolData.sceneSection.currentScene;
assembly: Slice;
oldName: Rope.ROPE;
newName: Rope.ROPE _ ViewerTools.GetContents[editToolData.sceneSection.new];

assembly _ SVSelections.TopMoveeCoincident[];
IF assembly = NIL THEN RETURN;
oldName _ assembly.name;
SVScene.RenameAssembly[assembly, newName, scene];
Feedback.AppendRaw[$Solidviews, Rope.Cat["Slice ", oldName, " renamed to ", newName, "."], oneLiner];
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
};

NewParent: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ editToolData.sceneSection.currentScene;
parentToBe: Slice;
found, parentIsPrimitive: BOOL;
g: SelectionGenerator;
selectionsExist: BOOL;

[g, selectionsExist] _ SVSelections.GetSelectionGenerator[movee];
SVSelections.ComplainIfNot[selectionsExist];
IF NOT selectionsExist THEN RETURN;
[parentToBe, found] _ SVEditUser.GetParent[editToolData];
IF NOT found THEN RETURN;
FOR assembly: Slice _ SVSelections.NextSelectionCoincident[g], SVSelections.NextSelectionCoincident[g] UNTIL assembly = NIL DO
SVScene.MoveSubassembly[assembly, parentToBe, scene
! SVAssembly.AttemptToAddSubassemblyToPrimitive =>
{parentIsPrimitive _ TRUE; CONTINUE}];
IF parentIsPrimitive THEN GOTO PrimitiveParent;
REPEAT
PrimitiveParent => {
Feedback.AppendRaw[$Solidviews, "A primitive can't be a parent.", oneLiner];
Feedback.BlinkRaw[$Solidviews];
};
ENDLOOP;
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
};


END.


ΐFile: SVEditUserImplB.mesa
Created in October 1982
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Last edited by Bier on May 25, 1987 5:15:17 pm PDT
Contents: All of the procedures called by SVEditTool when menus and buttons are pressed
Basic Shapes
If mouseButton = red or yellow, then make sure this assembly name is unique and add a new sphere by this name.  if mouseButton = blue, then find the old assembly by this name.  Make sure it is a primitive assembly.  Let it refer to halfSpace as its master object and use the new scalar values.
If mouseButton = red or yellow, then make sure this assembly name is unique and add a new sphere by this name.  if mouseButton = blue, then find the old assembly by this name.  Make sure it is a primitive assembly.  Let it refer to sphere as its master object and use the new scalar values.
We need to know the size of the master object in order to know what scalars to use to achieve a sphere of the size requested by the user.
We need to know the size of the master object in order to know what scalars to use to achieve a cylinder of the size requested by the user.
Create a new revolute master object.
mo.name should be unique, so NameAlreadyPresent would be a surprise.
If we are replacing an old revolute sweep with a new one, then leave the scalars as they are.  Otherwise, set them all to unity.
Create a new linear master object
Since the copy is on top of the original, there is no need to redraw.
Κ‘–

"cedar" style˜IheadšΟnœ™Iprocš
œ™Jšœ
Οm
œ1™<Lš
œ2™2LšœO™WL˜š
Οk	˜	LšœŸœ›˜Ή—L˜šœŸœ
Ÿ˜LšŸœŸœ§
˜Ε
LšŸœ
˜—L˜Lš
Ÿ˜˜LšœŸœ˜!LšœŸœ˜)LšœŸœ˜4LšœŸœ˜LšœŸœ!˜3Lšœ
Ÿœ˜-LšœŸœ˜,LšœŸœ˜/LšœŸœ˜#Lšœ
Ÿœ˜&LšœŸœ˜8Lšœ	Ÿœ˜Lšœ	Ÿœ˜LšœŸœ˜0LšœŸœ
˜LšœŸœ˜!LšœŸœ'˜?LšœŸœ˜!Lšœ
Ÿœ˜LšœŸœ˜$LšœŸœ˜/LšœŸœ˜'L˜Lš
œ™L˜LšœŸœ˜/LšœŸœ!˜0LšœŸœ!˜0Lšœ
Ÿœ#˜4Lšœ	Ÿœ˜,Lšœ
Ÿœ ˜.L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜FLš
œ₯™₯Lš
œ1˜1Lš
œ6˜6LšœŸœ
˜Lšœ
ŸœŸœ
˜LšœŸœ5Οbœ˜RLš
œ,˜,Lšœ	Ÿœ
˜LšœŸœŸœ˜%L˜Lš
œ˜Lšœ	Ÿœ
˜Lš
œ˜L˜Lš
œH˜HLšŸœ
Ÿœ	Ÿœ
Ÿœ
˜LšœŸœ˜,L˜šŸœŸœ˜Lš
œ>˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜LšœΟcœO˜aLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œi˜iLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œ=˜=Lš
œI˜ILš
œ
˜
—šŸœ
ŸœŸœ˜Lš
œ˜L˜
Lš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜Lš
œ?˜?LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸœ˜+LšœŸœV˜dLš
œ5˜5Lš
œ˜LšŸœ˜—LšœŸœ˜Lš
œ˜Lš
œ˜JšŸœ
Ÿœ*Ÿœ>˜ršŸœ
Ÿœ	Ÿœ˜Lš
œƒ
˜ƒ
Lš
œ!˜!—Lš
œ/˜/Lšœ…
Ÿœ˜‹
Lš
œ˜—Lšœ‘˜L˜—š	œŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜CLš
œ’™’Lš
œ1˜1Lš
œ6˜6LšœŸœ
˜Lšœ
ŸœŸœ
˜LšœŸœ5 œ˜OLšœŸœA˜MLš
œ,˜,Lšœ	Ÿœ
˜LšœŸœŸœ˜%L˜Lš
œ˜Lšœ	Ÿœ
˜Lš
œ˜Lšœ
Ÿœ
˜L˜Lš
œB˜BLšŸœ
Ÿœ	Ÿœ
Ÿœ
˜LšœŸœ˜&Lš
œ˜Lš
œ˜L˜Lš
œ‰
™‰
L˜šŸœŸœ˜Lš
œ>˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜Lšœ‘œI˜[LšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œx˜xLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lšœˆ
Ÿœ
ŸœŸœ˜Ά
Lš
œ
˜
—šŸœ
ŸœŸœ˜Lš
œ˜L˜
Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜Lš
œ<˜<LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸœ˜+LšœŸœU˜cLš
œ5˜5Lš
œ˜LšŸœ˜—LšœŸœ˜Lš
œ˜Lš
œ˜JšŸœ
Ÿœ*Ÿœ>˜ršŸœ
Ÿœ	Ÿœ˜Lš
œƒ
˜ƒ
Lš
œ!˜!—Lš
œ>˜>Lšœš
Ÿœ
ŸœŸœ˜Θ
Lš
œ˜—Lšœ‘˜L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜BLš
œ1˜1Lšœ	Ÿœ
˜LšœŸœ5 œ˜NLšœŸœŸœ˜%Lš
œ˜L˜Lš
œ˜Lš
œ:˜:Lš
œG˜GLš
œ ˜ L˜Lš
œH˜HL˜L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜@Lš
œ1˜1Lš
œ6˜6LšœŸœ
˜Lšœ
ŸœŸœ
˜LšœŸœ5 œ˜LLšœŸœC˜OLšœŸœC˜OLš
œ,˜,Lšœ	Ÿœ
˜LšœŸœŸœ˜%L˜Lš
œ˜Lšœ	ŸœŸœ
˜Lš
œ˜Lš
œA˜ALšŸœ
Ÿœ	Ÿœ
Ÿœ
˜LšœŸœ˜%Lš
œ‹
™‹
L˜Lš
œH˜HL˜šŸœŸœ˜Lšœ& 	œ˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜Lšœ‘œH˜ZLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œx˜xLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lšœˆ
Ÿœ
ŸœŸœ˜Ά
Lš
œ
˜
—šŸœ
ŸœŸœ˜Lš
œ˜L˜
Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜Lš
œ>˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸœ˜+LšœŸœX˜fLš
œ5˜5Lš
œ˜LšŸœ˜—LšœŸœ˜Lš
œ˜Lš
œ˜JšŸœ
Ÿœ*Ÿœ>˜ršŸœ
Ÿœ	Ÿœ˜Lš
œƒ
˜ƒ
Lš
œ!˜!—Lš
œ>˜>Lšœš
Ÿœ
ŸœŸœ˜Θ
Lš
œ˜—Lšœ‘˜L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜ALš
œ1˜1LšœŸœ5 œ˜MLšœŸœ?˜KLšœŸœ?˜KLšœŸœŸœ˜%L˜Lšœ
ŸœŸœ
˜LšœŸœ
˜Lš
œ,˜,Lšœ	Ÿœ
˜Lš
œ6˜6L˜Lš
œ˜Lšœ	ŸœŸœ
˜Lš
œ˜Lš
œ>˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜Lšœ
Ÿœ˜"Lš
œ@˜@Lš
œ#˜#L˜šŸœŸœ˜Lšœ& 	œ˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜Lšœ‘œE˜WLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œg˜gLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lšœˆ
Ÿœ
ŸœŸœ˜Ά
Lš
œ
˜
—šŸœ
ŸœŸœ˜Lš
œ˜L˜
Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜Lš
œ:˜:LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸœ˜+LšœŸœS˜aLš
œ5˜5Lš
œ˜LšŸœ˜—LšœŸœ˜Lš
œ˜Lš
œ˜JšŸœ
Ÿœ*Ÿœ>˜ršŸœ
Ÿœ	Ÿœ˜Lš
œƒ
˜ƒ
Lš
œ!˜!—Lš
œ-˜-Lšœš
Ÿœ
ŸœŸœ˜Θ
Lš
œ˜—Lšœ‘˜L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜BLš
œ1˜1Lš
œ˜LšœŸœ:˜NLšœŸœ
˜LšœŸœŸœ˜%L˜Lš
œL˜LLš
œT˜TLš
œO˜OLš
œ:˜:Lšœ‘˜L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜ALš
œ1˜1Lš
œ-˜-LšœŸœ˜Lš
œ6˜6LšœŸœ
˜Lšœ
ŸœŸœ
˜LšœŸœ5 œ˜LLš
œ˜Lš
œ˜Lš
œ,˜,Lšœ	Ÿœ
˜LšœŸœŸœ˜%L˜Lš
œ$™$Lš
œ(˜(šŸœŸœ˜Lš
œT˜TLš
œ˜LšŸœ˜—Lšœ œ"˜OL˜šŸœŸœ˜Lš
œ>˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šœ œ
˜(š
œ˜Lš
œ~˜~Lšœ.ŸœŸœ
˜>Lš
œ˜——LšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lšœ‘œE˜WLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œg˜gLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lšœˆ
Ÿœ
ŸœŸœ˜Ά
Lš
œ
˜
—šŸœ
ŸœŸœ˜LšœŸœ
˜#L˜
Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸœ˜+LšœŸœ]˜kLš
œ5˜5Lš
œ˜LšŸœ˜—Lš
œ7˜7šœ œ˜*L™D—LšœŸœ˜Lš
œ˜Lšœ=Ÿœ˜CLš
œ˜JšŸœ
Ÿœ*Ÿœ>˜ršŸœ
Ÿœ	Ÿœ˜Lš
œƒ
˜ƒ
Lš
œ!˜!—L™€
LšŸœ
ŸœŸœ0˜HLšœš
Ÿœ
ŸœŸœ˜Θ
Lš
œ˜—Lšœ‘˜L˜—š	œŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜CLš
œ1˜1Lš
œ-˜-Lšœ	ŸœŸœ
˜LšœŸœ
˜LšœŸœ
˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜LšœŸœŸœ˜%LšœŸœ5 œ˜LL˜Lš
œD˜DLš
œK˜KLš
œ˜L˜Lš
œ!™!Lš
œ(˜(Lš
œ'˜'š
œ?˜?š
œ/˜/Lš
œP˜PLš
œ˜Lšœ
Ÿœ
˜LšŸœ
˜	L˜—Lš
œ˜—LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜Lš
œ?˜?Lš
œW˜WLšœ‘˜—L˜šœŸœ>ŸœŸœŸœ7ŸœŸœ˜»
Lš
œ,˜,Lš
œ˜Lšœ	ŸœŸœ
˜Lš
œ6˜6Lšœ
ŸœŸœ
˜Lšœ	Ÿœ
˜L˜šŸœŸœ˜Lš
œ>˜>LšŸœ
Ÿœ	Ÿœ
Ÿœ
˜šœ œ
˜(š
œ˜Lš
œ}˜}Lšœ.ŸœŸœ
˜>Lš
œ˜——LšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œZ˜ZLšŸœ
Ÿœ	Ÿœ
Ÿœ
˜LšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lš
œg˜gLšŸœ
Ÿœ
Ÿœ
Ÿœ
˜Lšœˆ
Ÿœ
ŸœŸœ˜Ά
Lš
œ
˜
—šŸœ
ŸœŸœ˜L˜
Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜šŸœ
Ÿœ
ŸœŸœ˜+Lš
Ϡ
˜†
Lš
œ˜LšŸœ˜—Lš
œ7˜7Lšœ œ˜*LšœŸœ˜Lš
œ˜Lš
ŸœŸœ
Ÿœ1ŸœŸœ.˜
Lš
œ˜JšŸœ
Ÿœ*Ÿœ>˜ršŸœ
Ÿœ	Ÿœ˜Lš
œƒ
˜ƒ
Lš
œ˜Lš
œ˜—Lšœš
Ÿœ
ŸœŸœ˜Θ
Lš
œ˜—L˜L˜—L˜šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜>Lš
œ1˜1Lš
œ6˜6Lš
œ*˜*LšœŸœ
˜J˜Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜Lš
œ9˜9LšŸœ
ŸœŸœ
Ÿœ
˜Lšœ
Ÿœ
˜š
œ}˜}Lšœ*ŸœŸœ˜<—šŸœ
Ÿœ	Ÿœ˜Lš
œV˜VLš
œ˜LšŸœ
˜Lš
œ˜—š
œ=˜=L™E—Lšœ‘˜L˜—šœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜@Lš
œ1˜1Lš
œ6˜6Lš
œ˜LšœŸœ
˜LšœŸœ5 œ˜LL˜Jš
œ-˜-LšŸœŸœ
Ÿœ
Ÿœ
˜Lš
œ˜Lš
œ1˜1Lš
œe˜eLš
œ=˜=Lš
œ˜L˜—š	œŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜CLš
œ1˜1Lš
œ6˜6Lš
œ˜LšœŸœ
˜Jš
œ˜JšœŸœ
˜L˜Jš
œA˜AJš
œ,˜,JšŸœ
ŸœŸœ
Ÿœ
˜#Lš
œ9˜9LšŸœ
ŸœŸœ
Ÿœ
˜šŸœdŸœŸœ
Ÿ˜~š
œ3˜3š
œ2˜2LšœŸœŸœ˜&——LšŸœŸœ
Ÿœ˜/—š
Ÿ˜˜Lš
œL˜LLš
œ˜Lš
œ˜——JšŸœ
˜Lš
œ=˜=Lš
œ˜—L˜L˜LšŸœ
˜L˜L˜—…—Tom