def test_setComputedProp(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) # Property selection starts empty. self.assertListEqual(dm.getComputedProps(), []) self.assertEqual(dm.getFocusComputedProp(), None) # Set a property. dm.setComputedProp(stage.foo_bbox) self.assertListEqual(dm.getComputedProps(), [stage.foo_bbox]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_bbox) # Replace the last property. dm.setComputedProp(stage.foo_xform) self.assertListEqual(dm.getComputedProps(), [stage.foo_xform]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_xform) # Test validation. with self.assertRaises(ValueError): dm.setComputedProp(stage.foo)
def test_propBatchedChanges(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) counter = PropSignalCounter(dm.signalPropSelectionChanged) # Add some props in a batch. with dm.batchPropChanges: dm.addProp(stage.foo_one) dm.addProp(stage.foo_two) # Signal shouldn't be emitted yet! self.assertEqual(counter.getAndClearNumSignals(), 0) self.assertEqual(counter.getAndClearNumSignals(), 1) # Add a prop, then remove it immediately. A signal will still be # emitted. with dm.batchPropChanges: dm.addProp(stage.foo_three) dm.removeProp(stage.foo_three) self.assertEqual(counter.getAndClearNumSignals(), 1) # Clear the props then add some back. with dm.batchPropChanges: dm.clearProps() dm.addProp(stage.foo_two) dm.addProp(stage.foo_three) self.assertEqual(counter.getAndClearNumSignals(), 1)
def test_addComputedProp(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) # Property selection starts empty. self.assertListEqual(dm.getComputedProps(), []) self.assertEqual(dm.getFocusComputedProp(), None) # Add a property. dm.addComputedProp(stage.foo_bbox) self.assertListEqual(dm.getComputedProps(), [stage.foo_bbox]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_bbox) # Properties remain in the order they are added. dm.addComputedProp(stage.foo_xform) self.assertListEqual(dm.getComputedProps(), [stage.foo_bbox, stage.foo_xform]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_xform) # Test validation. with self.assertRaises(ValueError): dm.addComputedProp(stage.foo)
def test_computedPropBatchedChanges(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) counter = PropSignalCounter(dm.signalComputedPropSelectionChanged) # Add some props in a batch. with dm.batchComputedPropChanges: dm.addComputedProp(stage.foo_bbox) dm.addComputedProp(stage.foo_xform) # Signal shouldn't be emitted yet! self.assertEqual(counter.getAndClearNumSignals(), 0) self.assertEqual(counter.getAndClearNumSignals(), 1) # Add a prop, then remove it immediately. A signal will still be # emitted. with dm.batchComputedPropChanges: dm.addComputedProp(stage.bar_bbox) dm.removeComputedProp(stage.bar_bbox) self.assertEqual(counter.getAndClearNumSignals(), 1) # Clear the props then add some back. with dm.batchComputedPropChanges: dm.clearComputedProps() dm.addComputedProp(stage.foo_xform) dm.addComputedProp(stage.bar_bbox) self.assertEqual(counter.getAndClearNumSignals(), 1)
def test_addProp(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) # Property selection starts empty. self.assertListEqual(dm.getProps(), []) self.assertEqual(dm.getFocusProp(), None) # Add a property. dm.addProp(stage.foo_one) self.assertListEqual(dm.getProps(), [stage.foo_one]) self.assertEqual(dm.getFocusProp(), stage.foo_one) # Properties remain in the order they are added. dm.addProp(stage.foo_two) self.assertListEqual(dm.getProps(), [stage.foo_one, stage.foo_two]) self.assertEqual(dm.getFocusProp(), stage.foo_two) # Test validation. with self.assertRaises(ValueError): dm.addProp(stage.foo)
def test_setPrimInstance(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) self.assertDictEqual(dm.getPrimInstances(), {stage.root: ALL_INSTANCES}) # Set a prim instance as the selection. dm.setPrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: {1}}) # Set a different instance of the same prim as the selection. dm.setPrim(stage.foo, 2) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: {2}}) # Set a different prim's instance as the selection. dm.setPrim(stage.bar, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.bar: {1}}) # Test validation. with self.assertRaises(ValueError): dm.setPrim(stage.foo, None)
def test_getLCDPrims(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) # If the root prim is the only selected prim, it is also the only prim # in the LCD prims. This is the only case where the root is in the LCD # prims. self.assertListEqual(dm.getPrims(), [stage.root]) self.assertListEqual(dm.getLCDPrims(), [stage.root]) # LCD prims should exclude the root and any prims whose ancestors are # also in the selection but not the root prim. dm.setPrim(stage.root) dm.addPrim(stage.foo) dm.addPrim(stage.parent) dm.addPrim(stage.child1) self.assertListEqual(dm.getLCDPrims(), [stage.foo, stage.parent]) # Removing a prim from the selection can reveal prims in the LCD prims. dm.togglePrim(stage.parent) self.assertListEqual(dm.getLCDPrims(), [stage.foo, stage.child1]) # If a prim has any instances selected, it may be in the LCD prims. dm.addPrim(stage.child2, 1) self.assertListEqual(dm.getLCDPrims(), [stage.foo, stage.child1, stage.child2])
def test_primNonBatchedDiffs(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) counter = PrimSignalCounter(dm.signalPrimSelectionChanged) def checkDiff(expectedAdded, expectedRemoved): self.assertEqual(counter.getAndClearNumSignals(), 1) added, removed = counter.getLastSignalParameters() self.assertSetEqual(added, expectedAdded) self.assertSetEqual(removed, expectedRemoved) dm.addPrim(stage.foo) checkDiff({stage.foo.GetPath()}, set()) dm.togglePrim(stage.bar) checkDiff({stage.bar.GetPath()}, set()) dm.removePrim(stage.root) checkDiff(set(), {stage.root.GetPath()}) dm.clearPrims() checkDiff( {stage.root.GetPath()}, {stage.foo.GetPath(), stage.bar.GetPath()}) dm.setPrim(stage.foo) checkDiff({stage.foo.GetPath()}, {stage.root.GetPath()})
def test_setProp(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) # Property selection starts empty. self.assertListEqual(dm.getProps(), []) self.assertEqual(dm.getFocusProp(), None) # Set a property. dm.setProp(stage.foo_one) self.assertListEqual(dm.getProps(), [stage.foo_one]) self.assertEqual(dm.getFocusProp(), stage.foo_one) # Replace the last property. dm.setProp(stage.foo_two) self.assertListEqual(dm.getProps(), [stage.foo_two]) self.assertEqual(dm.getFocusProp(), stage.foo_two) # Test validation. with self.assertRaises(ValueError): dm.setProp(stage.foo)
def test_removeProp(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) dm.setProp(stage.foo_one) dm.addProp(stage.foo_two) self.assertListEqual(dm.getProps(), [stage.foo_one, stage.foo_two]) self.assertEqual(dm.getFocusProp(), stage.foo_two) # Remove a property. dm.removeProp(stage.foo_one) self.assertListEqual(dm.getProps(), [stage.foo_two]) self.assertEqual(dm.getFocusProp(), stage.foo_two) # Try to remove a property not in the selection. Nothing should happen. dm.removeProp(stage.foo_one) self.assertListEqual(dm.getProps(), [stage.foo_two]) self.assertEqual(dm.getFocusProp(), stage.foo_two) # Remove the last property. dm.removeProp(stage.foo_two) self.assertListEqual(dm.getProps(), []) self.assertEqual(dm.getFocusProp(), None) # Test validation. with self.assertRaises(ValueError): dm.removeProp(stage.foo)
def test_togglePrim(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) self.assertListEqual(dm.getPrims(), [stage.root]) # Toggle a prim into the selection. dm.togglePrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.root, stage.foo]) # Toggle a prim out of the selection. dm.togglePrim(stage.root) self.assertListEqual(dm.getPrims(), [stage.foo]) # Toggle the last prim out of the selection. Root prim should become # selected. dm.togglePrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.root]) # Try to toggle the root prim out of the selection when it is the only # remaining prim. It should remain selected. dm.togglePrim(stage.root) self.assertListEqual(dm.getPrims(), [stage.root]) # Test validation. with self.assertRaises(ValueError): dm.togglePrim(stage.foo_one)
def test_removeComputedProp(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) dm.setComputedProp(stage.foo_bbox) dm.addComputedProp(stage.foo_xform) self.assertListEqual(dm.getComputedProps(), [stage.foo_bbox, stage.foo_xform]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_xform) # Remove a property. dm.removeComputedProp(stage.foo_bbox) self.assertListEqual(dm.getComputedProps(), [stage.foo_xform]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_xform) # Try to remove a property not in the selection. Nothing should happen. dm.removeComputedProp(stage.foo_bbox) self.assertListEqual(dm.getComputedProps(), [stage.foo_xform]) self.assertEqual(dm.getFocusComputedProp(), stage.foo_xform) # Remove the last property. dm.removeComputedProp(stage.foo_xform) self.assertListEqual(dm.getComputedProps(), []) self.assertEqual(dm.getFocusComputedProp(), None) # Test validation. with self.assertRaises(ValueError): dm.removeComputedProp(stage.foo)
def test_removePrimInstance(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) dm.setPrim(stage.foo) dm.addPrim(stage.bar, 1) dm.addPrim(stage.bar, 2) self.assertDictEqual(dm.getPrimInstances(), { stage.foo: ALL_INSTANCES, stage.bar: {1, 2} }) # Remove a prim instance from the selection. dm.removePrim(stage.bar, 1) self.assertDictEqual(dm.getPrimInstances(), { stage.foo: ALL_INSTANCES, stage.bar: {2} }) # Remove the last instance of a prim from the selection. dm.removePrim(stage.bar, 2) self.assertDictEqual(dm.getPrimInstances(), { stage.foo: ALL_INSTANCES, }) # Try to remove a prim instance from the selection which does not exist. # Selection should not change. dm.removePrim(stage.bar, 3) self.assertDictEqual(dm.getPrimInstances(), { stage.foo: ALL_INSTANCES, }) # Remove a single prim instance when all instances of the prim are # selected. dm.removePrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.root: ALL_INSTANCES}) # Try to remove a single instance of the root prim when it is the only # selected prim. All instances of the root prim should remain selected. dm.removePrim(stage.root, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.root: ALL_INSTANCES}) # Test validation. with self.assertRaises(ValueError): dm.removePrim(stage.foo, None)
def test_primBatchedDiffs(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) counter = PrimSignalCounter(dm.signalPrimSelectionChanged) def checkDiff(expectedAdded, expectedRemoved): self.assertEqual(counter.getAndClearNumSignals(), 1) added, removed = counter.getLastSignalParameters() self.assertSetEqual(added, expectedAdded) self.assertSetEqual(removed, expectedRemoved) # Clear selection then add a single prim. with dm.batchPrimChanges: # Clearing during a batch should not add the root prim to the # selection unless the selection is still clear at the end of the # batch. dm.clearPrims() # Since we add a prim before the end of the batch, the root prim is # not added to the selection. dm.addPrim(stage.foo) # Signal shouldn't be emitted yet! self.assertEqual(counter.getAndClearNumSignals(), 0) checkDiff({stage.foo.GetPath()}, {stage.root.GetPath()}) # Add a prim then remove it. This should generate an empty diff because # there is no net change in the prim selection. with dm.batchPrimChanges: dm.addPrim(stage.bar) dm.removePrim(stage.bar) checkDiff(set(), set()) # Clear selection without adding any prims back. with dm.batchPrimChanges: # Clearing during a batch should not add the root prim to the # selection unless the selection is still clear at the end of the # batch. dm.clearPrims() # Since we don't add any prim to the empty selection before the end # of the batch, the root prim is added. checkDiff({stage.root.GetPath()}, {stage.foo.GetPath()}) # Clear root from the selection, add it back, then add another prim. with dm.batchPrimChanges: dm.clearPrims() dm.addPrim(stage.root) dm.addPrim(stage.foo) # The root prim existed in the selection before, so it is not in any # part of the diff. checkDiff({stage.foo.GetPath()}, set())
def test_setPrim(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) self.assertListEqual(dm.getPrims(), [stage.root]) # Set a prim. dm.setPrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.foo]) with self.assertRaises(ValueError): dm.setPrim(stage.foo_one)
def test_addPrimInstance(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) self.assertDictEqual(dm.getPrimInstances(), {stage.root: ALL_INSTANCES}) # Add a single prim instance. dm.addPrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), { stage.root: ALL_INSTANCES, stage.foo: {1} }) # Add a different prim instance. dm.addPrim(stage.foo, 2) self.assertDictEqual(dm.getPrimInstances(), { stage.root: ALL_INSTANCES, stage.foo: {1, 2} }) # Add all instances of the prim. dm.addPrim(stage.foo) self.assertDictEqual(dm.getPrimInstances(), { stage.root: ALL_INSTANCES, stage.foo: ALL_INSTANCES }) # Add a single instance. This should wipe out ALL_INSTANCES and leave # only the single instance in the prim's selected instances. dm.addPrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), { stage.root: ALL_INSTANCES, stage.foo: {1} }) # Test validation. with self.assertRaises(ValueError): dm.addPrim(stage.foo, None)
def test_switchToPrim(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) dm.setPrim(stage.foo) dm.addProp(stage.foo_one) dm.addProp(stage.foo_two) dm.addComputedProp(stage.foo_bbox) self.assertListEqual(dm.getPrims(), [stage.foo]) self.assertListEqual(dm.getProps(), [stage.foo_one, stage.foo_two]) self.assertListEqual(dm.getComputedProps(), [stage.foo_bbox]) # Switch selection to just bar, and convert all of foo's selected # properties to bar. dm.switchToPrim(stage.bar) self.assertListEqual(dm.getPrims(), [stage.bar]) self.assertListEqual(dm.getProps(), [stage.bar_one, stage.bar_two]) self.assertListEqual(dm.getComputedProps(), [stage.bar_bbox]) # Add foo to the selection. dm.addPrim(stage.foo) # Since two prims are selected, preserve property selection. dm.switchToPrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.foo]) self.assertListEqual(dm.getProps(), [stage.bar_one, stage.bar_two]) self.assertListEqual(dm.getComputedProps(), [stage.bar_bbox]) # Add foo.one to the selection. dm.addProp(stage.foo_one) # Since properties which belong to different prims are selected, # preserve the property selection. dm.switchToPrim(stage.bar) self.assertListEqual(dm.getPrims(), [stage.bar]) self.assertListEqual(dm.getProps(), [stage.bar_one, stage.bar_two, stage.foo_one]) self.assertListEqual(dm.getComputedProps(), [stage.bar_bbox])
def test_propTargetsNonBatchedChanges(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) counter = PropSignalCounter(dm.signalPropSelectionChanged) # Adding/removing/setting/clearing props all emit a single signal. dm.addPropTarget(stage.foo_one, stage.bar) self.assertEqual(counter.getAndClearNumSignals(), 1) dm.removePropTarget(stage.foo_one, stage.bar) self.assertEqual(counter.getAndClearNumSignals(), 1) dm.setPropTarget(stage.foo_one, stage.bar) self.assertEqual(counter.getAndClearNumSignals(), 1)
def test_clearProps(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) dm.setProp(stage.foo_one) dm.addProp(stage.foo_two) dm.addProp(stage.foo_three) self.assertListEqual(dm.getProps(), [stage.foo_one, stage.foo_two, stage.foo_three]) self.assertEqual(dm.getFocusProp(), stage.foo_three) # Clear the property selection. dm.clearProps() self.assertListEqual(dm.getProps(), []) self.assertEqual(dm.getFocusProp(), None)
def test_propTargets(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) self.assertDictEqual(dm.getPropTargets(), dict()) # Select a property. It should have an empty target selection. dm.addProp(stage.foo_one) self.assertDictEqual(dm.getPropTargets(), {stage.foo_one: set()}) # Add a target and connection to the property. dm.addPropTarget(stage.foo_one, stage.foo) dm.addPropTarget(stage.foo_one, stage.foo_two) self.assertDictEqual(dm.getPropTargets(), {stage.foo_one: {stage.foo, stage.foo_two}}) # Add a target to a property not already in the selection. The property # should be added to the selection. dm.addPropTarget(stage.foo_two, stage.foo) self.assertDictEqual(dm.getPropTargets(), { stage.foo_one: {stage.foo, stage.foo_two}, stage.foo_two: {stage.foo} }) # Remove the last target from a property. The property should remain # selected but have no targets. dm.removePropTarget(stage.foo_two, stage.foo) self.assertDictEqual(dm.getPropTargets(), { stage.foo_one: {stage.foo, stage.foo_two}, stage.foo_two: set() }) # Remove a property with targets. The property and its targets should # all be cleared. dm.removeProp(stage.foo_one) self.assertDictEqual(dm.getPropTargets(), {stage.foo_two: set()})
def test_togglePrimInstance(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) dm.setPrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: {1}}) # Toggle a prim instance into the selection. dm.togglePrim(stage.foo, 2) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: {1, 2}}) # Toggle a prim instance out of the selection. dm.togglePrim(stage.foo, 2) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: {1}}) # Toggle all instances of a prim when a single instance is selected. All # instances should be selected. dm.togglePrim(stage.foo) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: ALL_INSTANCES}) # Toggle a single instance of a prim when all instances are selected. # The single instance should be selected. dm.togglePrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.foo: {1}}) # Toggle the last prim instance out of the selection. All instances of # the root prim should be selected. dm.togglePrim(stage.foo, 1) self.assertDictEqual(dm.getPrimInstances(), {stage.root: ALL_INSTANCES}) # Test validation. with self.assertRaises(ValueError): dm.togglePrim(stage.foo, None)
def test_clearComputedProps(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) dm.setComputedProp(stage.foo_bbox) dm.addComputedProp(stage.foo_xform) dm.addComputedProp(stage.bar_bbox) self.assertListEqual(dm.getComputedProps(), [stage.foo_bbox, stage.foo_xform, stage.bar_bbox]) self.assertEqual(dm.getFocusComputedProp(), stage.bar_bbox) # Clear the property selection. dm.clearComputedProps() self.assertListEqual(dm.getComputedProps(), []) self.assertEqual(dm.getFocusComputedProp(), None)
def test_clearPrims(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) dm.addPrim(stage.foo) dm.addPrim(stage.bar, 1) dm.addPrim(stage.bar, 2) self.assertDictEqual(dm.getPrimInstances(), { stage.root: ALL_INSTANCES, stage.foo: ALL_INSTANCES, stage.bar: {1, 2} }) # Clear the prim selection. dm.clearPrims() self.assertDictEqual(dm.getPrimInstances(), {stage.root: ALL_INSTANCES})
def test_addPrim(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) self.assertListEqual(dm.getPrims(), [stage.root]) # Add a prim. dm.addPrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.root, stage.foo]) # Add a prim that is already selected. Selection shouldn't change. dm.addPrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.root, stage.foo]) # Test validation. with self.assertRaises(ValueError): dm.addPrim(stage.foo_one)
def test_computedPropNonBatchedChanges(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel, _computedPropFactory=FakeComputedPropFactory()) counter = PropSignalCounter(dm.signalComputedPropSelectionChanged) # Adding/removing/setting/clearing props all emit a single signal. dm.addComputedProp(stage.foo_bbox) self.assertEqual(counter.getAndClearNumSignals(), 1) dm.removeComputedProp(stage.foo_bbox) self.assertEqual(counter.getAndClearNumSignals(), 1) dm.setComputedProp(stage.foo_bbox) self.assertEqual(counter.getAndClearNumSignals(), 1) dm.clearComputedProps() self.assertEqual(counter.getAndClearNumSignals(), 1)
def test_removePrim(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) dm.setPrim(stage.foo) dm.addPrim(stage.bar) self.assertListEqual(dm.getPrims(), [stage.foo, stage.bar]) # Remove a prim. dm.removePrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.bar]) # Try to remove a prim that is not in the selection. Selection shouldn't # change. dm.removePrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.bar]) # Remove the last prim in the selection. Root prim should become # selected. dm.removePrim(stage.bar) self.assertListEqual(dm.getPrims(), [stage.root]) # Try to remove the root prim when it is the only prim in the selection. # It should remain selected. dm.removePrim(stage.root) self.assertListEqual(dm.getPrims(), [stage.root]) # Test validation. with self.assertRaises(ValueError): dm.removePrim(stage.foo_one)
def test_getFocusPrim(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) # Root should be in focus first. self.assertListEqual(dm.getPrims(), [stage.root]) self.assertEqual(dm.getFocusPrim(), stage.root) # The last set prim should be in focus. dm.setPrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.foo]) self.assertEqual(dm.getFocusPrim(), stage.foo) # Adding a prim does not change the focus. dm.addPrim(stage.bar) self.assertListEqual(dm.getPrims(), [stage.foo, stage.bar]) self.assertEqual(dm.getFocusPrim(), stage.foo) # Toggling out the focus prim changes the focus to the next available # prim in the selection order. dm.togglePrim(stage.foo) self.assertListEqual(dm.getPrims(), [stage.bar]) self.assertEqual(dm.getFocusPrim(), stage.bar) # Setting the prims changes the focus prim to the first in the given # list. dm.setPrim(stage.foo) dm.addPrim(stage.bar) self.assertListEqual(dm.getPrims(), [stage.foo, stage.bar]) self.assertEqual(dm.getFocusPrim(), stage.foo)
def test_primInstancesNonBatchedDiffs(self): stage = FakeStage() rootDataModel = FakeRootDataModel(stage) dm = SelectionDataModel(rootDataModel) counter = PrimSignalCounter(dm.signalPrimSelectionChanged) def checkDiff(expectedAdded, expectedRemoved): self.assertEqual(counter.getAndClearNumSignals(), 1) added, removed = counter.getLastSignalParameters() self.assertSetEqual(added, expectedAdded) self.assertSetEqual(removed, expectedRemoved) # Add some instances, then remove them. Adding instances to an already- # selected prim does not add it to the diff. Removing instances but # leaving some selected does not add the prim to the diff. dm.addPrim(stage.foo, 1) checkDiff({stage.foo.GetPath()}, set()) dm.addPrim(stage.foo, 2) checkDiff(set(), set()) dm.removePrim(stage.foo, 1) checkDiff(set(), set()) dm.removePrim(stage.foo, 2) checkDiff(set(), {stage.foo.GetPath()}) # Toggle some instances on, then off again. When an instance is toggled # but doesn't change whether the prim is selected, the prim is not added # to the diff. dm.togglePrim(stage.foo, 1) checkDiff({stage.foo.GetPath()}, set()) dm.togglePrim(stage.foo, 2) checkDiff(set(), set()) dm.togglePrim(stage.foo, 1) checkDiff(set(), set()) dm.togglePrim(stage.foo, 2) checkDiff(set(), {stage.foo.GetPath()}) # Toggle all instances of a prim on, then toggle a single instance on, # then toggle all instances on and off. This exercises the diffs for the # less-intuitive behavior of toggling a single instance when all are # selected and vice-versa. # Select all instances. dm.togglePrim(stage.foo) checkDiff({stage.foo.GetPath()}, set()) # Select just a single instance. dm.togglePrim(stage.foo, 1) checkDiff(set(), set()) # Select all instances again. dm.togglePrim(stage.foo) checkDiff(set(), set()) # Deselect the prim. dm.togglePrim(stage.foo) checkDiff(set(), {stage.foo.GetPath()}) # Set some instances. Setting instances on an already-selected prim does # not add the prim to the selection. dm.setPrim(stage.foo, 1)