def testChildOrdering(self):

        p = Gaffer.ParameterPath(self.__parameters(), "/")

        self.assertEqual([str(c) for c in p.children()],
                         ["/a", "/b", "/c", "/cv"])

        p = Gaffer.ParameterPath(self.__parameters(), "/c")
        self.assertEqual([str(c) for c in p.children()], ["/c/d", "/c/e"])
    def testChildForcedLeafTypes(self):

        p = Gaffer.ParameterPath(
            self.__parameters(),
            "/",
            forcedLeafTypes=(IECore.CompoundVectorParameter, ))

        c = p.children()[3]
        self.assertEqual(str(c), "/cv")
        self.assertEqual(c.isLeaf(), True)
    def testForcedLeafTypesCopy(self):

        p = Gaffer.ParameterPath(
            self.__parameters(),
            "/cv",
            forcedLeafTypes=(IECore.CompoundVectorParameter, ))
        self.assertEqual(p.isLeaf(), True)

        pp = p.copy()
        self.assertEqual(pp.isLeaf(), True)
    def testCopy(self):

        p = Gaffer.ParameterPath(self.__parameters(), "/c")

        pp = p.copy()
        self.assertEqual(str(pp), str(p))
        self.assertEqual(pp, p)
        self.failIf(p != p)

        del pp[-1]
        self.assertNotEqual(str(pp), str(p))
        self.assertNotEqual(pp, p)
        self.failUnless(pp != p)
    def testRelative(self):

        p = Gaffer.ParameterPath(
            self.__parameters(),
            "c",
            forcedLeafTypes=(IECore.CompoundVectorParameter, ))

        self.assertEqual(str(p), "c")
        self.assertTrue("c/d" in [str(c) for c in p.children()])
        self.assertTrue("c/e" in [str(c) for c in p.children()])

        p2 = p.copy()
        self.assertEqual(str(p2), "c")
        self.assertTrue("c/d" in [str(c) for c in p2.children()])
        self.assertTrue("c/e" in [str(c) for c in p2.children()])
    def test(self):

        p = self.__parameters()

        p = Gaffer.ParameterPath(p, "/")

        self.failUnless(p.isValid())
        self.failIf(p.isLeaf())

        children = p.children()
        self.assertEqual(len(children), 4)
        for child in children:
            self.failUnless(isinstance(child, Gaffer.ParameterPath))
            if child[-1] in ("c", "cv"):
                self.failIf(child.isLeaf())
            else:
                self.failUnless(child.isLeaf())
            self.assertEqual(child[-1],
                             child.info()["parameter:parameter"].name)
示例#7
0
	def __init__( self, parameterHandler ) :
	
		PresetDialogue.__init__( self, "Save Preset", parameterHandler )
				
		with GafferUI.ListContainer( spacing = 8 ) as column :
			with GafferUI.GridContainer( spacing = 6 ) :
				
				GafferUI.Label(
					"<h3>Location</h3>",
					index = ( 0, 0 ),
					alignment = (
						GafferUI.Label.HorizontalAlignment.Right,
						GafferUI.Label.VerticalAlignment.None,
					),
				)
				self._locationMenu( writable=True, index = ( 1, 0 ) )
				
				GafferUI.Label(
					"<h3>Name</h3>",
					index = ( 0, 1 ),
					alignment = (
						GafferUI.Label.HorizontalAlignment.Right,
						GafferUI.Label.VerticalAlignment.None,
					),
				)
				self.__presetNameWidget = GafferUI.TextWidget( "Enter a name!", index = ( 1, 1 ) )
				self.__presetNameWidget.setSelection( None, None ) # select all
				self.__presetNameChangedConnection = self.__presetNameWidget.textChangedSignal().connect( Gaffer.WeakMethod( self.__updateSaveButton ) )
						
				GafferUI.Label(
					"<h3>Description</h3>",
					index = ( 0, 2 ),
					alignment = (
						GafferUI.Label.HorizontalAlignment.Right,
						GafferUI.Label.VerticalAlignment.Top,
					),
				)
				
				self.__presetDescriptionWidget = GafferUI.MultiLineTextWidget( index = ( 1, 2 ), )
				self.__presetDescriptionChangedConnection = self.__presetDescriptionWidget.textChangedSignal().connect( Gaffer.WeakMethod( self.__updateSaveButton ) )
		
			with GafferUI.Collapsible( "Parameters To Save", collapsed=True ) as cl :
			
				# forcing CompoundVectorParameter to act as a leaf, because allowing the selection of some children but not others
				# makes no sense (because they must all have the same length).
				parameterPath = Gaffer.ParameterPath( parameterHandler.parameter(), "/", forcedLeafTypes = ( IECore.CompoundVectorParameter, ) )
				self.__parameterListing = GafferUI.PathListingWidget(
					parameterPath,
					columns = [ GafferUI.PathListingWidget.defaultNameColumn ],
					allowMultipleSelection = True,
					displayMode = GafferUI.PathListingWidget.DisplayMode.Tree
				)
				self.__parameterListing.setSelectedPaths( self.__allPaths( parameterPath ) )
				self.__haveSelectedParameters = True
				self.__selectionChangedConnection = self.__parameterListing.selectionChangedSignal().connect(
					Gaffer.WeakMethod( self.__selectionChanged )
				)
						
		self._setWidget( column )
		
		self._addButton( "Cancel" )
		self.__saveButton = self._addButton( "Save" )
		self.__saveButton.setEnabled( False )
    def testForcedLeafTypes(self):

        p = Gaffer.ParameterPath(self.__parameters(), "/c")

        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/").isLeaf(), False)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/a").isLeaf(), True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/b").isLeaf(), True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/c").isLeaf(), False)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/c/d").isLeaf(), True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/c/e").isLeaf(), True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/cv").isLeaf(), False)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/cv/s").isLeaf(), True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/cv/b").isLeaf(), True)

        kw = {"forcedLeafTypes": (IECore.CompoundVectorParameter, )}

        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/", **kw).isLeaf(),
            False)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/a", **kw).isLeaf(),
            True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/b", **kw).isLeaf(),
            True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/c", **kw).isLeaf(),
            False)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/c/d", **kw).isLeaf(),
            True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/c/e", **kw).isLeaf(),
            True)
        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/cv", **kw).isLeaf(),
            True)

        self.assertEqual(
            Gaffer.ParameterPath(self.__parameters(), "/cv", **kw).children(),
            [])
    def testRepr(self):

        p = Gaffer.ParameterPath(self.__parameters(), "/c")

        self.assertEqual(repr(p), "ParameterPath( '/c' )")