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)
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)
# 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
