<> <> <> <> <<>> DIRECTORY GList, SVAssembly, SVScene, SVSceneTypes, SVSelect; SVSelectImpl: CEDAR PROGRAM IMPORTS GList, SVAssembly, SVScene EXPORTS SVSelect = BEGIN Slice: TYPE = SVSceneTypes.Slice; AssemblyGenerator: TYPE = SVScene.AssemblyGenerator; Scene: TYPE = SVSceneTypes.Scene; <> SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor; SliceParts: TYPE = SVSceneTypes.SliceParts; SelectionClass: TYPE = SVSelect.SelectionClass; SliceDescriptorGenerator: TYPE = SVSceneTypes.SliceDescriptorGenerator; SliceDescriptorGeneratorObj: TYPE = SVSceneTypes.SliceDescriptorGeneratorObj; <<>> SelectSlice: PUBLIC PROC [sliceD: SliceDescriptor, scene: Scene, selectClass: SelectionClass] = { oldSliceD, union: SliceDescriptor; slice: Slice _ sliceD.slice; IF SVAssembly.EmptyParts[sliceD] THEN RETURN; oldSliceD _ FindSelectedSlice[slice, scene, selectClass]; IF oldSliceD#NIL THEN { union _ SVAssembly.UnionParts[oldSliceD, sliceD]; DeselectSlice[slice, oldSliceD.parts, scene, selectClass]; -- throw away old selection } ELSE union _ sliceD; IF selectClass = normal THEN union _ SVAssembly.AugmentParts[union, selectClass]; AppendSelection[scene, union, selectClass]; ChangeDonkeyTail[union, selectClass]; }; SelectEntireSlice: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] = { allParts: SliceDescriptor _ SVAssembly.NewParts[slice, NIL, [0,0,0], slice]; SelectSlice[allParts, scene, selectClass]; }; <<>> <> <> <> < scene.selected.normal _ NARROW[GList.Nconc[scene.selected.normal, LIST[sliceD]]];>> < scene.selected.hot _ NARROW[GList.Nconc[scene.selected.hot, LIST[sliceD]]];>> < scene.selected.active _ NARROW[GList.Nconc[scene.selected.active, LIST[sliceD]]];>> < ERROR;>> <<};>> <<>> AppendSelection: PROC [scene: Scene, sliceD: SliceDescriptor, selectClass: SelectionClass] = { <> SELECT selectClass FROM normal => { IF scene.selected.normal = NIL THEN scene.selected.normal _ CONS[sliceD, NIL] ELSE { list: LIST OF SliceDescriptor; FOR list _ scene.selected.normal, list.rest UNTIL list.rest = NIL DO {}; ENDLOOP; list.rest _ CONS[sliceD, NIL]; }; }; hot => scene.selected.hot _ NARROW[GList.Nconc[scene.selected.hot, LIST[sliceD]]]; active => scene.selected.active _ NARROW[GList.Nconc[scene.selected.active, LIST[sliceD]]]; ENDCASE => ERROR; }; SelectAll: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] = { g: AssemblyGenerator; g _ SVScene.PrimAssembliesInScene[scene]; FOR slice: Slice _ SVScene.NextAssembly[g], SVScene.NextAssembly[g] UNTIL slice = NIL DO SelectEntireSlice[slice, scene, selectClass]; ENDLOOP; }; DeleteSelection: PROC [scene: Scene, sliceD: SliceDescriptor, selectClass: SelectionClass] = { <> SetSelectedList[scene, NARROW[GList.DRemove[sliceD, ListSelected[scene, selectClass]]], selectClass]; }; 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; ENDCASE => ERROR; }; SetSelectedList: PROC [scene: Scene, value: LIST OF SliceDescriptor, selectClass: SelectionClass] = { SELECT selectClass FROM normal => scene.selected.normal _ value; hot => scene.selected.hot _ value; active => scene.selected.active _ value; ENDCASE => ERROR; }; ChangeDonkeyTail: PROC [sliceD: SliceDescriptor, selectClass: SelectionClass] = { SELECT selectClass FROM normal => sliceD.slice.normalSelectedParts _ sliceD; hot => sliceD.slice.hotSelectedParts _ sliceD; active => sliceD.slice.activeSelectedParts _ sliceD; ENDCASE; }; NoDonkeyTail: PROC [slice: Slice, selectClass: SelectionClass] = { SELECT selectClass FROM normal => slice.normalSelectedParts _ NIL; hot => slice.hotSelectedParts _ NIL; active => slice.activeSelectedParts _ NIL; ENDCASE; }; DeselectSlice: PUBLIC PROC [slice: Slice, parts: SliceParts, scene: Scene, selectClass: SelectionClass] = { oldD, newD, tempD: SliceDescriptor; oldD _ FindSelectedSlice[slice, scene, selectClass]; IF oldD # NIL THEN { tempD _ SVAssembly.DescriptorFromParts[slice, parts]; newD _ SVAssembly.DifferenceParts[oldD, tempD]; DeleteSelection[scene, oldD, selectClass]; NoDonkeyTail[oldD.slice, selectClass]; IF NOT SVAssembly.EmptyParts[newD] THEN { IF selectClass = normal THEN newD _ SVAssembly.AugmentParts[newD, selectClass]; AppendSelection[scene, newD, selectClass]; ChangeDonkeyTail[newD, selectClass]; }; }; }; DeselectEntireSlice: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] = { oldD: SliceDescriptor; oldD _ FindSelectedSlice[slice, scene, selectClass]; IF oldD # NIL THEN { DeleteSelection[scene, oldD, selectClass]; NoDonkeyTail[oldD.slice, selectClass]; }; }; DeselectAll: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] = { sliceD: SliceDescriptor; FOR selected: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], selected.rest UNTIL selected = NIL DO sliceD _ selected.first; NoDonkeyTail[sliceD.slice, selectClass]; ENDLOOP; SetSelectedList[scene, NIL, selectClass]; }; FindSelectedSlice: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] RETURNS [sliceD: SliceDescriptor] = { SELECT selectClass FROM normal => sliceD _ IF slice.normalSelectedParts = NIL THEN NIL ELSE slice.normalSelectedParts; hot => sliceD _ IF slice.hotSelectedParts = NIL THEN NIL ELSE slice.hotSelectedParts; active => sliceD _ IF slice.activeSelectedParts = NIL THEN NIL ELSE slice.activeSelectedParts; ENDCASE => ERROR; }; SelectedSlices: PUBLIC PROC [scene: Scene, selectClass: SelectionClass] RETURNS [sliceDescGen: SliceDescriptorGenerator] = { sliceD: SliceDescriptor _ NIL; ptr: LIST OF SliceDescriptor _ NIL; sliceDescGen _ NEW[SliceDescriptorGeneratorObj]; FOR entityList: LIST OF SliceDescriptor _ ListSelected[scene, selectClass], entityList.rest UNTIL entityList = NIL DO sliceD _ NARROW[entityList.first]; [sliceDescGen.list, ptr] _ AddSliceDescriptor[sliceD, sliceDescGen.list, ptr]; ENDLOOP; }; AddSliceDescriptor: PROC [entity: SliceDescriptor, entityList, ptr: LIST OF SliceDescriptor] RETURNS [newList, newPtr: LIST OF SliceDescriptor] = { IF ptr = NIL THEN { IF NOT entityList = NIL THEN ERROR; newPtr _ newList _ CONS[entity, NIL]; RETURN; } ELSE { newList _ entityList; ptr.rest _ CONS[entity, NIL]; newPtr _ ptr.rest; }; }; NextSliceDescriptor: PUBLIC PROC [g: SliceDescriptorGenerator] RETURNS [next: SliceDescriptor] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first; g.list _ g.list.rest; }; }; NextSlice: PUBLIC PROC [g: SliceDescriptorGenerator] RETURNS [next: Slice] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first.slice; g.list _ g.list.rest; }; }; IsSelectedInPart: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass] RETURNS [BOOL] = { <> <<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.>> sliceD: SliceDescriptor; sliceD _ FindSelectedSlice[slice, scene, selectClass]; RETURN[sliceD # NIL]; }; <<>> 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]; ENDCASE => ERROR; }; END.