GGSelectImpl.mesa
Contents: Procedures dealing selecting and deselecting objects, including both selection actions and selection feedback.
Copyright Ó 1988, 1992 by Xerox Corporation. All rights reserved.
Pier, November 10, 1988 4:41:22 pm PST
Kurlander August 28, 1986 7:54:12 pm PDT
Bier, June 22, 1989 9:22:07 pm PDT
DIRECTORY
GGBasicTypes, GGBoundBox, GGCoreTypes, GGModelTypes, GGOutline, GGParent, GGScene, GGSceneType, GGSegmentTypes, GGSelect, GGSequence, GGSlice, GGSliceOps, GGTraj, TextNode;
GGSelectImpl: CEDAR PROGRAM
IMPORTS GGBoundBox, GGOutline, GGParent, GGScene, GGSequence, GGSlice, GGSliceOps, GGTraj
EXPORTS GGModelTypes, GGSelect = BEGIN
BoundBox: TYPE = GGCoreTypes.BoundBox;
Joint: TYPE = GGModelTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
OutlineParts: TYPE = GGOutline.OutlineParts;
Scene: TYPE = GGModelTypes.Scene;
SceneObj: PUBLIC TYPE = GGSceneType.SceneObj;
SegAndIndex: TYPE = GGSequence.SegAndIndex;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
Sequence: TYPE = GGModelTypes.Sequence;
SequenceGenerator: TYPE = GGSequence.SequenceGenerator;
SequenceGeneratorObj: TYPE = GGSequence.SequenceGeneratorObj;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceDescriptorGeneratorObj: TYPE = GGModelTypes.SliceDescriptorGeneratorObj;
SliceDescriptorObj: TYPE = GGModelTypes.SliceDescriptorObj;
SliceDescriptorWalkProc: TYPE = GGModelTypes.SliceDescriptorWalkProc;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceGeneratorObj: TYPE = GGModelTypes.SliceGeneratorObj;
SliceParts: TYPE = GGModelTypes.SliceParts;
SliceWalkProc: TYPE = GGModelTypes.SliceWalkProc;
SlicePartsWalkProc: TYPE = GGModelTypes.SlicePartsWalkProc;
TrajData: TYPE = GGModelTypes.TrajData;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajParts: TYPE = GGModelTypes.TrajParts;
OutlineSequenceGenerator: TYPE = REF OutlineSequenceGeneratorObj;
OutlineSequenceGeneratorObj: TYPE = RECORD [
list: LIST OF OutlineSequence
];
OutlineSequence: TYPE = REF OutlineSequenceObj;
OutlineSequenceObj: TYPE = RECORD [
outline: Slice,  -- the outline represented by this record
fenceParts: TrajParts,  -- included parts of the fence trajectory
holeParts: LIST OF TrajParts -- included parts of holes
];
NotYetImplemented: PUBLIC SIGNAL = CODE;
Implementation Notes (updated July 6, 1987, by Bier)
The Selection mechanism maintains two "structures" which must be kept consistent. The first is a list of selected SliceDescriptors: scene.selected. The second is the set of "selectedInFull" fields in each of the selected slices.
To efficiently answer IsSelectedInFull queries, "selectedInFull" fields are found in slices, segments, joints, and control points. IsSelectedInFull is expensive for trajectories, and more expensive for outlines.
To efficiently answer IsSelectedInPart queries, the selectedInFull field does double duty in segments, joints, control points, and slices. IsSelectedInPart is somewhat expensive for outlines.
The following invariants should be maintained:
1) If a SliceDescriptor is on the selected list, all of the selectedInFull fields of its joints, segments, and control points should be TRUE. The selected fields are maintained for efficiency only. The information they represent is always obtainable from the selected list as well.
Converse of 1: If no sequence representing a given joint, segment, or control point is on the selected list, then the selectedInFull field of that entity should be FALSE.
2) Only one sequence per trajectory may appear on the selected list.
Corollary of 1 and 2: Any given selected flag is caused by a single element of the selected list. GetSelectedSequence will find that element (for joint, segments, and control points). A selected slice is its own cause.
3) A slice may only appear once on the selected list.
4) Iff a sequence representing a trajectory is on the selected list, the "selectedInPart" field of the trajectory will TRUE.
5) Iff a non-Outline slice is on the selected list, the "selectedInFull" field of that slice will be true.
These invariants will be maintained with the help of SetComponentSelectedFields.
Basic Selecting and Deselecting
ChangeDonkeyTail: PROC [sliceD: SliceDescriptor, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => sliceD.slice.normalSelectedParts ¬ sliceD;
hot => sliceD.slice.hotSelectedParts ¬ sliceD;
active => sliceD.slice.activeSelectedParts ¬ sliceD;
match => sliceD.slice.matchSelectedParts ¬ sliceD;
ENDCASE;
};
NoDonkeyTail: PROC [slice: Slice, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => slice.normalSelectedParts ¬ NIL;
hot => slice.hotSelectedParts ¬ NIL;
active => slice.activeSelectedParts ¬ NIL;
match => slice.matchSelectedParts ¬ NIL;
ENDCASE;
};
SelectAll: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] = {
DoSelectSlice: PROC [slice: Slice] RETURNS [done: BOOL ¬ FALSE] = {
SelectEntireSlice[slice, scene, selectClass];
};
[] ¬ GGScene.WalkSlices[scene, first, DoSelectSlice];
IF selectClass = normal THEN {
IF scene.selected.normal = NIL OR scene.selected.normal.rest # NIL
THEN scene.selected.normalLast ¬ NIL
ELSE scene.selected.normalLast ¬ scene.selected.normal.first;
};
};
SelectSliceFromParts: PUBLIC PROC [slice: Slice, parts: SliceParts, scene: Scene, selectClass: SelectionClass] = {
sliceD: SliceDescriptor ¬ GGSlice.DescriptorFromParts[slice, parts];
SelectSlice[sliceD, scene, selectClass];
IF selectClass = normal THEN scene.selected.normalLast ¬ GGParent.TopLevelDescriptorFromChildDescriptor[sliceD];
};
SelectSlice: PUBLIC PROC [sliceD: SliceDescriptor, scene: Scene, selectClass: SelectionClass] = {
oldSliceD, union: SliceDescriptor;
IF sliceD=NIL OR sliceD.parts = NIL OR GGSliceOps.IsEmptyParts[sliceD] THEN RETURN;
sliceD ¬ GGParent.TopLevelDescriptorFromChildDescriptor[sliceD];
oldSliceD ¬ FindSelectedSlice[sliceD.slice, selectClass];
IF oldSliceD#NIL THEN {
union ¬ GGSliceOps.UnionParts[oldSliceD, sliceD];
DeselectSlice[sliceD.slice, oldSliceD.parts, scene, selectClass]; -- throw away old selection
}
ELSE union ¬ sliceD;
IF selectClass = normal THEN union ¬ GGSliceOps.AugmentParts[union, selectClass];
AppendSelection[scene, union, selectClass];
ChangeDonkeyTail[union, selectClass];
IF selectClass = normal THEN scene.selected.normalLast ¬ GGParent.TopLevelDescriptorFromChildDescriptor[sliceD];
}; -- end SelectSlice
SelectEntireSlice: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] = {
allParts: SliceDescriptor ¬ GGSliceOps.NewParts[slice, NIL, slice];
SelectSlice[allParts, scene, selectClass];
};
DuplicateSelections: PUBLIC PROC [scene: Scene, fromClass: SelectionClass, toClass: SelectionClass] = {
DoSelectSlice: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL ¬ FALSE] = {
SelectSlice[sliceD, scene, toClass];
};
IF fromClass=toClass THEN RETURN;
[] ¬ GGScene.WalkSelectedSlices[scene, first, DoSelectSlice, fromClass];
};
DeselectEntity: PUBLIC PROC [entity: REF ANY, scene: Scene, selectClass: SelectionClass] = {
WITH entity SELECT FROM
slice: Slice => DeselectEntireSlice[slice, scene, selectClass];
sliceD: SliceDescriptor => DeselectSlice[sliceD.slice, sliceD.parts, scene, selectClass];
ENDCASE => ERROR;
};
DeselectEntityAllClasses: PUBLIC PROC [entity: REF ANY, scene: Scene] = {
DeselectEntity[entity, scene, normal];
DeselectEntity[entity, scene, active];
DeselectEntity[entity, scene, hot];
DeselectEntity[entity, scene, match];
};
DeselectAll: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] = {
Clear all flags that indicate the selection of each object.
FOR sliceD: LIST OF SliceDescriptor ¬ ListSelected[scene, selectClass], sliceD.rest UNTIL sliceD = NIL DO
NoDonkeyTail[sliceD.first.slice, selectClass];
ENDLOOP;
SetSelectedList[scene, NIL, selectClass];
};
DeselectAllAllClasses: PUBLIC PROC [scene: Scene] = {
DeselectAll[scene, normal];
DeselectAll[scene, active];
DeselectAll[scene, hot];
DeselectAll[scene, match];
};
DeselectEntireSlice: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] = {
Remove this slice from the selected list, and reset all selected fields.
IF GGScene.IsTopLevel[slice] THEN {
sliceD: SliceDescriptor ¬ FindSelectedSlice[slice, selectClass];
IF sliceD # NIL THEN {
DeleteSelection[scene, sliceD, selectClass];
NoDonkeyTail[sliceD.slice, selectClass];
};
IF selectClass = normal THEN
IF scene.selected.normalLast # NIL AND scene.selected.normalLast.slice = slice
THEN scene.selected.normalLast ¬ NIL;
}
ELSE {
entireD: SliceDescriptor ¬ GGSliceOps.NewParts[slice, NIL, slice];
DeselectSlice[entireD.slice, entireD.parts, scene, selectClass];
};
};
DeselectSlice: PUBLIC PROC [slice: Slice, parts: SliceParts, scene: Scene, selectClass: SelectionClass] = {
oldD, newD, tempD: SliceDescriptor;
tempD ¬ GGSlice.DescriptorFromParts[slice, parts];
tempD ¬ GGParent.TopLevelDescriptorFromChildDescriptor[tempD];
oldD ¬ FindSelectedSlice[tempD.slice, selectClass];
IF oldD#NIL THEN {
newD ¬ GGSliceOps.DifferenceParts[oldD, tempD];
DeleteSelection[scene, oldD, selectClass];
NoDonkeyTail[oldD.slice, selectClass];
IF NOT GGSliceOps.IsEmptyParts[newD] THEN {
IF selectClass = normal THEN newD ¬ GGSliceOps.AugmentParts[newD, selectClass];
AppendSelection[scene, newD, selectClass];
ChangeDonkeyTail[newD, selectClass];
};
IF selectClass = normal THEN {
IF scene.selected.normalLast # NIL AND scene.selected.normalLast.slice = slice
THEN scene.selected.normalLast ¬ GGSliceOps.DifferenceParts[scene.selected.normalLast, tempD];
IF scene.selected.normalLast = NIL OR GGSliceOps.IsEmptyParts[scene.selected.normalLast]
THEN scene.selected.normalLast ¬ NIL;
};
};
};
DeselectTraj: PROC [traj: Slice, scene: Scene, selectClass: SelectionClass] = {
Very much like DeselectSlice, but optimized for the single Traj case.
ancestor: Slice ¬ GGParent.GetTopLevelAncestor[traj];
oldD: SliceDescriptor ¬ FindSelectedSlice[ancestor, selectClass];
IF oldD#NIL THEN {
newD: SliceDescriptor ¬ GGParent.RemoveTraj[oldD, traj];
DeleteSelection[scene, oldD, selectClass];
NoDonkeyTail[ancestor, selectClass];
IF NOT GGSliceOps.IsEmptyParts[newD] THEN {
AppendSelection[scene, newD, selectClass];
ChangeDonkeyTail[newD, selectClass];
};
IF selectClass = normal THEN
IF scene.selected.normalLast # NIL AND scene.selected.normalLast.slice = ancestor
THEN {
scene.selected.normalLast ¬ GGParent.RemoveTraj[scene.selected.normalLast, traj];
IF scene.selected.normalLast = NIL OR GGSliceOps.IsEmptyParts[scene.selected.normalLast]
THEN scene.selected.normalLast ¬ NIL;
};
};
};
Updating Selections When Sequences Become Obsolete
SaveSelectionsInSliceAllClasses: PUBLIC PROC [slice: Slice, scene: Scene] = {
sliceD: SliceDescriptor;
sliceD ¬ FindSelectedSlice[slice, normal];
GGSliceOps.SaveSelections[slice, IF sliceD = NIL THEN NIL ELSE sliceD.parts, normal];
sliceD ¬ FindSelectedSlice[slice, hot];
GGSliceOps.SaveSelections[slice, IF sliceD = NIL THEN NIL ELSE sliceD.parts, hot];
sliceD ¬ FindSelectedSlice[slice, active];
GGSliceOps.SaveSelections[slice, IF sliceD = NIL THEN NIL ELSE sliceD.parts, active];
sliceD ¬ FindSelectedSlice[slice, match];
GGSliceOps.SaveSelections[slice, IF sliceD = NIL THEN NIL ELSE sliceD.parts, match];
};
RemakeSelections: PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] RETURNS [isTopLevel: BOOL ¬ FALSE] = {
parts: SliceParts ¬ GGSliceOps.RemakeSelections[slice, selectClass];
IF GGScene.IsTopLevel[slice] THEN {
DeselectEntireSlice[slice, scene, selectClass]; -- get rid of old selection
SelectSliceFromParts[slice, parts, scene, selectClass];
isTopLevel ¬ TRUE;
};
};
ReselectSliceAllClasses: PUBLIC PROC [slice: Slice, scene: Scene] = {
[] ¬ RemakeSelections[slice, scene, normal];
[] ¬ RemakeSelections[slice, scene, hot];
[] ¬ RemakeSelections[slice, scene, active];
[] ¬ RemakeSelections[slice, scene, match];
};
ReselectTraj: PUBLIC PROC [traj: Slice, trajEnd: TrajEnd, scene: Scene, extend: BOOL] RETURNS [newHot: Sequence] = {
This routine propogates the former selection (say, hotness) to a newly extended traj and extends the selection to its end if extend = TRUE.
newOutlineD: SliceDescriptor;
newTrajD: SliceDescriptor;
selSeq: Sequence;
newSeqParts, newHotParts: TrajParts;
selSeq ¬ FindSelectedSequence[traj, scene, normal];
normal selections
IF selSeq#NIL THEN {
newSeqParts ¬ GGSequence.Augment[selSeq, trajEnd, extend];
DeselectTraj[selSeq.slice, scene, normal];
newTrajD ¬ GGSlice.DescriptorFromParts[traj, newSeqParts];
SelectSlice[newTrajD, scene, normal];
};
hot selections
selSeq ¬ FindSelectedSequence[traj, scene, hot];
IF selSeq#NIL THEN {
newHotParts ¬ newSeqParts ¬ GGSequence.Augment[selSeq, trajEnd, extend];
DeselectTraj[selSeq.slice, scene, hot]; -- assumes second level Traj
newTrajD ¬ newHot ¬ GGSlice.DescriptorFromParts[traj, newSeqParts];
SelectSlice[newTrajD, scene, hot];
};
Ignore active and match selections
};
Utilities
DeleteSelection: PROC [scene: Scene, entity: SliceDescriptor, selectClass: SelectionClass] = {
Deletes entity from list. If it is not on the list, do nothing.
SetSelectedList[scene,
DRemove[entity, ListSelected[scene, selectClass]],
selectClass];
};
Operations which dispatch on the SelectionClass:
ListSelected: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] RETURNS [selectedList: LIST OF SliceDescriptor] = {
SELECT selectClass FROM
normal => selectedList ¬ scene.selected.normal;
hot => selectedList ¬ scene.selected.hot;
active => selectedList ¬ scene.selected.active;
match => selectedList ¬ scene.selected.match;
ENDCASE => ERROR;
};
SetSelected: PUBLIC PROC [scene: Scene, selectClass: SelectionClass, selected: LIST OF SliceDescriptor] = {
For each SliceDescriptor in selected that is not obsolete, re-establish that selection. Remember to call DeselectAll[scene, selectClass] if you wish to replace any existing selections.
FOR list: LIST OF SliceDescriptor ¬ selected, list.rest UNTIL list = NIL DO
SelectSlice[list.first, scene, selectClass];
ENDLOOP;
};
SetJointField: PROC [joint: Joint, selected: BOOL, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => joint.TselectedInFull.normal ¬ selected;
hot => joint.TselectedInFull.hot ¬ selected;
active => joint.TselectedInFull.active ¬ selected;
match => joint.TselectedInFull.match ¬ selected;
ENDCASE;
};
SetSegmentField: PROC [seg: Segment, selected: BOOL, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => seg.TselectedInFull.normal ¬ selected;
hot => seg.TselectedInFull.hot ¬ selected;
active => seg.TselectedInFull.active ¬ selected;
match => seg.TselectedInFull.match ¬ selected;
ENDCASE;
};
OPERATIONS THAT ALTER THE SELECTED LISTS
AppendSelection: PROC [scene: Scene, entity: SliceDescriptor, selectClass: SelectionClass] = {
Build the selection list in the proper order and keep it that way.
SELECT selectClass FROM
normal => {
IF scene.selected.normal = NIL THEN {
scene.selected.normal ¬ LIST[entity];
scene.selected.normalPtr ¬ scene.selected.normal;
scene.selected.normalPtrValid ¬ TRUE;
}
ELSE IF scene.selected.normalPtrValid THEN {
scene.selected.normalPtr.rest ¬ LIST[entity];
scene.selected.normalPtr ¬ scene.selected.normalPtr.rest;
}
ELSE {
scene.selected.normalPtr ¬ LastSliceDescriptor[scene.selected.normal];
scene.selected.normalPtr.rest ¬ LIST[entity];
scene.selected.normalPtr ¬ scene.selected.normalPtr.rest;
scene.selected.normalPtrValid ¬ TRUE;
};
};
hot => {
IF scene.selected.hot = NIL THEN {
scene.selected.hot ¬ LIST[entity];
scene.selected.hotPtr ¬ scene.selected.hot;
scene.selected.hotPtrValid ¬ TRUE;
}
ELSE IF scene.selected.hotPtrValid THEN {
scene.selected.hotPtr.rest ¬ LIST[entity];
scene.selected.hotPtr ¬ scene.selected.hotPtr.rest;
}
ELSE {
scene.selected.hotPtr ¬ LastSliceDescriptor[scene.selected.hot];
scene.selected.hotPtr.rest ¬ LIST[entity];
scene.selected.hotPtr ¬ scene.selected.hotPtr.rest;
scene.selected.hotPtrValid ¬ TRUE;
};
};
active => {
IF scene.selected.active = NIL THEN {
scene.selected.active ¬ LIST[entity];
scene.selected.activePtr ¬ scene.selected.active;
scene.selected.activePtrValid ¬ TRUE;
}
ELSE IF scene.selected.activePtrValid THEN {
scene.selected.activePtr.rest ¬ LIST[entity];
scene.selected.activePtr ¬ scene.selected.activePtr.rest;
}
ELSE {
scene.selected.activePtr ¬ LastSliceDescriptor[scene.selected.active];
scene.selected.activePtr.rest ¬ LIST[entity];
scene.selected.activePtr ¬ scene.selected.activePtr.rest;
scene.selected.activePtrValid ¬ TRUE;
};
};
match => {
IF scene.selected.match = NIL THEN {
scene.selected.match ¬ LIST[entity];
scene.selected.matchPtr ¬ scene.selected.match;
scene.selected.matchPtrValid ¬ TRUE;
}
ELSE IF scene.selected.matchPtrValid THEN {
scene.selected.matchPtr.rest ¬ LIST[entity];
scene.selected.matchPtr ¬ scene.selected.matchPtr.rest;
}
ELSE {
scene.selected.matchPtr ¬ LastSliceDescriptor[scene.selected.match];
scene.selected.matchPtr.rest ¬ LIST[entity];
scene.selected.matchPtr ¬ scene.selected.matchPtr.rest;
scene.selected.matchPtrValid ¬ TRUE;
};
};
ENDCASE => ERROR;
};
LastSliceDescriptor: PROC [sliceDList: LIST OF SliceDescriptor] RETURNS [last: LIST OF SliceDescriptor] = {
FOR last ¬ sliceDList, last.rest UNTIL last.rest = NIL DO ENDLOOP;
};
SetSelectedList: PROC [scene: Scene, value: LIST OF SliceDescriptor, selectClass: SelectionClass] = {
SELECT selectClass FROM
normal => {
scene.selected.normal ¬ value;
scene.selected.normalPtrValid ¬ FALSE;
};
hot => {
scene.selected.hot ¬ value;
scene.selected.hotPtrValid ¬ FALSE;
};
active => {
scene.selected.active ¬ value;
scene.selected.activePtrValid ¬ FALSE;
};
match => {
scene.selected.match ¬ value;
scene.selected.matchPtrValid ¬ FALSE;
};
ENDCASE => ERROR;
};
Enumerate Selected Objects
IsSelectedInFull: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] RETURNS [BOOL] = {
donkeyTail: SliceDescriptor ¬ SELECT selectClass FROM
match => slice.matchSelectedParts,
active => slice.activeSelectedParts,
hot => slice.hotSelectedParts,
normal => slice.normalSelectedParts,
ENDCASE => ERROR;
IF donkeyTail = NIL THEN RETURN[FALSE];
RETURN[GGSliceOps.IsCompleteParts[donkeyTail]];
};
IsSelectedInPart: PUBLIC PROC [entity: REF ANY, scene: Scene, selectClass: SelectionClass] RETURNS [BOOL] = {
Returns TRUE if all or part of entity is selected. These are the cases:
1) entity is a slice. Some outline is selected all or in part.
2) entity is an outline. Some trajectory is selected all or in part.
3) entity is a trajectory. Some joint or segment is selected.
4) entity is a sequence. Some joint or segment is selected.
WITH entity SELECT FROM
slice: Slice => {
sliceD: SliceDescriptor ¬ FindSelectedSlice[slice, selectClass];
RETURN[sliceD # NIL];
};
traj: Slice => {
seq: Sequence;
seq ¬ FindSelectedSequence[traj, scene, selectClass];
RETURN[seq # NIL];
};
seq: Sequence => {
selSeq: Sequence;
selSeq ¬ FindSelectedSequence[seq.slice, scene, selectClass];
IF selSeq = seq THEN RETURN[TRUE];
IF selSeq = NIL THEN RETURN[FALSE];
RETURN[GGSequence.Overlap[seq, selSeq]];
};
ENDCASE => ERROR;
};
NoSelections: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] RETURNS [BOOL] = {
SELECT selectClass FROM
normal => RETURN[scene.selected.normal = NIL];
hot => RETURN[scene.selected.hot = NIL];
active => RETURN[scene.selected.active = NIL];
match => RETURN[scene.selected.match = NIL];
ENDCASE => ERROR;
};
FindSelectedSequence: PROC [traj: Slice, scene: Scene, selectClass: SelectionClass] RETURNS [seq: Sequence] = { -- returns SliceDescriptor for a trajectory if selected
LookForTraj: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL ¬ FALSE] = {
IF sliceD.slice=traj THEN {
seq ¬ sliceD;
done ¬ TRUE;
};
};
[] ¬ GGScene.WalkSelectedSlices[scene, leaf, LookForTraj, selectClass, $Traj];
};
FindSelectedSlice: PUBLIC PROC [slice: Slice, selectClass: SelectionClass] RETURNS [sliceD: SliceDescriptor] = {
SELECT selectClass FROM
normal => sliceD ¬ slice.normalSelectedParts;
hot => sliceD ¬ slice.hotSelectedParts;
active => sliceD ¬ slice.activeSelectedParts;
match => sliceD ¬ slice.matchSelectedParts;
ENDCASE => ERROR;
};
GetLastSelection: PUBLIC PROC [scene: Scene] RETURNS [sliceD: SliceDescriptor] = {
sliceD ¬ scene.selected.normalLast;
};
SubstituteForSegment: PUBLIC PROC [traj: Slice, segNum: NAT, newRun: Slice, scene: Scene] RETURNS [bBox: BoundBox, newTraj: Slice] = {
Replaces a segment with a new run. If newRun is not NIL, then only one trajectory is modified, and the new trajectory is returned. Also returned is the bbox of modified Outlines.
newOutlines: LIST OF Slice;
trajData: TrajData ¬ NARROW[traj.data];
runParts: TrajParts ¬ GGSequence.CreateFromSegment[trajData, segNum];
run: SliceDescriptor ¬ GGSlice.DescriptorFromParts[traj, runParts];
oldOutline: Slice ¬ GGParent.GetParent[traj];
newOutline: Slice;
priority: INT ¬ GGScene.GetPriority[scene, oldOutline];
GGOutline.SaveSelectionsInOutlineAllClasses[oldOutline];
DeselectTraj[traj, scene, normal];
DeselectTraj[traj, scene, hot];
newTraj ¬ GGTraj.SpliceIn[run, newRun];
newOutline ¬ GGParent.GetParent[newTraj];
GGScene.DeleteSlice[scene, oldOutline];
IF newOutline#NIL THEN {
GGScene.AddSlice[scene, newOutline, priority];
ReselectSliceAllClasses[newOutline, scene];
};
bBox ¬ BoundBoxOfOutlines[newOutlines];
};
BoundBoxOfOutlines: PROC [outlines: LIST OF Slice] RETURNS [bBox: BoundBox] = {
bBox ¬ GGBoundBox.NullBoundBox[];
FOR list: LIST OF Slice ¬ outlines, list.rest UNTIL list = NIL DO
GGBoundBox.EnlargeByBox[bBox: bBox, by: GGSliceOps.GetBoundBox[list.first] ];
ENDLOOP;
};
DRemove: PROC [ref: SliceDescriptor, list: LIST OF SliceDescriptor] RETURNS[LIST OF SliceDescriptor] = {
l, l1: LIST OF SliceDescriptor ¬ NIL;
l ¬ list;
UNTIL l = NIL DO
IF l.first=ref THEN {
IF l1 = NIL THEN RETURN[l.rest]; -- ref was first object on list
l1.rest ¬ l.rest;
RETURN[list];
};
l1 ¬ l;
l ¬ l.rest;
ENDLOOP;
RETURN [list];
};
END.