def testBookmarkUpdates(self):

        s = Gaffer.ScriptNode()

        s["a"] = Gaffer.Node()
        s["b"] = Gaffer.Node()
        s["c"] = Gaffer.Node()

        b = Gaffer.NumericBookmarkSet(s, 1)
        self.assertEqual(b.size(), 0)

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["a"])
        self.assertEqual(set(b), {s["a"]})

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["b"])
        self.assertEqual(set(b), {s["b"]})

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, None)
        self.assertEqual(b.size(), 0)

        Gaffer.MetadataAlgo.setNumericBookmark(s, 2, s["c"])

        b2 = Gaffer.NumericBookmarkSet(s, 2)
        self.assertEqual(set(b2), {s["c"]})

        Gaffer.MetadataAlgo.setNumericBookmark(s, 2, s["a"])
        self.assertEqual(set(b2), {s["a"]})
    def testSignals(self):

        s = Gaffer.ScriptNode()

        s["a"] = Gaffer.Node()
        s["b"] = Gaffer.Node()

        mirror = set()

        def added(_, member):
            mirror.add(member)

        def removed(_, member):
            mirror.remove(member)

        b = Gaffer.NumericBookmarkSet(s, 1)

        ca = b.memberAddedSignal().connect(added)
        cr = b.memberRemovedSignal().connect(removed)

        self.assertEqual(set(b), mirror)

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["a"])
        self.assertEqual(set(b), mirror)

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["b"])
        self.assertEqual(set(b), mirror)
    def testSignalOrder(self):

        s = Gaffer.ScriptNode()

        s["a"] = Gaffer.Node()
        s["b"] = Gaffer.Node()

        b = Gaffer.NumericBookmarkSet(s, 1)

        callbackFailures = {"added": 0, "removed": 0}

        # Check we have no members when one is removed as we're
        # defined as only ever containing one node. We can't assert
        # here as the exception gets eaten and the test passes anyway
        def removed(_, member):
            if set(b) != set():
                callbackFailures["removed"] += 1

        cr = b.memberRemovedSignal().connect(removed)

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["a"])
        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["b"])

        self.assertEqual(callbackFailures["removed"], 0)

        # Check member is added before signal, same deal re: asserts
        def added(_, member):
            if set(b) != {s["a"]}:
                callbackFailures["added"] += 1

        ca = b.memberAddedSignal().connect(added)

        Gaffer.MetadataAlgo.setNumericBookmark(s, 1, s["a"])
        self.assertEqual(callbackFailures["added"], 0)
Exemplo n.º 4
0
    def testNodeSetRestore(self):

        s = Gaffer.ScriptNode()
        c = GafferUI.CompoundEditor(s)

        editors = list((GafferUI.NodeEditor(s), GafferUI.NodeEditor(s),
                        GafferUI.AnimationEditor(s), GafferUI.NodeEditor(s)))

        editors[0].setNodeSet(Gaffer.NumericBookmarkSet(s, 1))
        editors[1].setNodeSet(Gaffer.NumericBookmarkSet(s, 2))
        editors[2].setNodeSet(Gaffer.NumericBookmarkSet(s, 3))

        for e in editors:
            c.addEditor(e)

        a = Gaffer.ApplicationRoot("testApp")
        l = GafferUI.Layouts.acquire(a)
        l.add("ReprNodeSetTest", repr(c), persistent=False)

        cc = l.create("ReprNodeSetTest", s)

        editors = cc.editors()

        ns = editors[0].getNodeSet()
        self.assertTrue(isinstance(ns, Gaffer.NumericBookmarkSet))
        self.assertTrue(ns.getBookmark(), 1)

        ns = editors[1].getNodeSet()
        self.assertTrue(isinstance(ns, Gaffer.NumericBookmarkSet))
        self.assertTrue(ns.getBookmark(), 2)

        ns = editors[2].getNodeSet()
        self.assertTrue(isinstance(ns, Gaffer.NumericBookmarkSet))
        self.assertTrue(ns.getBookmark(), 3)

        ns = editors[3].getNodeSet()
        self.assertTrue(isinstance(ns, Gaffer.StandardSet))
    def testAccessors(self):

        s = Gaffer.ScriptNode()

        b = Gaffer.NumericBookmarkSet(s, 1)

        self.assertEqual(b.getBookmark(), 1)

        for i in range(1, 10):
            b.setBookmark(i)
            self.assertEqual(b.getBookmark(), i)

        for i in (0, 10):
            with self.assertRaises(RuntimeError):
                b.setBookmark(i)
Exemplo n.º 6
0
def __findNumericBookmark(editor, numericBookmark):

    if not isinstance(editor, (GafferUI.NodeSetEditor, GafferUI.GraphEditor)):
        return False

    # Don't modify the contents of floating windows, because these are
    # expected to be locked to one node.
    if editor.ancestor(GafferUI.CompoundEditor) is None:
        return False

    node = Gaffer.MetadataAlgo.getNumericBookmark(editor.scriptNode(),
                                                  numericBookmark)
    if not node:
        return False

    if isinstance(editor, GafferUI.GraphEditor):
        editor.graphGadget().setRoot(node.parent())
        editor.frame([node])
    else:
        s = Gaffer.NumericBookmarkSet(editor.scriptNode(), numericBookmark)
        editor.setNodeSet(s)

    return True
Exemplo n.º 7
0
 def followBookmark(number, weakEditor, _):
     editor = weakEditor()
     if editor is not None:
         b = Gaffer.NumericBookmarkSet(editor.scriptNode(), number)
         editor.setNodeSet(b)