def __init__(self):
        EventHandler.EventHandler.__init__(self)

        # default name is the class name, minus the "Factory"
        self._Name = self.__class__.__name__
        if self._Name[-7:] == 'Factory':
            self._Name = self._Name[0:-7]

        # Store the modified time
        self._MTime = vtk.vtkObject()
        self._RenderTime = vtk.vtkObject()

        # list of renderers the actors are displayed in
        self._Renderers = []
        # dictionary of actors for each renderer
        self._ActorDict = {}

        # ActorFactories which are children of this one
        self._Children = []

        # the transform for all of the actors
        self._Transform = vtk.vtkTransform()

        # this transform is used as a spare
        self._DummyTransform = vtk.vtkTransform()

    def testObjId(self):
        map = vtk.vtkObjectIdMap()
        # Just make sure if we call it twice with None, the results match
        objId1 = map.GetGlobalId(None)
        objId1b = map.GetGlobalId(None)
        print('Object ids for None: objId1 => ',objId1,', objId1b => ',objId1b)
        self.assertTrue(objId1 == objId1b)

        object2 = vtk.vtkObject()
        addr2 = object2.__this__
        addr2 = addr2[1:addr2.find('_', 1)]
        addr2 = int(addr2, 16)

        object3 = vtk.vtkObject()
        addr3 = object3.__this__
        addr3 = addr3[1:addr3.find('_', 1)]
        addr3 = int(addr3, 16)

        # insert the bigger address first
        if (addr2 < addr3):
            object2, object3 = object3, object2

        objId2 = map.GetGlobalId(object2)
        objId2b = map.GetGlobalId(object2)
        print('Object ids for object2: objId2 => ',objId2,', objId2b => ',objId2b)
        self.assertTrue(objId2 == objId2b)

        objId3 = map.GetGlobalId(object3)
        objId3b = map.GetGlobalId(object3)
        print('Object ids for object3: objId3 => ',objId3,', objId3b => ',objId3b)
        self.assertTrue(objId3 == objId3b)

  def test_removeObserver(self):
    foo = Foo()
    object = vtk.vtkObject()
    object2 = vtk.vtkObject()
    event = vtk.vtkCommand.ModifiedEvent
    callback = foo.onObjectModified
    callback2 = foo.onObjectModifiedAgain
    self.assertEqual(len(foo.Observations), 0)

    foo.addObserver(object, event, callback)
    foo.addObserver(object2, event, callback)
    foo.addObserver(object, event, callback2)
    foo.addObserver(object2, event, callback2)
    self.assertEqual(len(foo.Observations), 4)

    foo.removeObserver(object2, event, callback)
    self.assertEqual(len(foo.Observations), 3)

    foo.removeObserver(object, event, callback)
    self.assertEqual(len(foo.Observations), 2)

    foo.removeObserver(object, event, callback2)
    self.assertEqual(len(foo.Observations), 1)

    foo.removeObserver(object2, event, callback2)
    self.assertEqual(len(foo.Observations), 0)

 def testGhostForDict(self):
     """Ghost an object to save the dict"""
     o = vtk.vtkObject()
     o.customattr = 'hello'
     a = vtk.vtkVariantArray()
     a.InsertNextValue(o)
     i = id(o)
     del o
     o = vtk.vtkObject()
     o = a.GetValue(0).ToVTKObject()
     # make sure the id has changed, but dict the same
     self.assertEqual(o.customattr, 'hello')
     self.assertNotEqual(i, id(o))

  def test_hasObserver(self):
    foo = Foo()
    object = vtk.vtkObject()
    object2 = vtk.vtkObject()
    event = vtk.vtkCommand.ModifiedEvent
    callback = foo.onObjectModified
    self.assertFalse(foo.hasObserver(object, event, callback))
    self.assertFalse(foo.hasObserver(object2, event, callback))

    foo.addObserver(object, event, callback)
    self.assertTrue(foo.hasObserver(object, event, callback))
    self.assertFalse(foo.hasObserver(object2, event, callback))

    foo.addObserver(object2, event, callback)
    self.assertTrue(foo.hasObserver(object, event, callback))
    self.assertTrue(foo.hasObserver(object2, event, callback))

    def __init__(self):

        ActorFactory.ActorFactory.__init__(self)

        self.markList = []
        self.positionList = []          # none transformed position list
        self.captions = []
        self.activeIndex = None
        self._defaultCaptionVisibility = False
        self.cursorMark = None
        self.curpos = None

        # sizes
        self.markSize = 10.
        self.cursorMarkSize = 12.

        # colors
        self.cursorMarkColor = (1, 0, 0)    # red
        self.markColor = (1, 1, 0)          # yellow

        self._markTransform = vtk.vtkTransform()
        self._markTransform.AddObserver(
            'ModifiedEvent', self._OnTransformModified)
        self._transformedView = False

        self.eventObject = vtk.vtkObject()

 def testProxy(self):
     o = vtk.vtkObject()
     proxy = weakref.proxy(o)
     self.assertEqual(proxy.GetClassName(), 'vtkObject')
     del o
     self.assertRaises(weakref.ReferenceError, getattr,
                       proxy, 'GetClassName')

    def setUp(self):
        self.vtkObjs = [vtk.vtkObject() for _ in range(30)]
        self.collection = vtk.vtkCollection()
        for obj in self.vtkObjs:
            self.collection.AddItem(obj)

        self.emptyCollection = vtk.vtkCollection()

  def test_observer(self):
    foo = Foo()
    object = vtk.vtkObject()
    object2 = vtk.vtkObject()
    event = vtk.vtkCommand.ModifiedEvent
    callback = foo.onObjectModified
    callback2 = foo.onObjectModifiedAgain
    self.assertEqual(foo.observer(event, callback), None)

    foo.addObserver(object, event, callback)
    self.assertEqual(foo.observer(event, callback), object)

    # observer function return the first observer
    foo.addObserver(object2, event, callback)
    self.assertEqual(foo.observer(event, callback), object)

    foo.addObserver(object2, event, callback2)
    self.assertEqual(foo.observer(event, callback2), object2)

    def testPriorityArg(self):
        """Test the optional priority argument
        """
        cb = callback()
        o = vtk.vtkObject()
        o.AddObserver(vtk.vtkCommand.ModifiedEvent, cb, 0.5)
        o.Modified()

        self.assertEqual(cb.caller, o)

    def testCommandWithArgs(self):
        """Test binding a command that has arguments.
        """
        cb = callback()
        o = vtk.vtkObject()
        o.AddObserver(vtk.vtkCommand.ModifiedEvent, cb)
        o.Modified()

        self.assertEqual(cb.caller, o)
        self.assertEqual(cb.event, "ModifiedEvent")

    def testUseEventNameString(self):
        """Test binding with a string event name.
        """
        cb = callback()
        o = vtk.vtkObject()
        o.AddObserver("ModifiedEvent", cb)
        o.Modified()

        self.assertEqual(cb.caller, o)
        self.assertEqual(cb.event, "ModifiedEvent")

    def testCommandCircularRef(self):
        """Test correct reference loop reporting for commands
        """
        cb = callback()
        o = vtk.vtkObject()
        o.AddObserver(vtk.vtkCommand.ModifiedEvent, cb)
        cb.circular_ref = o
        # referent to check if "o" is deleted
        referent = vtk.vtkObject()
        o.referent = referent
        # make sure gc removes referer "o" from referent
        s1 = repr(gc.get_referrers(referent))
        del o
        del cb
        gc.collect()
        s2 = repr(gc.get_referrers(referent))

        self.assertNotEqual(s1, s2)
        self.assertNotEqual(s1.count("vtkObject"), 0)
        self.assertEqual(s2.count("vtkObject"), 0)

  def test_addObserver(self):
    foo = Foo()
    object = vtk.vtkObject()
    object2 = vtk.vtkObject()
    event = vtk.vtkCommand.ModifiedEvent
    callback = foo.onObjectModified
    self.assertEqual(len(foo.Observations), 0)

    foo.ModifiedEventCount = {}
    foo.addObserver(object, event, callback)
    object.Modified()
    self.assertEqual(len(foo.Observations), 1)
    self.assertEqual(foo.modifiedEventCount(object), 1)
    self.assertEqual(foo.modifiedEventCount(object2), 0)

    foo.ModifiedEventCount = {}
    foo.addObserver(object, event, callback)
    object.Modified()
    self.assertEqual(len(foo.Observations), 1)
    self.assertEqual(foo.modifiedEventCount(object), 1)
    self.assertEqual(foo.modifiedEventCount(object2), 0)

    foo.ModifiedEventCount = {}
    foo.addObserver(object, event, callback, group='a')
    object.Modified()
    self.assertEqual(len(foo.Observations), 1)
    self.assertEqual(foo.modifiedEventCount(object), 1)
    self.assertEqual(foo.modifiedEventCount(object2), 0)

    foo.ModifiedEventCount = {}
    foo.addObserver(object2, event, callback)
    object.Modified()
    self.assertEqual(len(foo.Observations), 2)
    self.assertEqual(foo.modifiedEventCount(object), 1)
    self.assertEqual(foo.modifiedEventCount(object2), 0)

    foo.ModifiedEventCount = {}
    object2.Modified()
    self.assertEqual(len(foo.Observations), 2)
    self.assertEqual(foo.modifiedEventCount(object), 0)
    self.assertEqual(foo.modifiedEventCount(object2), 1)

 def testObjectPointer(self):
     a = vtk.vtkInformation()
     ptr = a.__this__
     # check the format _0123456789abcdef_p_vtkInformation
     self.assertEqual(ptr[0:1], "_")
     self.assertEqual(ptr[-17:], "_p_vtkInformation")
     address = int(ptr[1:-17], 16)
     # create a VTK object from the swig pointer
     b = vtk.vtkObject(ptr)
     self.assertEqual(b.GetClassName(), a.GetClassName())
     self.assertEqual(a.__this__, b.__this__)
     self.assertEqual(a, b)

 def testGhostForClass(self):
     """Ghost an object to save the class"""
     o = vtkCustomObject()
     a = vtk.vtkVariantArray()
     a.InsertNextValue(o)
     i = id(o)
     del o
     o = vtk.vtkObject()
     o = a.GetValue(0).ToVTKObject()
     # make sure the id has changed, but class the same
     self.assertEqual(o.__class__, vtkCustomObject)
     self.assertNotEqual(i, id(o))

 def testSubclassGhost(self):
     """Make sure ghosting of the class works"""
     o = vtkCustomObject()
     c = vtk.vtkCollection()
     c.AddItem(o)
     i = id(o)
     del o
     o = vtk.vtkObject()
     o = c.GetItemAsObject(0)
     # make sure the id has changed, but class the same
     self.assertEqual(o.__class__, vtkCustomObject)
     self.assertNotEqual(i, id(o))

 def testArgumentConversion(self):
     """Test argument conversion via implicit constructors"""
     # automatic conversion to vtkVariant
     a = vtk.vtkVariantArray()
     a.InsertNextValue(2.5)
     a.InsertNextValue(vtk.vtkObject())
     self.assertEqual(a.GetValue(0), vtk.vtkVariant(2.5))
     self.assertEqual(a.GetValue(1).GetType(), vtk.VTK_OBJECT)
     # same, but this one is via "const vtkVariant&" argument
     a = vtk.vtkDenseArray[float]()
     a.Resize(1)
     a.SetVariantValue(0, 2.5)
     self.assertEqual(a.GetVariantValue(0).ToDouble(), 2.5)

 def testRemoveCommand(self):
     """Test the removal of an observer.
     """
     cb = callback()
     o = vtk.vtkObject()
     o.AddObserver(vtk.vtkCommand.ModifiedEvent, cb)
     o.Modified()
     self.assertEqual(cb.caller, o)
     o.RemoveObservers(vtk.vtkCommand.ModifiedEvent)
     cb.caller = None
     cb.event = None
     o.Modified()
     self.assertEqual(cb.caller, None)

 def testConstructors(self):
     """Test overloaded constructors"""
     # resolve by number of arguments
     v = vtk.vtkVector3d(3, 4, 5)
     self.assertEqual((v[0], v[1], v[2]), (3, 4, 5))
     v = vtk.vtkVector3d(6)
     self.assertEqual((v[0], v[1], v[2]), (6, 6, 6))
     # resolve by argument type
     v = vtk.vtkVariant(3.0)
     self.assertEqual(v.GetType(), vtk.VTK_DOUBLE)
     v = vtk.vtkVariant(1)
     self.assertEqual(v.GetType(), vtk.VTK_INT)
     v = vtk.vtkVariant("hello")
     self.assertEqual(v.GetType(), vtk.VTK_STRING)
     v = vtk.vtkVariant(vtk.vtkObject())
     self.assertEqual(v.GetType(), vtk.VTK_OBJECT)