def touched_ae(dst): pardir = os.path.split(dst)[0] if not pardir: pardir = os.curdir import Finder f = Finder.Finder() f.update(File.FSRef(pardir))
def init(): resource_locations = [ r"resources", r"C:\Users\Fred\Documents\My Dropbox\resources", r"/Users/stephen/Dropbox/resources", r"C:\Users\Tyler\Documents\My Dropbox\resources", r"C:\Users\merfie\Documents\My Dropbox\resources" ] try: more_locations = [ os.path.join(os.path.dirname(sys.argv[0]), r"resources"), os.path.join(os.path.dirname(sys.argv[0]), r"resources_repo"), ] resource_locations = more_locations + resource_locations except: pass for location in resource_locations: if os.path.isdir(location): settings.resources_path = location break else: try: from Carbon import File fs, _, _ = File.ResolveAliasFile('location', 1) settings.resources_path = fs.as_pathname() break except: pass pyglet.resource.path.append(settings.resources_path) pyglet.resource.path.append(os.getcwd()) pyglet.resource.reindex()
def _generateDocumentsDir(): path = "" if sys.platform == "win32": from win32com.shell import shell, shellcon path = shell.SHGetFolderPath(0, shellcon.CSIDL_PERSONAL, None, 0) elif sys.platform == "darwin": import Carbon.File as CFile import Carbon.Folder as CFolder import Carbon.Folders as CFolders fsspec_disk, fsspec_desktop = CFolder.FindFolder( CFolders.kOnSystemDisk, CFolders.kDocumentsFolderType, 0) path = CFile.FSSpec((fsspec_disk, fsspec_desktop, '')).as_pathname() if path == "": path = os.path.expanduser("~") return path
def touched_ae(dst): """Tell the finder a file has changed""" pardir = os.path.split(dst)[0] if not pardir: pardir = os.curdir import Finder f = Finder.Finder() f.update(File.FSRef(pardir))
def actual_path(path): ''' If this path is actually a symlink (or an Apple alias) it returns the actual path ''' # Unfortunately I think os.path.realpath is broken under windows, but I can't check if check_apple_alias: return File.FSResolveAliasFile(path, True)[0].as_pathname() elif os.path.islink(path): return os.readlink(path) else: return path
def resolvealiases(path): try: fsr, d1, d2 = File.FSResolveAliasFile(path, 1) path = fsr.as_pathname() return path except (File.Error, ValueError), (error, str): if error <> -120: raise dir, file = os.path.split(path) return os.path.join(resolvealiases(dir), file)
def loadFile(self, filename): "load an image file and display it" try: self.im = Image.open(filename) except: # need to resolve alias if PLATFORM == 'OSX': fss = CF.FSSpec(filename) try: fss, isFolder, aliased = CF.ResolveAliasFile(fss, 0) except: print "File not found: ", filename return fsr = CF.FSRef(fss) filename = fsr.FSRefMakePath() self.im = Image.open(filename) if self.im.size[0] > self.max_w: self.im = self.resize(self.im) if self.im.size[1] > self.max_h: self.im = self.resize(self.im) self.displayImage(filename)
def mkalias(src, dst, relative=None): """Create a finder alias""" srcfsr = File.FSRef(src) # The next line will fail under unix-Python if the destination # doesn't exist yet. We should change this code to be fsref-based. dstdir, dstname = os.path.split(dst) if not dstdir: dstdir = os.curdir dstdirfsr = File.FSRef(dstdir) if relative: relativefsr = File.FSRef(relative) # ik mag er geen None in stoppen :-( alias = File.FSNewAlias(relativefsr, srcfsr) else: alias = srcfsr.FSNewAliasMinimal() dstfsr, dstfss = Res.FSCreateResourceFile(dstdirfsr, unicode(dstname), File.FSGetResourceForkName()) h = Res.FSOpenResourceFile(dstfsr, File.FSGetResourceForkName(), 3) resource = Res.Resource(alias.data) resource.AddResource('alis', 0, '') Res.CloseResFile(h) dstfinfo = dstfss.FSpGetFInfo() dstfinfo.Flags = dstfinfo.Flags | 0x8000 # Alias flag dstfss.FSpSetFInfo(dstfinfo)
def copy(src, dst, createpath=0, copydates=1, forcetype=None): """Copy a file, including finder info, resource fork, etc""" src = File.pathname(src) dst = File.pathname(dst) if createpath: mkdirs(os.path.split(dst)[0]) ifp = open(src, 'rb') ofp = open(dst, 'wb') d = ifp.read(BUFSIZ) while d: ofp.write(d) d = ifp.read(BUFSIZ) ifp.close() ofp.close() ifp = openrf(src, '*rb') ofp = openrf(dst, '*wb') d = ifp.read(BUFSIZ) while d: ofp.write(d) d = ifp.read(BUFSIZ) ifp.close() ofp.close() srcfss = File.FSSpec(src) dstfss = File.FSSpec(dst) sf = srcfss.FSpGetFInfo() df = dstfss.FSpGetFInfo() df.Creator, df.Type = sf.Creator, sf.Type if forcetype != None: df.Type = forcetype df.Flags = (sf.Flags & COPY_FLAGS) dstfss.FSpSetFInfo(df) if copydates: srcfsr = File.FSRef(src) dstfsr = File.FSRef(dst) catinfo, _, _, _ = srcfsr.FSGetCatalogInfo(Files.kFSCatInfoAllDates) dstfsr.FSSetCatalogInfo(Files.kFSCatInfoAllDates, catinfo) touched(dstfss)
def __openfiles(self, requestevent, replyevent): try: listdesc = requestevent.AEGetParamDesc(keyDirectObject, typeAEList) for i in range(listdesc.AECountItems()): aliasdesc = listdesc.AEGetNthDesc(i + 1, typeAlias)[1] alias = File.Alias(rawdata=aliasdesc.data) fsref = alias.FSResolveAlias(None)[0] pathname = fsref.as_pathname() sys.argv.append(pathname) except Exception, e: print "argvemulator.py warning: can't unpack an open document event" import traceback traceback.print_exc()
def open_file(self, requestevent, replyevent): from chimera import openModels, UserError, replyobj try: listdesc = requestevent.AEGetParamDesc(AEc.keyDirectObject, AEc.typeAEList) for i in xrange(listdesc.AECountItems()): aliasdesc = listdesc.AEGetNthDesc(i + 1, AEc.typeAlias)[1] alias = File.Alias(rawdata=aliasdesc.data) fsref = alias.FSResolveAlias(None)[0] pathname = fsref.as_pathname() #print "GOT OPEN FOR %s" % pathname openModels.open(pathname) except UserError, what: replyobj.error("%s" % what)
def setFileTypeToOggs(self,fn): """Set filetype to OggS to allow playback in iTunes""" from Carbon import File, Files for f in fn: fl, is_dir = File.FSPathMakeRef(f.encode('utf-8')) if is_dir: return False ci, _fn, fsspc, pfl = fl.FSGetCatalogInfo(Files.kFSCatInfoFinderInfo) finfo = fsspc.FSpGetFInfo() finfo.Type = 'OggS' fsspc.FSpSetFInfo(finfo) return True
def realPathCase(path): """ Return the real case of path e.g. PageName for pagename HFS and HFS+ file systems, are case preserving but case insensitive. You can't have 'file' and 'File' in the same directory, but you can get the real name of 'file'. @param path: string @rtype: string @return the real case of path or None """ try: from Carbon import File try: return File.FSRef(path).as_pathname() except File.Error: return None except ImportError: return None
def set(self, path_or_fss, start=0): self.SetPort() if self.movie: #self.GetWindow().InvalWindowRect(self.movie.GetMovieBox()) Qd.PaintRect(self.movie.GetMovieBox()) path = File.pathname(path) self.movietitle = os.path.basename(path) movieResRef = Qt.OpenMovieFile(path_or_fss, 1) self.movie, dummy, dummy = Qt.NewMovieFromFile( movieResRef, 0, QuickTime.newMovieActive) self.moviebox = self.movie.GetMovieBox() self.calcmoviebox() Qd.ObscureCursor() # XXX does this work at all? self.movie.GoToBeginningOfMovie() if start: self.movie.StartMovie() self.running = 1 else: self.running = 0 self.movie.MoviesTask(0)
def mkalias(src, dst, relative=None): srcfsr = File.FSRef(src) dstdir, dstname = os.path.split(dst) if not dstdir: dstdir = os.curdir dstdirfsr = File.FSRef(dstdir) if relative: relativefsr = File.FSRef(relative) alias = File.FSNewAlias(relativefsr, srcfsr) else: alias = srcfsr.FSNewAliasMinimal() dstfsr, dstfss = Res.FSCreateResourceFile(dstdirfsr, unicode(dstname), File.FSGetResourceForkName()) h = Res.FSOpenResourceFile(dstfsr, File.FSGetResourceForkName(), 3) resource = Res.Resource(alias.data) resource.AddResource('alis', 0, '') Res.CloseResFile(h) dstfinfo = dstfss.FSpGetFInfo() dstfinfo.Flags = dstfinfo.Flags | 32768 dstfss.FSpSetFInfo(dstfinfo)
# Make sure fonts are found on Mac OS X if platform.system() == 'Darwin': fontPaths = [] try: from Carbon import File, Folder, Folders # @UnresolvedImport domains = [ Folders.kUserDomain, Folders.kLocalDomain, Folders.kSystemDomain ] if not runningFromSource: domains.append(Folders.kNetworkDomain) for domain in domains: try: fsref = Folder.FSFindFolder(domain, Folders.kFontsFolderType, False) fontPaths.append(File.pathname(fsref)) except: pass # Folder probably doesn't exist. except: fontPaths.extend([ os.path.expanduser('~/Library/Fonts'), '/Library/Fonts', '/Network/Library/Fonts', '/System/Library/Fonts' ]) os.environ['OSG_FILE_PATH'] = ':'.join(fontPaths) # Set up for internationalization. import gettext as gettext_module, __builtin__ __builtin__.gettext = gettext_module.translation('Neuroptikon', fallback=True).lgettext # Install a new version of inspect.getdoc() that converts any reST formatting to plain text.
class File(_Base): """A reference to a filesystem location.""" # Constructors def __init__(self, path): """Make File object from POSIX path.""" self._path = unicode(path) #self._hfs = None self._url = None self._fsref = None self._fsspec = None self._desc = None def makewithurl(klass, url): """Make File object from file URL.""" scheme, netloc, path = urlparse(url)[:3] if scheme != 'file': raise ValueError, 'Not a file URL.' obj = klass(unicode(unquote(path), 'utf8')) obj._url = url return obj makewithurl = classmethod(makewithurl) def makewithfsref(klass, fsref): """Make File object from Carbon.File.FSRef.""" obj = klass(unicode(fsref.as_pathname(), 'utf8')) obj._fsref = fsref return obj makewithfsref = classmethod(makewithfsref) def makewithfsspec(klass, fsspec): """Make File object from legacy Carbon.File.FSSpec.""" obj = klass(unicode(fsspec.as_pathname(), 'utf8')) obj._fsspec = fsspec return obj makewithfsspec = classmethod(makewithfsspec) def makewithaedesc(klass, desc): """Make File object from CarbonX.AE.AEDesc of typeFSS, typeFSRef, typeFileURL. Note: behaviour for other descriptor types is undefined: typeAlias will cause problems, others will probably fail. """ if desc.type == kAE.typeFileURL: url = desc.data else: url = desc.AECoerceDesc(kAE.typeFileURL).data obj = klass(unicode(unquote(urlparse(url)[2]), 'utf8')) obj._url = url obj._desc = desc return obj makewithaedesc = classmethod(makewithaedesc) # Instance methods def __repr__(self): return 'mactypes.File(%r)' % self._path # Properties path = property(lambda self: self._path, _ro, doc="Get as POSIX path.") def url(self): if self._url is None: self._url = urlunparse( ('file', 'localhost', quote(self._path.encode('utf8')), '', '', '')) return self._url url = property(url, _ro, doc="Get as file URL.") file = property(lambda self: File(self._path), _ro, doc="Get as mactypes.File.") alias = property(lambda self: Alias.makewithfsref(self.fsref), _ro, doc="Get as mactypes.Alias.") def fsref(self): if self._fsref: return self._fsref else: if self._desc: self._fsref = Carbon.File.FSRef( rawdata=self._desc.AECoerceDesc(kAE.typeFSRef).data) return self._fsref else: return Carbon.File.FSRef(self._path) fsref = property(fsref, _ro, doc="Get as Carbon.File.FSRef.") def fsspec(self): if self._fsspec: return self._fsspec else: if self._desc: self._fsspec = Carbon.File.FSSpec( rawdata=self._desc.AECoerceDesc(kAE.typeFSS).data) return self._fsspec else: return Carbon.File.FSSpec(self._path) fsspec = property(fsspec, _ro, doc="Get as legacy Carbon.File.FSSpec.") fsalias = property(lambda self: Carbon.File.FSNewAlias(None, self.fsref), _ro, doc="Get as Carbon.File.Alias.") def aedesc(self): if self._desc is None: if self._fsref: self._desc = AECreateDesc(kAE.typeFSRef, self._fsref.data) elif self._fsspec: self._desc = AECreateDesc(kAE.typeFSS, self._fsspec.data) else: self._desc = AECreateDesc(kAE.typeFileURL, self.url) return self._desc aedesc = property(aedesc, _ro, doc="Get as CarbonX.AE.AEDesc.")
class Alias(_Base): """A persistent reference to a filesystem object.""" # Constructors def __init__(self, path): """Make Alias object from POSIX path.""" if path is not _NoPath: self._alias = Carbon.File.FSNewAlias( None, Carbon.File.FSRef(unicode(path))) self._desc = None def makewithurl(klass, url): """Make File object from file URL.""" scheme, netloc, path = urlparse(url)[:3] if scheme != 'file': raise ValueError, 'Not a file URL.' obj = klass(unicode(unquote(path), 'utf8')) return obj makewithurl = classmethod(makewithurl) def makewithfsref(klass, fsref): """Make Alias object from Carbon.File.FSRef.""" return klass.makewithfsalias(Carbon.File.FSNewAlias(None, fsref)) makewithfsref = classmethod(makewithfsref) def makewithfsalias(klass, alias): """Make Alias object from Carbon.File.Alias.""" obj = klass(_NoPath) obj._alias = alias return obj makewithfsalias = classmethod(makewithfsalias) def makewithaedesc(klass, desc): """Make Alias object from CarbonX.AE.AEDesc of typeAlias (typeFSS, typeFSRef, typeFileURL should also be acceptable). Note: behaviour for other descriptor types is undefined and will probably fail. """ obj = klass(_NoPath) obj._alias = Carbon.File.Alias( rawdata=desc.AECoerceDesc(kAE.typeAlias).data) return obj makewithaedesc = classmethod(makewithaedesc) # Instance methods def __repr__(self): return 'mactypes.Alias(%r)' % unicode(self.fsref.as_pathname(), 'utf8') # Properties path = property(lambda self: unicode( self._alias.FSResolveAlias(None)[0].as_pathname(), 'utf8'), _ro, doc="Get as POSIX path.") url = property(lambda self: urlunparse( ('file', 'localhost', quote(self.path.encode('utf8')), '', '', '')), _ro, doc="Get as file URL.") file = property(lambda self: File.makewithfsref(self.fsref), _ro, doc="Get as mactypes.File.") alias = property(lambda self: self, _ro, doc="Get as mactypes.Alias (i.e. itself).") fsref = property(lambda self: self._alias.FSResolveAlias(None)[0], _ro, doc="Get as Carbon.File.FSRef.") fsspec = property(lambda self: self._alias.ResolveAlias(None)[0], _ro, doc="Get as legacy Carbon.File.FSSpec.") fsalias = property(lambda self: self._alias, _ro, doc="Get as Carbon.File.Alias.") def aedesc(self): if not self._desc: self._desc = AECreateDesc(kAE.typeAlias, self._alias.data) return self._desc aedesc = property(aedesc, _ro, doc="Get as CarbonX.AE.AEDesc.")
def getmodtime(file): file = File.FSRef(file) catinfo, d1, d2, d3 = file.FSGetCatalogInfo(Files.kFSCatInfoContentMod) return catinfo.contentModDate
def makeusermenus(self): m = Wapplication.Menu(self.menubar, "File") newitem = FrameWork.MenuItem(m, "New", "N", 'new') openitem = FrameWork.MenuItem(m, "Open" + ELLIPSIS, "O", 'open') openbynameitem = FrameWork.MenuItem(m, "Open File by Name" + ELLIPSIS, "D", 'openbyname') self.openrecentmenu = FrameWork.SubMenu(m, "Open Recent") self.makeopenrecentmenu() FrameWork.Separator(m) closeitem = FrameWork.MenuItem(m, "Close", "W", 'close') saveitem = FrameWork.MenuItem(m, "Save", "S", 'save') saveasitem = FrameWork.MenuItem(m, "Save as" + ELLIPSIS, None, 'save_as') FrameWork.Separator(m) saveasappletitem = FrameWork.MenuItem(m, "Save as Applet" + ELLIPSIS, None, 'save_as_applet') FrameWork.Separator(m) instmgritem = FrameWork.MenuItem(m, "Package Manager", None, 'openpackagemanager') gensuiteitem = FrameWork.MenuItem(m, "Generate OSA Suite...", None, 'gensuite') if not runningOnOSX(): # On OSX there's a special "magic" quit menu, so we shouldn't add # it to the File menu. FrameWork.Separator(m) quititem = FrameWork.MenuItem(m, "Quit", "Q", 'quit') m = Wapplication.Menu(self.menubar, "Edit") undoitem = FrameWork.MenuItem(m, "Undo", 'Z', "undo") FrameWork.Separator(m) cutitem = FrameWork.MenuItem(m, "Cut", 'X', "cut") copyitem = FrameWork.MenuItem(m, "Copy", "C", "copy") pasteitem = FrameWork.MenuItem(m, "Paste", "V", "paste") FrameWork.MenuItem(m, "Clear", None, "clear") FrameWork.Separator(m) selallitem = FrameWork.MenuItem(m, "Select all", "A", "selectall") sellineitem = FrameWork.MenuItem(m, "Select line", "L", "selectline") FrameWork.Separator(m) finditem = FrameWork.MenuItem(m, "Find" + ELLIPSIS, "F", "find") findagainitem = FrameWork.MenuItem(m, "Find again", 'G', "findnext") enterselitem = FrameWork.MenuItem(m, "Enter search string", "E", "entersearchstring") replaceitem = FrameWork.MenuItem(m, "Replace", None, "replace") replacefinditem = FrameWork.MenuItem(m, "Replace & find again", 'T', "replacefind") FrameWork.Separator(m) shiftleftitem = FrameWork.MenuItem(m, "Shift left", "[", "shiftleft") shiftrightitem = FrameWork.MenuItem(m, "Shift right", "]", "shiftright") m = Wapplication.Menu(self.menubar, "Python") runitem = FrameWork.MenuItem(m, "Run window", "R", 'run') runselitem = FrameWork.MenuItem(m, "Run selection", None, 'runselection') FrameWork.Separator(m) moditem = FrameWork.MenuItem(m, "Module browser" + ELLIPSIS, "M", self.domenu_modulebrowser) FrameWork.Separator(m) mm = FrameWork.SubMenu(m, "Preferences") FrameWork.MenuItem(mm, "Set Scripts folder" + ELLIPSIS, None, self.do_setscriptsfolder) FrameWork.MenuItem(mm, "Editor default settings" + ELLIPSIS, None, self.do_editorprefs) FrameWork.MenuItem(mm, "Set default window font" + ELLIPSIS, None, self.do_setwindowfont) self.openwindowsmenu = Wapplication.Menu(self.menubar, 'Windows') self.makeopenwindowsmenu() self._menustocheck = [ closeitem, saveitem, saveasitem, saveasappletitem, undoitem, cutitem, copyitem, pasteitem, selallitem, sellineitem, finditem, findagainitem, enterselitem, replaceitem, replacefinditem, shiftleftitem, shiftrightitem, runitem, runselitem ] prefs = self.getprefs() try: fsr, d = File.Alias( rawdata=prefs.scriptsfolder).FSResolveAlias(None) self.scriptsfolder = fsr.FSNewAliasMinimal() except: path = os.path.join(os.getcwd(), "Mac", "IDE scripts") if not os.path.exists(path): if sys.platform == "darwin": path = os.path.join(os.getenv("HOME"), "Library", "Python", "IDE-Scripts") else: path = os.path.join(os.getcwd(), "Scripts") if not os.path.exists(path): os.makedirs(path) f = open( os.path.join(path, "Place your scripts here" + ELLIPSIS), "w") f.close() fsr = File.FSRef(path) self.scriptsfolder = fsr.FSNewAliasMinimal() self.scriptsfoldermodtime = getmodtime(fsr) else: self.scriptsfoldermodtime = getmodtime(fsr) prefs.scriptsfolder = self.scriptsfolder.data self._scripts = {} self.scriptsmenu = None self.makescriptsmenu() self.makehelpmenu()
except ImportError: pass # Make sure fonts are found on Mac OS X if platform.system() == 'Darwin': fontPaths = [] try: from Carbon import File, Folder, Folders # @UnresolvedImport domains = [Folders.kUserDomain, Folders.kLocalDomain, Folders.kSystemDomain] if not runningFromSource: domains.append(Folders.kNetworkDomain) for domain in domains: try: fsref = Folder.FSFindFolder(domain, Folders.kFontsFolderType, False) fontPaths.append(File.pathname(fsref)) except: pass # Folder probably doesn't exist. except: fontPaths.extend([os.path.expanduser('~/Library/Fonts'), '/Library/Fonts', '/Network/Library/Fonts', '/System/Library/Fonts']) os.environ['OSG_FILE_PATH'] = ':'.join(fontPaths) # Set up for internationalization. import gettext as gettext_module, __builtin__ __builtin__.gettext = gettext_module.translation('Neuroptikon', fallback = True).lgettext # Install a new version of inspect.getdoc() that converts any reST formatting to plain text. import inspect, re _orig_getdoc = inspect.getdoc