def save(self, filename, data, mode='wb', overwriteNewer=False):
if self.resourcepath != filename:
self.resourcepath = filename
self.name = os.path.basename(self.resourcepath)
try:
if not overwriteNewer and self.fileIsNewer():
raise ExplorerNodes.TransportModifiedSaveError(
_('This file has '
'been saved by someone else since it was loaded'),
self.resourcepath)
open(self.resourcepath, mode).write(data)
except IOError, error:
raise ExplorerNodes.TransportSaveError(error, self.resourcepath)
def load(self, mode='rb'):
try:
data = open(self.resourcepath, mode).read()
self.updateStdAttrs()
return data
except IOError, error:
raise ExplorerNodes.TransportLoadError(error, self.resourcepath)
def save(self, filename, data, mode='wb', overwriteNewer=False):
if filename != self.currentFilename():
self.ftpObj.path = os.path.dirname(filename)
self.ftpObj.name = os.path.basename(filename)
try:
self.ftpConn.save(self.ftpObj, data)
except Exception, error:
raise ExplorerNodes.TransportSaveError(error, self.ftpObj.whole_name())
def load(self, mode='rb'):
from FileExplorer import FileSysNode
import tempfile
fn = tempfile.mktemp()
p, n = os.path.split(fn)
fn = os.path.join(p, 'X'+n)
try:
self.copyToFS(FileSysNode('', os.path.dirname(fn), None, -1, None, None), os.path.basename(fn))
if os.path.exists(fn):
try:
return open(fn, mode).read()
finally:
os.remove(fn)
else:
raise ExplorerNodes.TransportLoadError(
_('File was not downloaded locally.'), self.resourcepath)
except Exception, error:
raise ExplorerNodes.TransportLoadError(error, self.resourcepath)
def save(self, filename, data, mode='wb', overwriteNewer=False):
if filename != self.resourcepath:
self.name = os.path.basename(filename)
self.resourcepath = filename
self.initResource()
try:
self.checkResp(self.resource.put(data))
except Exception, error:
raise ExplorerNodes.TransportSaveError(error, self.resourcepath)
def openList(self):
try:
#----------------------------------------
# A hack for locally-encoded filesystems:
# We need to convert filesystem names
# from local encoding to unicode
if type(self.resourcepath) is str:
files = os.listdir(
self.resourcepath.decode(sys.getfilesystemencoding()))
else: # unicode or other
files = os.listdir(self.resourcepath)
#----------------------------------------
except Exception, err:
raise ExplorerNodes.TransportError(err)
def save(self, filename, data, mode='wb', overwriteNewer=False):
from FileExplorer import FileSysNode
import tempfile
name = os.path.basename(self.resourcepath)
fn = tempfile.mktemp()
p, n = os.path.split(fn)
fn = os.path.join(p, 'X'+n)
try:
open(fn, mode).write(data)
try:
parentDir = os.path.dirname(self.resourcepath)
parentName = os.path.basename(parentDir)
parentSSHNode = self.createChildNode(parentName, 1,
self.properties, parentDir)
parentSSHNode.copyFromFS(FileSysNode('', fn, None, -1), name)
finally:
os.remove(fn)
except Exception, error:
raise ExplorerNodes.TransportSaveError(error, self.resourcepath)
def load(self, mode='rb'):
try:
return self.checkResp(self.resource.document_src.get()).body
except Exception, error:
raise ExplorerNodes.TransportLoadError(error, self.resourcepath)
def __init__(self, editor):
self._ref_all_transp = False
conf = Utils.createAndReadConfig('Explorer')
self.importExplorers(conf)
# Create clipboards for all registered nodes
self.clipboards = {'global': ExplorerNodes.GlobalClipper()}
for Clss, info in ExplorerNodes.explorerNodeReg.items():
Clip = info['clipboard']
if type(Clip) is ClassType:
self.clipboards[Clss.protocol] = Clip(
self.clipboards['global'])
# Root node and transports
self.boaRoot = ExplorerNodes.RootNode('Boa Constructor')
self.openEditorFiles = \
ExplorerNodes.nodeRegByProt['boa.open-models'](editor, self.boaRoot)
self.transports = ExplorerNodes.ContainerNode('Transport',
EditorHelper.imgFolder)
self.transports.entriesByProt = {}
self.transports.bold = True
if ExplorerNodes.all_transports is None:
ExplorerNodes.all_transports = self.transports
self._ref_all_transp = True
self.recentFiles = ExplorerNodes.MRUCatNode(self.clipboards, conf,
None, self.transports,
self)
self.bookmarks = ExplorerNodes.BookmarksCatNode(
self.clipboards, conf, None, self.transports, self)
self.pluginNodes = [
ExplorerNodes.nodeRegByProt[prot](self.clipboards['file'], None,
self.bookmarks)
for prot in ExplorerNodes.explorerRootNodesReg
]
self.preferences = \
ExplorerNodes.nodeRegByProt['boa.prefs.group'](self.boaRoot)
assert self.clipboards.has_key('file'), _(
'File system transport must be loaded')
# root level of the tree
self.boaRoot.entries = [
self.openEditorFiles, self.recentFiles, self.bookmarks,
self.transports
] + self.pluginNodes + [self.preferences]
# Populate transports with registered node categories
# Protocol also has to be defined in the explorer section of the config
transport_order = eval(conf.get('explorer', 'transportstree'), {})
for name in transport_order:
for Clss in ExplorerNodes.explorerNodeReg.keys():
if Clss.protocol == name:
Cat = ExplorerNodes.explorerNodeReg[Clss]['category']
if not Cat: break
Clip = ExplorerNodes.explorerNodeReg[Clss]['clipboard']
if type(Clip) == type(''):
clip = self.clipboards[Clip]
elif self.clipboards.has_key(Clss.protocol):
clip = self.clipboards[Clss.protocol]
else:
clip = None
confSect, confItem = ExplorerNodes.explorerNodeReg[Clss][
'confdef']
if conf.has_option(confSect, confItem):
try:
cat = Cat(clip, conf, None, self.bookmarks)
self.transports.entries.append(cat)
self.transports.entriesByProt[
Cat.itemProtocol] = cat
except Exception, error:
wx.LogWarning(_('Transport category %s not added: %s')\
%(Cat.defName, str(error)))
break
def getPropList(self):
propLst = []
if type(self.obj) is types.ListType:
props = self.obj
else:
props = [self.obj]
subProps = self.buildItems([], props)
for prop in subProps:
propLst.append(
RTTI.PropertyWrapper(prop[0], 'NameRoute', self.GetProp,
self.SetProp))
self.propItems = subProps
return {'constructor': [], 'properties': propLst}
def GetProp(self, name):
for prop in self.propItems:
if prop[0] == name: return prop[1]
def SetProp(self, name, value):
raise Exception, _('Property editing not supported yet')
#-------------------------------------------------------------------------------
ExplorerNodes.register(DAVItemNode,
clipboard=DAVExpClipboard,
confdef=('explorer', 'dav'),
controller=DAVController,
category=DAVCatNode)
ExplorerNodes.fileOpenDlgProtReg.append('dav')
def findFileExplorerNode(category, respath, transports):
for tp in transports.entries:
if tp.itemProtocol == 'file':
return tp.getNodeFromPath(respath, forceFolder=False)
raise ExplorerNodes.TransportError(
_('FileSysCatNode not found in transports %s') % transports.entries)
def createChildNode(self, name, modulePage):
return NewPaletteItemNode(modulePage.updatePageName(), name, modulePage, self)
def openList(self):
res = []
mods = []
for name, modPage in self.editor.modules.items():
mods.append( (modPage.tIdx, name, modPage) )
mods.sort()
for idx, name, modPage in mods:
res.append(self.createChildNode(name, modPage))
return res
class NewPaletteItemNode(ExplorerNodes.ExplorerNode):
protocol = 'boa.new-item'
def __init__(self, name, resourcepath, modulePage, parent):
ExplorerNodes.ExplorerNode.__init__(self, name, resourcepath, None,
modulePage.model.imgIdx, parent, {})
def notifyBeginLabelEdit(self, event):
event.Veto()
def isFolderish(self):
return False
#-------------------------------------------------------------------------------
ExplorerNodes.register(OpenModelsNode, controller=EditorController)
if not respath.startswith('~/'):
respath = '/' + respath
isFolder = respath[-1] == '/'
if isFolder:
respath = respath[:-1]
return self.createChildNode(os.path.basename(respath), isFolder,
self.properties, respath)
class SSHExpClipboard(ExplorerNodes.ExplorerClipboard):
def clipPaste_FileSysExpClipboard(self, node, nodes, mode):
for clipnode in nodes:
if mode == 'cut':
node.copyFromFS(clipnode)
self.clipNodes = []
elif mode == 'copy':
node.copyFromFS(clipnode)
def clipPaste_SSHExpClipboard(self, node, nodes, mode):
for sshNode in nodes:
if mode == 'cut':
node.moveFileFrom(sshNode)
self.clipNodes = []
elif mode == 'copy':
node.copyFileFrom(sshNode)
#-------------------------------------------------------------------------------
ExplorerNodes.register(SSHItemNode, clipboard=SSHExpClipboard,
confdef=('explorer', 'ssh'), controller=SSHController, category=SSHCatNode)
ExplorerNodes.fileOpenDlgProtReg.append('ssh')
class FTPExpClipboard(ExplorerNodes.ExplorerClipboard):
def pasteFileSysFolder(self, folderpath, nodepath, ftpConn):
ftpConn.add_folder(os.path.basename(folderpath), nodepath)
files = os.listdir(folderpath)
folder = os.path.basename(folderpath)
newNodepath = nodepath + '/' + folder
for file in files:
file = os.path.join(folderpath, file)
if os.path.isdir(file):
self.pasteFileSysFolder(file, newNodepath, ftpConn)
else:
ftpConn.upload(file, newNodepath)
def clipPaste_FileSysExpClipboard(self, node, nodes, mode):
nodepath = node.resourcepath
for file in nodes:
if file.isDir():
self.pasteFileSysFolder(file.resourcepath, nodepath,
node.ftpConn)
else:
node.ftpConn.upload(file.resourcepath, nodepath)
#-------------------------------------------------------------------------------
ExplorerNodes.register(FTPItemNode,
clipboard=FTPExpClipboard,
confdef=('explorer', 'ftp'),
controller=FTPController,
category=FTPCatNode)
ExplorerNodes.fileOpenDlgProtReg.append('ftp')
def getURI(self):
return self.getTitle()
def uriSplitFile(filename, filepath):
return 'file', '', filepath, filename
def findFileExplorerNode(category, respath, transports):
for tp in transports.entries:
if tp.itemProtocol == 'file':
return tp.getNodeFromPath(respath, forceFolder=False)
raise ExplorerNodes.TransportError(
_('FileSysCatNode not found in transports %s') % transports.entries)
#-------------------------------------------------------------------------------
ExplorerNodes.register(FileSysNode,
clipboard=FileSysExpClipboard,
confdef=('explorer', 'file'),
controller=FileSysController,
category=FileSysCatNode)
ExplorerNodes.register(CurWorkDirNode,
clipboard='file',
controller='file',
root=True)
ExplorerNodes.fileOpenDlgProtReg.append('file')
ExplorerNodes.uriSplitReg[('file', 2)] = uriSplitFile
ExplorerNodes.uriSplitReg[('os.cwd', 2)] = uriSplitFile
ExplorerNodes.transportFindReg['file'] = findFileExplorerNode
return 'zip', zipfile, zipentry, filename
def findZipExplorerNode(category, respath, transports):
zf = ZipFileNode(os.path.basename(category), category, None, -1, None,
None)
zf.openList()
return zf.getNodeFromPath(respath)
#-------------------------------------------------------------------------------
# Register zip files as a subtype of file explorers
FileExplorer.FileSysNode.subExplorerReg['file'].append(
(ZipFileNode, isZip, EditorHelper.imgZipFileModel))
ExplorerNodes.register(ZipItemNode,
clipboard=ZipExpClipboard,
controller=ZipController)
ExplorerNodes.uriSplitReg[('zip', 3)] = uriSplitZip
ExplorerNodes.transportFindReg['zip'] = findZipExplorerNode
ExplorerNodes.fileOpenDlgProtReg.append('zip')
EditorHelper.modelReg[ZipFileModel.modelIdentifier] = ZipFileModel
EditorHelper.binaryFilesReg.append('.zip')
#-------------------------------------------------------------------------------
def isTarGzip(file):
name, ext = os.path.splitext(file)
return ext == '.tgz' or ext == '.gz' and os.path.splitext(
name)[1] == '.tar'
class DAVSubCompanion(DAVPropReaderMixin, HelperDTC):
def __init__(self, name, designer, ownerCompanion, obj, ownerPropWrap):
HelperDTC.__init__(self, name, designer, ownerCompanion, obj,
ownerPropWrap)
self.propItems = []
def getPropList(self):
propLst = []
if type(self.obj) is types.ListType:
props = self.obj
else:
props = [self.obj]
subProps = self.buildItems([], props)
for prop in subProps:
propLst.append(RTTI.PropertyWrapper(prop[0], 'NameRoute',
self.GetProp, self.SetProp))
self.propItems = subProps
return {'constructor': [], 'properties': propLst}
def GetProp(self, name):
for prop in self.propItems:
if prop[0] == name: return prop[1]
def SetProp(self, name, value):
raise Exception, _('Property editing not supported yet')
#-------------------------------------------------------------------------------
ExplorerNodes.register(DAVItemNode, clipboard=DAVExpClipboard,
confdef=('explorer', 'dav'), controller=DAVController, category=DAVCatNode)
ExplorerNodes.fileOpenDlgProtReg.append('dav')
def openList(self):
self.cwd = self.resourcepath = os.path.abspath(os.getcwd())
return FileSysNode.openList(self)
def getTitle(self):
return 'os.cwd://%s'%self.cwd
def getURI(self):
return self.getTitle()
def uriSplitFile(filename, filepath):
return 'file', '', filepath, filename
def findFileExplorerNode(category, respath, transports):
for tp in transports.entries:
if tp.itemProtocol == 'file':
return tp.getNodeFromPath(respath, forceFolder=False)
raise ExplorerNodes.TransportError(
_('FileSysCatNode not found in transports %s')%transports.entries)
#-------------------------------------------------------------------------------
ExplorerNodes.register(FileSysNode, clipboard=FileSysExpClipboard,
confdef=('explorer', 'file'), controller=FileSysController,
category=FileSysCatNode)
ExplorerNodes.register(CurWorkDirNode, clipboard='file', controller='file',
root=True)
ExplorerNodes.fileOpenDlgProtReg.append('file')
ExplorerNodes.uriSplitReg[('file', 2)] = uriSplitFile
ExplorerNodes.uriSplitReg[('os.cwd', 2)] = uriSplitFile
ExplorerNodes.transportFindReg['file'] = findFileExplorerNode
def createChildNode(self, name, modulePage):
return NewPaletteItemNode(modulePage.updatePageName(), name, modulePage, self)
def openList(self):
res = []
mods = []
for name, modPage in self.editor.modules.items():
mods.append( (modPage.tIdx, name, modPage) )
mods.sort()
for idx, name, modPage in mods:
res.append(self.createChildNode(name, modPage))
return res
class NewPaletteItemNode(ExplorerNodes.ExplorerNode):
protocol = 'boa.new-item'
def __init__(self, name, resourcepath, palette, newitem):
ExplorerNodes.ExplorerNode.__init__(self, name, resourcepath, None,
modulePage.model.imgIdx, parent, {})
def notifyBeginLabelEdit(self, event):
event.Veto()
def isFolderish(self):
return False
#-------------------------------------------------------------------------------
ExplorerNodes.register(OpenModelsNode, controller=EditorController)
Help.initHelp()
def OnClearHelpIndexes(self, event):
import Help
cd = Help.getCacheDir()
for name in os.listdir(cd):
if os.path.splitext(name)[1] == '.cached':
os.remove(os.path.join(cd, name))
wx.LogMessage(_('Deleted %s') % name)
def OnOpenHHP(self, event):
if self.list.node:
ms = self.list.getMultiSelection()
for node in self.getNodesForSelection(ms):
self.editor.openOrGotoModule(node.getAbsPath(
node.resourcepath))
#-------------------------------------------------------------------------------
ExplorerNodes.register(BoaPrefGroupNode)
ExplorerNodes.register(PluginFilesGroupNode,
controller=PluginFilesGroupNodeController)
ExplorerNodes.register(TransportPluginsLoadOrderGroupNode,
controller=TransportPluginsLoadOrderController)
ExplorerNodes.register(TransportPluginsTreeDisplayOrderGroupNode,
controller=TransportPluginsTreeDisplayOrderController)
ExplorerNodes.register(HelpConfigBooksPGN,
controller=HelpConfigBooksController)
def load(self, mode='rb'):
try:
return self.ftpConn.load(self.ftpObj)
except Exception, error:
raise ExplorerNodes.TransportLoadError(error,
self.ftpObj.whole_name())
self.entries = lst
return lst
def open(self, editor):
return editor.openOrGotoModule(self.resourcepath)
def openParent(self, editor):
tree = editor.explorer.tree
cvsParentItemParent = tree.GetItemParent(
tree.GetItemParent(tree.GetSelection()))
cvsChd = tree.getChildNamed(cvsParentItemParent, 'CVS')
if cvsChd.IsOk():
tree.SelectItem(cvsChd)
return True
else:
return False
#---------------------------------------------------------------------------
# Register cvs dirs as a subtype of file explorers
import FileExplorer
FileExplorer.FileSysNode.subExplorerReg['folder'].append(
(FSCVSFolderNode, isCVS, EditorHelper.imgCVSFolder))
ExplorerNodes.register(FSCVSFolderNode,
clipboard=None,
confdef=('', ''),
controller=CVSController)
Help.delHelp()
wx.Yield()
Help.initHelp()
def OnClearHelpIndexes(self, event):
import Help
cd = Help.getCacheDir()
for name in os.listdir(cd):
if os.path.splitext(name)[1] == '.cached':
os.remove(os.path.join(cd, name))
wx.LogMessage(_('Deleted %s')%name)
def OnOpenHHP(self, event):
if self.list.node:
ms = self.list.getMultiSelection()
for node in self.getNodesForSelection(ms):
self.editor.openOrGotoModule(node.getAbsPath(node.resourcepath))
#-------------------------------------------------------------------------------
ExplorerNodes.register(BoaPrefGroupNode)
ExplorerNodes.register(PluginFilesGroupNode,
controller=PluginFilesGroupNodeController)
ExplorerNodes.register(TransportPluginsLoadOrderGroupNode,
controller=TransportPluginsLoadOrderController)
ExplorerNodes.register(TransportPluginsTreeDisplayOrderGroupNode,
controller=TransportPluginsTreeDisplayOrderController)
ExplorerNodes.register(HelpConfigBooksPGN, controller=HelpConfigBooksController)
raise
else:
self.connected = True
class FTPExpClipboard(ExplorerNodes.ExplorerClipboard):
def pasteFileSysFolder(self, folderpath, nodepath, ftpConn):
ftpConn.add_folder(os.path.basename(folderpath), nodepath)
files = os.listdir(folderpath)
folder = os.path.basename(folderpath)
newNodepath = nodepath+'/'+folder
for file in files:
file = os.path.join(folderpath, file)
if os.path.isdir(file):
self.pasteFileSysFolder(file, newNodepath, ftpConn)
else:
ftpConn.upload(file, newNodepath)
def clipPaste_FileSysExpClipboard(self, node, nodes, mode):
nodepath = node.resourcepath
for file in nodes:
if file.isDir():
self.pasteFileSysFolder(file.resourcepath, nodepath, node.ftpConn)
else:
node.ftpConn.upload(file.resourcepath, nodepath)
#-------------------------------------------------------------------------------
ExplorerNodes.register(FTPItemNode, clipboard=FTPExpClipboard,
confdef=('explorer', 'ftp'), controller=FTPController, category=FTPCatNode)
ExplorerNodes.fileOpenDlgProtReg.append('ftp')
imgIdx = EditorHelper.imgZipFileModel
ext = '.zip'
def uriSplitZip(filename, zipfile, zipentry):
return 'zip', zipfile, zipentry, filename
def findZipExplorerNode(category, respath, transports):
zf = ZipFileNode(os.path.basename(category), category, None, -1, None, None)
zf.openList()
return zf.getNodeFromPath(respath)
#-------------------------------------------------------------------------------
# Register zip files as a subtype of file explorers
FileExplorer.FileSysNode.subExplorerReg['file'].append(
(ZipFileNode, isZip, EditorHelper.imgZipFileModel))
ExplorerNodes.register(ZipItemNode, clipboard=ZipExpClipboard,
controller=ZipController)
ExplorerNodes.uriSplitReg[('zip', 3)] = uriSplitZip
ExplorerNodes.transportFindReg['zip'] = findZipExplorerNode
ExplorerNodes.fileOpenDlgProtReg.append('zip')
EditorHelper.modelReg[ZipFileModel.modelIdentifier] = ZipFileModel
EditorHelper.binaryFilesReg.append('.zip')
#-------------------------------------------------------------------------------
def isTarGzip(file):
name, ext = os.path.splitext(file)
return ext == '.tgz' or ext == '.gz' and os.path.splitext(name)[1] == '.tar'
class TarGzipController(ZipController): pass
class TarGzipInfoMixin:
def createCatCompanion(self, catNode):
comp = ExplorerNodes.CategoryDictCompanion(catNode.treename, self)
return comp
for missing in missingEntries:
lst.append(missing)
self.entries = lst
return lst
def open(self, editor):
return editor.openOrGotoModule(self.resourcepath)
def openParent(self, editor):
tree = editor.explorer.tree
cvsParentItemParent = tree.GetItemParent(tree.GetItemParent(tree.GetSelection()))
cvsChd = tree.getChildNamed(cvsParentItemParent, 'CVS')
if cvsChd.IsOk():
tree.SelectItem(cvsChd)
return True
else:
return False
#---------------------------------------------------------------------------
# Register cvs dirs as a subtype of file explorers
import FileExplorer
FileExplorer.FileSysNode.subExplorerReg['folder'].append(
(FSCVSFolderNode, isCVS, EditorHelper.imgCVSFolder)
)
ExplorerNodes.register(FSCVSFolderNode, clipboard=None, confdef=('', ''),
controller=CVSController)
