
<<File: SVEditUserImplB.mesa>>
<<Created in October 1982>>
<<Copyright © 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>>

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;

<<Basic Shapes>>

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] = {
<<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.>>
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] = {
<<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.>>
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;

<<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.>>

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];
<<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.>>

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];

<<Create a new revolute master object.>>
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];
<<mo.name should be unique, so NameAlreadyPresent would be a surprise.>>
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 we are replacing an old revolute sweep with a new one, then leave the scalars as they are.  Otherwise, set them all to unity.>>
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;

<<Create a new linear master object>>
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];
<<Since the copy is on top of the original, there is no need to redraw.>>
}; -- 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.