def saveAs(menu):
scriptWindow = menu.ancestor(GafferUI.ScriptWindow)
script = scriptWindow.scriptNode()
currentFileName = script["fileName"].getValue()
if currentFileName:
path = Gaffer.FileSystemPath(currentFileName)
else:
path = Gaffer.FileSystemPath(os.getcwd())
path.setFilter(__scriptPathFilter())
dialogue = GafferUI.PathChooserDialogue(path,
title="Save script",
confirmLabel="Save")
path = dialogue.waitForPath(parentWindow=scriptWindow)
if not path:
return
path = str(path)
if not path.endswith(".gfr"):
path += ".gfr"
script["fileName"].setValue(path)
with GafferUI.ErrorDialogue.ExceptionHandler(title="Error Saving File",
parentWindow=scriptWindow):
script.save()
application = script.ancestor(Gaffer.ApplicationRoot.staticTypeId())
addRecentFile(application, path)
def testCancellation(self):
p = Gaffer.FileSystemPath(os.path.dirname(__file__))
# Children
c = IECore.Canceller()
c.cancel()
with self.assertRaises(IECore.Cancelled):
p.children(c)
# Sequence properties
for f in range(0, 100):
with open(
os.path.join(self.temporaryDirectory(),
"{}.txt".format(f)), "w") as f:
f.write("x")
p = Gaffer.FileSystemPath(os.path.join(self.temporaryDirectory(),
"#.txt"),
includeSequences=True)
with self.assertRaises(IECore.Cancelled):
p.property("fileSystem:owner", c)
with self.assertRaises(IECore.Cancelled):
p.property("fileSystem:group", c)
with self.assertRaises(IECore.Cancelled):
p.property("fileSystem:size", c)
with self.assertRaises(IECore.Cancelled):
p.property("fileSystem:modificationTime", c)
def _waitForFileName( initialFileName="", parentWindow=None ) : bookmarks = None if parentWindow is not None : if isinstance( parentWindow, GafferUI.ScriptWindow ) : scriptWindow = parentWindow else : scriptWindow = parentWindow.ancestor( GafferUI.ScriptWindow ) if scriptWindow is not None : bookmarks = GafferUI.Bookmarks.acquire( scriptWindow.scriptNode().ancestor( Gaffer.ApplicationRoot.staticTypeId() ), category="reference" ) if initialFileName : path = Gaffer.FileSystemPath( os.path.dirname( os.path.abspath( initialFileName ) ) ) else : path = Gaffer.FileSystemPath( bookmarks.getDefault( parentWindow ) if bookmarks is not None else os.getcwd() ) path.setFilter( Gaffer.FileSystemPath.createStandardFilter( [ "grf" ] ) ) dialogue = GafferUI.PathChooserDialogue( path, title = "Load reference", confirmLabel = "Load", valid = True, leaf = True, bookmarks = bookmarks ) path = dialogue.waitForPath( parentWindow = parentWindow ) if not path : return "" return str( path )
def testConstructWithFilter(self):
p = Gaffer.FileSystemPath(__file__)
self.failUnless(p.getFilter() is None)
f = Gaffer.FileNamePathFilter(["*.exr"])
p = Gaffer.FileSystemPath(__file__, filter=f)
self.failUnless(p.getFilter().isSame(f))
def testConstructWithFilter(self):
p = Gaffer.FileSystemPath(__file__)
self.assertIsNone(p.getFilter())
f = Gaffer.FileNamePathFilter(["*.exr"])
p = Gaffer.FileSystemPath(__file__, filter=f)
self.assertTrue(p.getFilter().isSame(f))
def __init__(self, path, root="/", minSequenceSize=1, filter=None):
if not isinstance(path, Gaffer.Path):
if isinstance(path, str):
path = Gaffer.FileSystemPath(path)
else:
path = Gaffer.FileSystemPath(path, root)
Gaffer.Path.__init__(self, path[:], path.root(), filter=filter)
# we use the seed for creating base paths whenever we need them
self.__basePathSeed = path
self.__minSequenceSize = minSequenceSize
def testCopy(self):
p = Gaffer.FileSystemPath(self.__dir)
p2 = p.copy()
self.assertEqual(p, p2)
self.assertEqual(str(p), str(p2))
def __init__(self,
key,
target=None,
acceptEmptyString=True,
defaultValue="",
**kw):
self.__row = GafferUI.ListContainer(
GafferUI.ListContainer.Orientation.Horizontal, spacing=4)
self.__path = Gaffer.FileSystemPath()
self.__pathWidget = GafferUI.PathWidget(self.__path)
MetadataWidget.__init__(self,
self.__row,
key,
target,
defaultValue=defaultValue,
**kw)
self.__row.append(self.__pathWidget)
button = GafferUI.Button(image="pathChooser.png", hasFrame=False)
button.clickedSignal().connect(Gaffer.WeakMethod(self.__buttonClicked),
scoped=False)
self.__row.append(button)
self.__acceptEmptyString = acceptEmptyString
self.__pathWidget.editingFinishedSignal().connect(Gaffer.WeakMethod(
self.__editingFinished),
scoped=False)
def __fileNameCreator( plug, annotations ) :
extensions = annotations.get( plug.getName() + ".extensions", None )
if extensions is not None :
extensions = extensions.value.split( "|" )
else :
extensions = []
bookmarksCategory = annotations.get( plug.getName() + ".bookmarksCategory", None )
if bookmarksCategory is not None :
bookmarksCategory = bookmarksCategory.value
else :
# seems like a reasonable guess, and it's preferable to have a category
# rather than to have any bookmarks made here pollute the bookmarks for
# other browsers.
bookmarksCategory = "texture"
return GafferUI.PathPlugValueWidget(
plug,
path = Gaffer.FileSystemPath(
"/",
filter = Gaffer.FileSystemPath.createStandardFilter(
extensions = extensions,
extensionsLabel = "Show only supported files",
),
),
pathChooserDialogueKeywords = {
"bookmarks" : GafferUI.Bookmarks.acquire(
plug.ancestor( Gaffer.ApplicationRoot.staticTypeId() ),
pathType = Gaffer.FileSystemPath,
category = bookmarksCategory,
),
},
)
def testSymLinkInfo( self ) : with open( self.__dir + "/a", "w" ) as f : f.write( "AAAA" ) os.symlink( self.__dir + "/a", self.__dir + "/l" ) # symlinks should report the info for the file # they point to. a = Gaffer.FileSystemPath( self.__dir + "/a" ) l = Gaffer.FileSystemPath( self.__dir + "/l" ) aInfo = a.info() self.assertEqual( aInfo["fileSystem:size"], l.info()["fileSystem:size"] ) # unless they're broken os.remove( str( a ) ) self.assertNotEqual( aInfo["fileSystem:size"], l.info()["fileSystem:size"] )
def open(menu):
scriptWindow = menu.ancestor(GafferUI.ScriptWindow)
path = Gaffer.FileSystemPath("/")
path.addFilter(Gaffer.FileNamePathFilter(["*.gfr"]))
path.addFilter(
Gaffer.FileNamePathFilter([re.compile("^[^.].*")], leafOnly=False))
dialogue = GafferUI.PathChooserDialogue(path,
title="Open script",
confirmLabel="Open")
scriptWindow.addChildWindow(dialogue)
path = dialogue.waitForPath()
dialogue.hide()
if not path:
return
currentScript = scriptWindow.getScript()
application = scriptWindow.getScript().ancestor(
Gaffer.ApplicationRoot.staticTypeId())
currentNodes = [
n for n in currentScript.children()
if n.isInstanceOf(Gaffer.Node.staticTypeId())
]
if not currentNodes and not currentScript["fileName"].getValue():
script = currentScript
else:
script = Gaffer.ScriptNode()
script["fileName"].setValue(str(path))
script.load()
application["scripts"].addChild(script)
def test(self):
# First, check that we have a mix of extensions in
# our test directory. Otherwise we can't test anything.
self.assertTrue(
len(glob.glob(self.__testDirectory + "/*")) != len(
glob.glob(self.__testDirectory + "/*.txt")))
# Check that an unfiltered path can see all the files
path = Gaffer.FileSystemPath(self.__testDirectory)
children = path.children()
self.assertEqual(len(children),
len(glob.glob(self.__testDirectory + "/*")))
# Attach a filter, and check that the files are filtered
txtFilter = Gaffer.FileNamePathFilter(["*.txt"])
path.setFilter(txtFilter)
children = path.children()
self.assertEqual(len(children),
len(glob.glob(self.__testDirectory + "/*.txt")))
# Copy the path and check the filter is working on the copy
pathCopy = path.copy()
self.assertEqual(len(pathCopy.children()), len(children))
# Detach the filter and check that behaviour has reverted
path.setFilter(None)
children = path.children()
self.assertEqual(len(children),
len(glob.glob(self.__testDirectory + "/*")))
def exportSelection(menu):
scriptWindow = menu.ancestor(GafferUI.ScriptWindow)
script = scriptWindow.scriptNode()
selection = script.selection()
parent = selection[0].parent()
for node in selection:
if not parent.isAncestorOf(node):
assert (node.parent().isAncestorOf(parent))
parent = node.parent()
path = Gaffer.FileSystemPath(os.getcwd())
path.setFilter(__scriptPathFilter())
dialogue = GafferUI.PathChooserDialogue(path,
title="Export selection",
confirmLabel="Export")
path = dialogue.waitForPath(parentWindow=scriptWindow)
if not path:
return
path = str(path)
if not path.endswith(".gfr"):
path += ".gfr"
script.serialiseToFile(path, parent, script.selection())
def testCopy(self):
p = Gaffer.FileSystemPath(self.temporaryDirectory())
p2 = p.copy()
self.assertEqual(p, p2)
self.assertEqual(str(p), str(p2))
def testEnabled(self):
p = Gaffer.FileSystemPath(self.__dir, includeSequences=True)
self.assertTrue(p.getIncludeSequences())
p.setFilter(
Gaffer.FileSequencePathFilter(
mode=Gaffer.FileSequencePathFilter.Keep.Files))
self.assertEqual(p.getFilter().getMode(),
Gaffer.FileSequencePathFilter.Keep.Files)
self.assertEqual(
set([str(c) for c in p.children()]),
set([
self.__dir + "/singleFile.txt",
self.__dir + "/dir",
]))
p.getFilter().setEnabled(False)
self.assertEqual(
set([str(c) for c in p.children()]),
set([
self.__dir + "/singleFile.txt", self.__dir + "/a.001.txt",
self.__dir + "/a.002.txt", self.__dir + "/a.004.txt",
self.__dir + "/b.003.txt", self.__dir + "/dir",
self.__dir + "/a.###.txt", self.__dir + "/b.###.txt"
]))
def __addClicked(self, *unused):
bookmarks = GafferUI.Bookmarks.acquire(self, category="image")
path = Gaffer.FileSystemPath(bookmarks.getDefault(self))
path.setIncludeSequences(True)
path.setFilter(
Gaffer.FileSystemPath.createStandardFilter(
GafferImage.ImageReader.supportedExtensions(),
"Show only image files",
includeSequenceFilter=True,
))
dialogue = GafferUI.PathChooserDialogue(path,
title="Add image",
confirmLabel="Add",
valid=True,
leaf=True,
bookmarks=bookmarks)
dialogue.pathChooserWidget().pathListingWidget().setColumns(
dialogue.pathChooserWidget().pathListingWidget().getColumns() + [
GafferUI.PathListingWidget.StandardColumn(
"Frame Range", "fileSystem:frameRange")
])
path = dialogue.waitForPath(
parentWindow=self.ancestor(GafferUI.Window))
if not path:
return
with Gaffer.UndoScope(self.getPlug().ancestor(Gaffer.ScriptNode)):
self.__images().addChild(
GafferImage.Catalogue.Image.load(str(path)))
self.getPlug().setValue(len(self.__images()) - 1)
def __exportClicked(self, *unused):
bookmarks = GafferUI.Bookmarks.acquire(self, category="image")
path = Gaffer.FileSystemPath(bookmarks.getDefault(self))
path.setFilter(
Gaffer.FileSystemPath.createStandardFilter(
GafferImage.ImageReader.supportedExtensions(),
"Show only image files",
includeSequenceFilter=True,
))
dialogue = GafferUI.PathChooserDialogue(path,
title="Export image",
confirmLabel="Export",
leaf=True,
bookmarks=bookmarks)
path = dialogue.waitForPath(
parentWindow=self.ancestor(GafferUI.Window))
if not path:
return
index = self.__indexFromSelection()
with GafferUI.ErrorDialogue.ErrorHandler(
parentWindow=self.ancestor(GafferUI.Window)):
self.__images()[index].save(str(path))
def _run(self, args):
if len(args["files"]) < 1 or len(args["files"]) > 2:
raise Exception("Must view exactly one file.")
self.__window = GafferUI.Window(
title="Gaffer Viewer", sizeMode=GafferUI.Window.SizeMode.Manual)
self.__window.setChild(
GafferUI.CompoundPathPreview(
Gaffer.FileSystemPath(args["files"][0])))
self.__closedConnection = self.__window.closedSignal().connect(
Gaffer.WeakMethod(self.__closed))
## \todo The window doesn't appear without this naughtiness. I think we either need to
# add a similar method in the public interface, or maybe make a SizeConstraintContainer
# or something along those lines.
self.__window._qtWidget().setMinimumSize(300, 200)
self.__window.setVisible(True)
GafferUI.EventLoop.mainEventLoop().start()
return 0
def __importReference(menu, node):
bookmarks = GafferUI.Bookmarks.acquire(node, category="reference")
path = Gaffer.FileSystemPath(bookmarks.getDefault(menu))
path.setFilter(Gaffer.FileSystemPath.createStandardFilter(["grf"]))
window = menu.ancestor(GafferUI.Window)
dialogue = GafferUI.PathChooserDialogue(path,
title="Import reference",
confirmLabel="Import",
leaf=True,
valid=True,
bookmarks=bookmarks)
path = dialogue.waitForPath(parentWindow=window)
if not path:
return
scriptNode = node.ancestor(Gaffer.ScriptNode)
with GafferUI.ErrorDialogue.ErrorHandler(title="Error Importing Reference",
closeLabel="Oy vey",
parentWindow=window):
with Gaffer.UndoScope(scriptNode):
scriptNode.executeFile(str(path),
parent=node,
continueOnError=True)
def _waitForFileName( initialFileName="", parentWindow=None ) : if initialFileName : path = Gaffer.FileSystemPath( os.path.dirname( os.path.abspath( initialFileName ) ) ) else : path = Gaffer.FileSystemPath( os.getcwd() ) path.setFilter( Gaffer.FileSystemPath.createStandardFilter( [ "grf" ] ) ) dialogue = GafferUI.PathChooserDialogue( path, title = "Load reference", confirmLabel = "Load" ) path = dialogue.waitForPath( parentWindow = parentWindow ) if not path : return "" return str( path )
def __init__(self,
plug,
path=None,
pathChooserDialogueKeywords=None,
**kw):
self.__row = GafferUI.ListContainer(
GafferUI.ListContainer.Orientation.Horizontal, spacing=4)
GafferUI.PlugValueWidget.__init__(self, self.__row, plug, **kw)
self.__path = path if path is not None else Gaffer.FileSystemPath()
self.__pathChooserDialogueKeywords = pathChooserDialogueKeywords
pathWidget = GafferUI.PathWidget(self.__path)
self._addPopupMenu(pathWidget)
self.__row.append(pathWidget)
button = GafferUI.Button(image="pathChooser.png", hasFrame=False)
self.__buttonClickedConnection = button.clickedSignal().connect(
Gaffer.WeakMethod(self.__buttonClicked))
self.__row.append(button)
self.__editingFinishedConnection = pathWidget.editingFinishedSignal(
).connect(Gaffer.WeakMethod(self.__setPlugValue))
self._updateFromPlug()
def testPropertyNames(self):
p = Gaffer.FileSystemPath(self.temporaryDirectory())
a = p.propertyNames()
self.assertTrue(isinstance(a, list))
self.assertTrue("fileSystem:group" in a)
self.assertTrue("fileSystem:owner" in a)
self.assertTrue("fileSystem:modificationTime" in a)
self.assertTrue("fileSystem:size" in a)
self.assertTrue("fileSystem:frameRange" not in a)
p = Gaffer.FileSystemPath(self.temporaryDirectory(),
includeSequences=True)
self.assertTrue("fileSystem:frameRange" in p.propertyNames())
def __exportOSLShader(nodeEditor, node):
bookmarks = GafferUI.Bookmarks.acquire(node, category="shader")
path = Gaffer.FileSystemPath(bookmarks.getDefault(nodeEditor))
path.setFilter(Gaffer.FileSystemPath.createStandardFilter(["osl"]))
dialogue = GafferUI.PathChooserDialogue(path,
title="Export OSL Shader",
confirmLabel="Export",
leaf=True,
bookmarks=bookmarks)
path = dialogue.waitForPath(
parentWindow=nodeEditor.ancestor(GafferUI.Window))
if not path:
return
path = str(path)
if not path.endswith(".osl"):
path += ".osl"
with GafferUI.ErrorDialogue.ErrorHandler(title="Error Exporting Shader",
parentWindow=nodeEditor.ancestor(
GafferUI.Window)):
with open(path, "w") as f:
with nodeEditor.getContext():
f.write(
node.source(os.path.splitext(os.path.basename(path))[0]))
def __pathAndBookmarks( scriptWindow ) : bookmarks = GafferUI.Bookmarks.acquire( scriptWindow, pathType = Gaffer.FileSystemPath, category = "script", ) currentFileName = scriptWindow.scriptNode()["fileName"].getValue() if currentFileName : path = Gaffer.FileSystemPath( os.path.dirname( os.path.abspath( currentFileName ) ) ) else : path = Gaffer.FileSystemPath( bookmarks.getDefault( scriptWindow ) ) path.setFilter( Gaffer.FileSystemPath.createStandardFilter( [ "gfr" ] ) ) return path, bookmarks
def __init__( self, data=None, editable=True, header=False, showIndices=True, path=None, pathChooserDialogueKeywords={}, **kw ) :
GafferUI.VectorDataWidget.__init__( self, data=data, editable=editable, header=header, showIndices=showIndices, **kw )
self.__path = path if path is not None else Gaffer.FileSystemPath( "/" )
self.__pathChooserDialogueKeywords = pathChooserDialogueKeywords
self.__editConnection = self.editSignal().connect( Gaffer.WeakMethod( self.__edit ) )
def testRelativePath(self):
os.chdir(self.temporaryDirectory())
with open(self.temporaryDirectory() + "/a", "w") as f:
f.write("AAAA")
p = Gaffer.FileSystemPath("a")
self.assertEqual(str(p), "a")
self.assertFalse(p.isEmpty())
self.assertTrue(p.isValid())
p2 = Gaffer.FileSystemPath("nonexistent")
self.assertEqual(str(p2), "nonexistent")
self.assertFalse(p2.isEmpty())
self.assertFalse(p2.isValid())
def testInfoOfInvalidPath(self):
fp = Gaffer.FileSystemPath("/iSurelyDontExist")
self.assertEqual(fp.isValid(), False)
self.assertEqual(fp.info(), None)
sp = Gaffer.SequencePath(fp)
self.assertEqual(sp.isValid(), False)
self.assertEqual(sp.info(), None)
def testPropertyNames(self):
p = Gaffer.FileSystemPath(self.__dir)
a = p.propertyNames()
self.assertTrue(isinstance(a, list))
self.assertTrue("fileSystem:group" in a)
self.assertTrue("fileSystem:owner" in a)
self.assertTrue("fileSystem:modificationTime" in a)
self.assertTrue("fileSystem:size" in a)
def testGroup(self):
p = Gaffer.FileSystemPath(self.temporaryDirectory())
p.append("t")
with open(str(p), "w") as f:
f.write("AAAA")
g = p.property("fileSystem:group")
self.assertTrue(isinstance(g, str))
self.assertEqual(g, grp.getgrgid(os.stat(str(p)).st_gid).gr_name)
def testOwner(self):
p = Gaffer.FileSystemPath(self.temporaryDirectory())
p.append("t")
with open(str(p), "w") as f:
f.write("AAAA")
o = p.property("fileSystem:owner")
self.assertTrue(isinstance(o, str))
self.assertEqual(o, pwd.getpwuid(os.stat(str(p)).st_uid).pw_name)
