def testSelectionSignalFrequency(self): d = { "a": { "e": 10, }, "b": { "f": "g", }, } p = Gaffer.DictPath(d, "/") w = GafferUI.PathListingWidget(p, allowMultipleSelection=True) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) c = GafferTest.CapturingSlot(w.selectionChangedSignal()) self.assertEqual(len(c), 0) w.setSelectedPaths( [Gaffer.DictPath(d, "/a"), Gaffer.DictPath(d, "/b")]) self.assertEqual(set([str(p) for p in w.getSelectedPaths()]), set(["/a", "/b"])) self.assertEqual(len(c), 1)
def testExpansionSignalFrequency(self): d = {} for i in range(0, 10): dd = {} for j in range(0, 10): dd[str(j)] = j d[str(i)] = dd p = Gaffer.DictPath(d, "/") w = GafferUI.PathListingWidget(p) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) c = GafferTest.CapturingSlot(w.expansionChangedSignal()) self.assertEqual(len(c), 0) w.setPathExpanded(Gaffer.DictPath(d, "/1"), True) self.assertEqual(len(c), 1) w.setPathExpanded(Gaffer.DictPath(d, "/1"), True) self.assertEqual(len(c), 1) w.setPathExpanded(Gaffer.DictPath(d, "/2"), True) self.assertEqual(len(c), 2) e = w.getExpandedPaths() self.assertEqual(len(e), 2) w.setExpandedPaths([]) self.assertEqual(len(c), 3) w.setExpandedPaths(e) self.assertEqual(len(c), 4)
def testExpandedPaths(self): d = {} for i in range(0, 10): dd = {} for j in range(0, 10): dd[str(j)] = j d[str(i)] = dd p = Gaffer.DictPath(d, "/") w = GafferUI.PathListingWidget(p) self.assertEqual(len(w.getExpandedPaths()), 0) p1 = Gaffer.DictPath(d, "/1") self.assertEqual(w.getPathExpanded(p1), False) w.setPathExpanded(p1, True) self.assertEqual(w.getPathExpanded(p1), True) self.assertEqual(len(w.getExpandedPaths()), 1) self.assertEqual(str(list(w.getExpandedPaths())[0]), str(p1)) w.setPathExpanded(p1, False) self.assertEqual(w.getPathExpanded(p1), False) self.assertEqual(len(w.getExpandedPaths()), 0) p2 = Gaffer.DictPath(d, "/2") p3 = Gaffer.DictPath(d, "/3") w.setExpandedPaths([p1, p2]) self.assertEqual(w.getPathExpanded(p1), True) self.assertEqual(w.getPathExpanded(p2), True) self.assertEqual(w.getPathExpanded(p3), False) self.assertEqual(w.getExpandedPaths(), [p1, p2]) w.setPath(Gaffer.DictPath({}, "/")) self.assertEqual(len(w.getExpandedPaths()), 0)
def testExpandedPathsWhenPathChanges( self ) : d = { "a" : { "e" : 10, }, "b" : { "f" : "g", }, } p = Gaffer.DictPath( d, "/" ) p1 = Gaffer.DictPath( d, "/a" ) w = GafferUI.PathListingWidget( p, displayMode = GafferUI.PathListingWidget.DisplayMode.Tree ) self.assertEqual( w.getPathExpanded( p1 ), False ) w.setPathExpanded( p1, True ) self.assertEqual( w.getPathExpanded( p1 ), True ) # fake a change to the path p.pathChangedSignal()( p ) # because the PathListingWidget only updates on idle events, we have # to run the event loop to get it to process the path changed signal. def stop() : GafferUI.EventLoop.mainEventLoop().stop() return False GafferUI.EventLoop.addIdleCallback( stop ) GafferUI.EventLoop.mainEventLoop().start() # once it has processed things, the expansion should be exactly as it was. self.assertEqual( w.getPathExpanded( p1 ), True )
def testExpandedPathsWhenPathChangesWithSelection(self): d = { "a": { "e": 10, }, "b": { "f": "g", }, } p = Gaffer.DictPath(d, "/") pa = Gaffer.DictPath(d, "/a") pae = Gaffer.DictPath(d, "/a/e") w = GafferUI.PathListingWidget( p, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree) self.assertEqual(w.getPathExpanded(pa), False) self.assertEqual(w.getPathExpanded(pae), False) w.setSelectedPaths([pa], expandNonLeaf=False) self.assertEqual(w.getPathExpanded(pa), False) self.assertEqual(w.getPathExpanded(pae), False) # fake a change to the path p.pathChangedSignal()(p) # because the PathListingWidget only updates on idle events, we have # to run the event loop to get it to process the path changed signal. self.waitForIdle(100) # once it has processed things, the expansion should be exactly as it was. self.assertEqual(w.getPathExpanded(pa), False) self.assertEqual(w.getPathExpanded(pae), False)
def testDictTypes(self): d = { "a": IECore.CompoundObject({ "b": IECore.IntData(10), }), "c": IECore.CompoundData({ "d": IECore.StringData("e"), }), } self.assertEqual(Gaffer.DictPath(d, "/").isLeaf(), False) self.assertEqual(Gaffer.DictPath(d, "/a").isLeaf(), False) self.assertEqual(Gaffer.DictPath(d, "/a/b").isLeaf(), True) self.assertEqual(Gaffer.DictPath(d, "/c").isLeaf(), False) self.assertEqual(Gaffer.DictPath(d, "/c/d").isLeaf(), True) self.assertEqual( Gaffer.DictPath(d, "/", dictTypes=(dict, IECore.CompoundData)).isLeaf(), False) self.assertEqual( Gaffer.DictPath(d, "/a", dictTypes=(dict, IECore.CompoundData)).isLeaf(), True) self.assertEqual(Gaffer.DictPath(d, "/a/b").isLeaf(), True) self.assertEqual(Gaffer.DictPath(d, "/c").isLeaf(), False) self.assertEqual(Gaffer.DictPath(d, "/c/d").isLeaf(), True)
def testExpansion(self): d = {} for i in range(0, 10): dd = {} for j in range(0, 10): dd[str(j)] = j d[str(i)] = dd p = Gaffer.DictPath(d, "/") w = GafferUI.PathListingWidget(p) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) self.assertTrue(w.getExpansion().isEmpty()) cs = GafferTest.CapturingSlot(w.expansionChangedSignal()) e = IECore.PathMatcher(["/1", "/2", "/2"]) w.setExpansion(e) self.assertEqual(w.getExpansion(), e) self.assertEqual(len(cs), 1) w.setPath(Gaffer.DictPath({}, "/")) self.assertTrue(w.getExpansion().isEmpty())
def testExpandedPathsWhenPathChangesWithSelection(self): d = { "a": { "e": 10, }, "b": { "f": "g", }, } p = Gaffer.DictPath(d, "/") pa = Gaffer.DictPath(d, "/a") pae = Gaffer.DictPath(d, "/a/e") w = GafferUI.PathListingWidget( p, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) self.assertEqual(w.getPathExpanded(pa), False) self.assertEqual(w.getPathExpanded(pae), False) w.setSelectedPaths([pa], expandNonLeaf=False) self.assertEqual(w.getPathExpanded(pa), False) self.assertEqual(w.getPathExpanded(pae), False) # Fake a change to the path and check that the expansion is exactly as # it was. self.__emitPathChanged(w) self.assertEqual(w.getPathExpanded(pa), False) self.assertEqual(w.getPathExpanded(pae), False)
def testExpandedPathsWhenPathChanges(self): d = { "a": { "e": 10, }, "b": { "f": "g", }, } p = Gaffer.DictPath(d, "/") p1 = Gaffer.DictPath(d, "/a") w = GafferUI.PathListingWidget( p, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) self.assertEqual(w.getPathExpanded(p1), False) w.setPathExpanded(p1, True) self.assertEqual(w.getPathExpanded(p1), True) # Fake a change to the path and check that the expansion is exactly as # it was. self.__emitPathChanged(w) self.assertEqual(w.getPathExpanded(p1), True) self.assertEqual(self.__expansionFromQt(w), IECore.PathMatcher(["/a"]))
def testSelection(self): d = {} for i in range(0, 10): dd = {} for j in range(0, 10): dd[str(j)] = j d[str(i)] = dd p = Gaffer.DictPath(d, "/") w = GafferUI.PathListingWidget(p, allowMultipleSelection=True) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) self.assertTrue(w.getSelection().isEmpty()) cs = GafferTest.CapturingSlot(w.selectionChangedSignal()) s = IECore.PathMatcher(["/1", "/2/5", "/3/1"]) w.setSelection(s) self.assertEqual(w.getSelection(), s) self.assertEqual(len(cs), 1) w.setPath(Gaffer.DictPath({}, "/")) self.assertTrue(w.getSelection().isEmpty())
def testExpandedPathsWhenPathChanges(self): d = { "a": { "e": 10, }, "b": { "f": "g", }, } p = Gaffer.DictPath(d, "/") p1 = Gaffer.DictPath(d, "/a") w = GafferUI.PathListingWidget( p, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) self.assertEqual(w.getPathExpanded(p1), False) w.setPathExpanded(p1, True) self.assertEqual(w.getPathExpanded(p1), True) # fake a change to the path p.pathChangedSignal()(p) # because the PathListingWidget only updates on idle events, we have # to run the event loop to get it to process the path changed signal. self.waitForIdle(100) # once it has processed things, the expansion should be exactly as it was. self.assertEqual(w.getPathExpanded(p1), True)
def testChildDictTypes(self): d = {"a": IECore.CompoundObject()} p = Gaffer.DictPath(d, "/") c = p.children()[0] self.assertEqual(c.isLeaf(), False) p = Gaffer.DictPath(d, "/", dictTypes=(dict, )) c = p.children()[0] self.assertEqual(c.isLeaf(), True)
def __init__(self, path): tmpPath = Gaffer.DictPath( {}, "/") # empty path we can use till we get an indexed io file with GafferUI.ListContainer(borderWidth=8, spacing=8) as column: self.__pathWidget = GafferUI.PathWidget(tmpPath) with GafferUI.SplitContainer( GafferUI.ListContainer.Orientation.Horizontal): self.__pathListing = GafferUI.PathListingWidget( tmpPath, columns=[ GafferUI.PathListingWidget.defaultNameColumn, GafferUI.PathListingWidget. defaultIndexedIODataTypeColumn, ], displayMode=GafferUI.PathListingWidget.DisplayMode.Tree, ) self.__pathPreview = GafferUI.DataPathPreview(tmpPath) GafferUI.DeferredPathPreview.__init__(self, column, path) self.__prevPath = tmpPath self._updateFromPath()
def __init__( self, scriptNode, **kw ) : column = GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Vertical, borderWidth = 8, spacing = 4 ) GafferUI.NodeSetEditor.__init__( self, column, scriptNode, **kw ) searchFilter = _GafferSceneUI._SceneHierarchySearchFilter() setFilter = _GafferSceneUI._SceneHierarchySetFilter() setFilter.setEnabled( False ) self.__filter = Gaffer.CompoundPathFilter( [ searchFilter, setFilter ] ) with column : with GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Horizontal, spacing = 4 ) : _SearchFilterWidget( searchFilter ) _SetFilterWidget( setFilter ) self.__pathListing = GafferUI.PathListingWidget( Gaffer.DictPath( {}, "/" ), # temp till we make a ScenePath columns = [ GafferUI.PathListingWidget.defaultNameColumn ], allowMultipleSelection = True, displayMode = GafferUI.PathListingWidget.DisplayMode.Tree, ) self.__pathListing.setDragPointer( "objects" ) self.__pathListing.setSortable( False ) self.__selectionChangedConnection = self.__pathListing.selectionChangedSignal().connect( Gaffer.WeakMethod( self.__selectionChanged ) ) self.__expansionChangedConnection = self.__pathListing.expansionChangedSignal().connect( Gaffer.WeakMethod( self.__expansionChanged ) ) self.__plug = None self._updateFromSet()
def testSetExpansionClearsExpansionByUser(self): w = GafferUI.PathListingWidget( Gaffer.DictPath({ "a": 1, "b": 2, "c": 3 }, "/"), displayMode=GafferUI.PathListingWidget.DisplayMode.Tree) model = w._qtWidget().model() model.rowCount() # Trigger population of top level of the model _GafferUI._pathModelWaitForPendingUpdates(GafferUI._qtAddress(model)) self.assertEqual(w.getExpansion(), IECore.PathMatcher()) w._qtWidget().expand(model.index( 0, 0)) # Equivalent to a click by the user self.assertEqual(w.getExpansion(), IECore.PathMatcher(["/a"])) w.setExpansion(IECore.PathMatcher(["/b"])) _GafferUI._pathModelWaitForPendingUpdates(GafferUI._qtAddress(model)) self.assertEqual(self.__expansionFromQt(w), IECore.PathMatcher(["/b"])) w._qtWidget().collapse(model.index( 1, 0)) # Equivalent to a click by the user self.assertEqual(w.getExpansion(), IECore.PathMatcher()) w.setExpansion(IECore.PathMatcher(["/b"])) _GafferUI._pathModelWaitForPendingUpdates(GafferUI._qtAddress(model)) self.assertEqual(self.__expansionFromQt(w), IECore.PathMatcher(["/b"]))
def __init__(self, scriptNode, **kw): self.__column = GafferUI.ListContainer(borderWidth=8, spacing=6) GafferUI.EditorWidget.__init__(self, self.__column, scriptNode, **kw) with self.__column: GafferUI.Image("%s/pipeBrowser.png" % pipe.name()) with GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Horizontal, spacing=6): GafferUI.Label("Role") modeMenu = GafferUI.SelectionMenu() for mode in self.__modes: modeMenu.addItem(mode[0]) self.__modeChangedConnection = modeMenu.currentIndexChangedSignal( ).connect(Gaffer.WeakMethod(self.__modeChanged)) self.__pathChooser = GafferUI.PathChooserWidget( Gaffer.DictPath({}, "/"), previewTypes=GafferUI.PathPreviewWidget.types()) self.__pathChooser.pathWidget().setVisible(True) # turns the listmode and path string invisible! self.__pathChooser.directoryPathWidget().parent().setVisible(True) self.__modeInstances = {} self.__currentModeInstance = None self.__modeChanged(modeMenu)
def __init__(self): GafferUI.PathListingWidget.__init__( self, Gaffer.DictPath({}, "/"), # listing displays the plug name and automatically sorts based on plug index columns=(GafferUI.PathListingWidget.Column( "dict:value", "Name", lambda x: x.plug.getName(), lambda x: x.index), ), displayMode=GafferUI.PathListingWidget.DisplayMode.Tree, ) self.__parent = None # the parent of the plugs we're listing self.setDragPointer("") self.setHeaderVisible(False) self.__dragEnterConnection = self.dragEnterSignal().connect( Gaffer.WeakMethod(self.__dragEnter)) self.__dragMoveConnection = self.dragMoveSignal().connect( Gaffer.WeakMethod(self.__dragMove)) self.__dragEndConnection = self.dragEndSignal().connect( Gaffer.WeakMethod(self.__dragEnd)) self.__keyPressConnection = self.keyPressSignal().connect( Gaffer.WeakMethod(self.__keyPress)) self.__metadataPlugValueChangedConnection = Gaffer.Metadata.plugValueChangedSignal( ).connect(Gaffer.WeakMethod(self.__plugMetadataChanged))
def __init__(self, scriptNode, **kw): self.__column = GafferUI.ListContainer(borderWidth=8, spacing=6) GafferUI.EditorWidget.__init__(self, self.__column, scriptNode, **kw) with self.__column: with GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Horizontal, spacing=6): GafferUI.Label("Location") modeMenu = GafferUI.MultiSelectionMenu( allowMultipleSelection=False, allowEmptySelection=False, ) for mode in self.__modes: modeMenu.append(mode[0]) self.__modeChangedConnection = modeMenu.selectionChangedSignal( ).connect(Gaffer.WeakMethod(self.__modeChanged)) self.__pathChooser = GafferUI.PathChooserWidget( Gaffer.DictPath({}, "/"), previewTypes=GafferUI.PathPreviewWidget.types()) self.__pathChooser.pathWidget().setVisible(False) self.__modeInstances = {} self.__currentModeInstance = None modeMenu.setSelection([self.__modes[0][0]])
def __init__( self, path, previewTypes=[], allowMultipleSelection=False, **kw ) : self.__column = GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Vertical, spacing=8 ) GafferUI.Widget.__init__( self, self.__column, **kw ) # we use this temporary path for our child widgets while constructing, and then call # self.setPath() to replace it with the real thing. this lets us avoid duplicating the # logic we need in setPath(). tmpPath = Gaffer.DictPath( {}, "/" ) with self.__column : # row for manipulating current directory with GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Horizontal, spacing = 0 ) : self.__displayModeButton = GafferUI.Button( image = "pathListingTree.png", hasFrame=False ) self.__displayModeButton.setToolTip( "Toggle between list and tree views" ) self.__displayModeButtonClickedConnection = self.__displayModeButton.clickedSignal().connect( Gaffer.WeakMethod( self.__displayModeButtonClicked ) ) reloadButton = GafferUI.Button( image = "refresh.png", hasFrame=False ) reloadButton.setToolTip( "Refresh view" ) self.__reloadButtonClickedConnection = reloadButton.clickedSignal().connect( Gaffer.WeakMethod( self.__reloadButtonClicked ) ) upButton = GafferUI.Button( image = "pathUpArrow.png", hasFrame=False ) upButton.setToolTip( "Up one level" ) self.__upButtonClickedConnection = upButton.clickedSignal().connect( Gaffer.WeakMethod( self.__upButtonClicked ) ) GafferUI.Spacer( IECore.V2i( 4, 4 ) ) self.__dirPathWidget = GafferUI.PathWidget( tmpPath ) # directory listing and preview widget with GafferUI.SplitContainer( GafferUI.SplitContainer.Orientation.Horizontal, expand=True ) as splitContainer : self.__directoryListing = GafferUI.PathListingWidget( tmpPath, allowMultipleSelection=allowMultipleSelection ) self.__displayModeChangedConnection = self.__directoryListing.displayModeChangedSignal().connect( Gaffer.WeakMethod( self.__displayModeChanged ) ) if len( previewTypes ) : self.__previewWidget = GafferUI.CompoundPathPreview( tmpPath, childTypes=previewTypes ) else : self.__previewWidget = None if len( splitContainer ) > 1 : splitContainer.setSizes( [ 2, 1 ] ) # give priority to the listing over the preview # filter section self.__filterFrame = GafferUI.Frame( borderWidth=0, borderStyle=GafferUI.Frame.BorderStyle.None ) self.__filter = None # path self.__pathWidget = GafferUI.PathWidget( tmpPath ) self.__pathWidget.setVisible( allowMultipleSelection == False ) self.__pathSelectedSignal = GafferUI.WidgetSignal() self.__listingSelectionChangedConnection = self.__directoryListing.selectionChangedSignal().connect( Gaffer.WeakMethod( self.__listingSelectionChanged ) ) self.__listingSelectedConnection = self.__directoryListing.pathSelectedSignal().connect( Gaffer.WeakMethod( self.__pathSelected ) ) self.__pathWidgetSelectedConnection = self.__pathWidget.activatedSignal().connect( Gaffer.WeakMethod( self.__pathSelected ) ) self.__path = None self.setPath( path )
def __init__(self, scriptNode, **kw): column = GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Vertical, borderWidth=8) GafferUI.NodeSetEditor.__init__(self, column, scriptNode, **kw) with column: self.__pathListing = GafferUI.PathListingWidget( Gaffer.DictPath({}, "/"), # temp till we make a ScenePath columns=[GafferUI.PathListingWidget.defaultNameColumn], allowMultipleSelection=True, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree, ) self.__pathListing.setDragPointer("objects") self.__pathListing.setSortable(False) self.__selectionChangedConnection = self.__pathListing.selectionChangedSignal( ).connect(Gaffer.WeakMethod(self.__selectionChanged)) self.__expansionChangedConnection = self.__pathListing.expansionChangedSignal( ).connect(Gaffer.WeakMethod(self.__expansionChanged)) self.__plug = None self.__playback = None self._updateFromSet()
def testSelectionExpansion(self): d = {} for i in range(0, 10): dd = {} for j in range(0, 10): dd[str(j)] = j d[str(i)] = dd p = Gaffer.DictPath(d, "/") w = GafferUI.PathListingWidget( p, allowMultipleSelection=True, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree) _GafferUI._pathListingWidgetAttachTester( GafferUI._qtAddress(w._qtWidget())) self.assertTrue(w.getSelection().isEmpty()) self.assertTrue(w.getExpansion().isEmpty()) s = IECore.PathMatcher(["/1", "/2", "/9", "/2/5"]) w.setSelection(s, expandNonLeaf=True, scrollToFirst=False) self.assertEqual(w.getSelection(), s) _GafferUI._pathModelWaitForPendingUpdates( GafferUI._qtAddress(w._qtWidget().model())) self.assertEqual(w.getExpansion(), IECore.PathMatcher(["/1", "/2", "/9"]))
def __init__(self, scriptNode, **kw): column = GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Vertical, borderWidth=8, spacing=4) GafferUI.NodeSetEditor.__init__(self, column, scriptNode, **kw) searchFilter = _GafferSceneUI._HierarchyViewSearchFilter() setFilter = _GafferSceneUI._HierarchyViewSetFilter() setFilter.setEnabled(False) self.__filter = Gaffer.CompoundPathFilter([searchFilter, setFilter]) with column: with GafferUI.ListContainer( GafferUI.ListContainer.Orientation.Horizontal, spacing=4): _SearchFilterWidget(searchFilter) _SetFilterWidget(setFilter) self.__pathListing = GafferUI.PathListingWidget( Gaffer.DictPath({}, "/"), # temp till we make a ScenePath columns=[GafferUI.PathListingWidget.defaultNameColumn], allowMultipleSelection=True, displayMode=GafferUI.PathListingWidget.DisplayMode.Tree, ) self.__pathListing.setDragPointer("objects") self.__pathListing.setSortable(False) # Work around insanely slow selection of a range containing many # objects (using a shift-click). The default selection behaviour # is SelectRows and this triggers some terrible performance problems # in Qt. Since we only have a single column, there is no difference # between SelectItems and SelectRows other than the speed. # # This workaround isn't going to be sufficient when we come to add # additional columns to the HierarchyView. What _might_ work instead # is to override `QTreeView.setSelection()` in PathListingWidget.py, # so that we manually expand the selected region to include full rows, # and then don't have to pass the `QItemSelectionModel::Rows` flag to # the subsequent `QItemSelectionModel::select()` call. This would be # essentially the same method we used to speed up # `PathListingWidget.setSelection()`. # # Alternatively we could avoid QItemSelectionModel entirely by managing # the selection ourself as a persistent PathMatcher. self.__pathListing._qtWidget().setSelectionBehavior( self.__pathListing._qtWidget().SelectionBehavior.SelectItems) self.__selectionChangedConnection = self.__pathListing.selectionChangedSignal( ).connect(Gaffer.WeakMethod(self.__selectionChanged)) self.__expansionChangedConnection = self.__pathListing.expansionChangedSignal( ).connect(Gaffer.WeakMethod(self.__expansionChanged)) self.__plug = None self._updateFromSet()
def __updatePath(self): if self.__parent is None: # we have nothing to show - early out. self.setPath(Gaffer.DictPath({}, "/")) return # build a DictPath to represent our child plugs. plugs = self.__parent.children(Gaffer.Plug) plugs = GafferUI.PlugLayout.layoutOrder(plugs) d = {} for index, plug in enumerate(plugs): d[plug.getName()] = self.Entry(plug, index) self.setPath(Gaffer.DictPath(d, "/"))
def testDeeperExpandedPaths(self): p = Gaffer.DictPath({"a": {"b": {"c": {"d": 10}}}}, "/") w = GafferUI.PathListingWidget(p) w.setPathExpanded(p.copy().setFromString("/a/b/c"), True) self.assertTrue(w.getPathExpanded(p.copy().setFromString("/a/b/c")))
def testProperties(self): d = { "one": 1, "d": { "two": 2, }, } p = Gaffer.DictPath(d, "/one") self.assertTrue("dict:value" in p.propertyNames()) self.assertEqual(p.property("dict:value"), 1) p = Gaffer.DictPath(d, "/d") self.assertEqual(p.property("dict:value"), None) p = Gaffer.DictPath(d, "/ invalid") self.assertEqual(p.property("dict:value"), None)
def testChangingDirectoryClearsSelection(self): path = Gaffer.DictPath({"a": {"b": {"c": 10}}}, "/") widget = GafferUI.PathListingWidget(path) widget.setSelection(IECore.PathMatcher(["/a"])) self.assertEqual(widget.getSelection(), IECore.PathMatcher(["/a"])) path.append("a") self.assertEqual(widget.getSelection(), IECore.PathMatcher())
def testRepr(self): d = { "one": 1, "two": 2, } p = Gaffer.DictPath(d, "/one") self.assertEqual(repr(p), "DictPath( '/one' )")
def __dictPath(self): dict = {} dict["dir"] = {} for f in IECore.FileSequence("a.#.exr 1-10").fileNames(): dict["dir"][f] = 1 for f in IECore.FileSequence("b.####.tiff 20-200x2").fileNames(): dict["dir"][f] = 1 return Gaffer.DictPath(dict, "/")
def testSortable(self): w = GafferUI.PathListingWidget(Gaffer.DictPath({}, "/")) self.assertTrue(w.getSortable()) w.setSortable(False) self.assertFalse(w.getSortable()) w.setSortable(True) self.assertTrue(w.getSortable())
def __setPathListingPath( self ) : if self.__plug is not None : # Note that we take a static copy of our current context for use in the ScenePath - this prevents the # PathListing from updating automatically when the original context changes, and allows us to have finer # grained control of the update in our _updateFromContext() method. self.__pathListing.setPath( GafferScene.ScenePath( self.__plug, Gaffer.Context( self.getContext() ), "/" ) ) self.__transferExpansionFromContext() self.__transferSelectionFromContext() else : self.__pathListing.setPath( Gaffer.DictPath( {}, "/" ) )