def display(self, desc, event):
uri = desc.get_uri()
if not gnomevfs.exists(uri):
return
file_info = gnomevfs.get_file_info(uri)
is_dir = files.is_dir(file_info)
icon_manager = Icons(self)
if is_dir:
pixbuf = icon_manager.retrieve_icon(u'stock_folder',
gtk.STOCK_DIRECTORY)
self.__appendMenuItem(label=menu0001, pixbuf=pixbuf,
callback=lambda a: self.__set_repository(uri))
pixbuf = None
else:
self.__appendMenuItem(stock=gtk.STOCK_OPEN,
callback=lambda a: self.__open_file(uri))
if is_dir:
self.__appendSeperator()
pixbuf = icon_manager.retrieve_icon(gtk.STOCK_NEW, gtk.STOCK_NEW)
self.__appendMenuItem(label=menu0003, pixbuf=pixbuf,
callback=lambda a: self.__create_file_in(uri))
self.__appendMenuItem(label=menu0010, pixbuf=pixbuf,
callback=lambda a: self.__create_folder_in(uri))
self.__appendSeperator()
pixbuf = None
if gnomevfs.exists(uri) and uri.is_local:
pixbuf = None
if icon_manager.theme.has_icon(u'gnome-terminal'):
pixbuf = icon_manager.theme.load_icon(u'gnome-terminal',
16, gtk.ICON_LOOKUP_USE_BUILTIN)
self.__appendMenuItem(label=menu0011, pixbuf=pixbuf,
callback=lambda a: self.__open_terminal(uri))
pixbuf = icon_manager.retrieve_icon(u'stock_open',
gtk.STOCK_OPEN)
self.__appendMenuItem(label=u'Browse...', pixbuf=pixbuf,
callback=lambda a: self.__open_file_browser(uri))
self.__appendSeperator()
self.__appendMenuItem(stock=gtk.STOCK_CUT, sensitive=False)
self.__appendMenuItem(stock=gtk.STOCK_COPY, sensitive=False)
if is_dir:
self.__appendMenuItem(stock=gtk.STOCK_PASTE, sensitive=False)
self.__appendSeperator()
self.__appendMenuItem(menu0008, sensitive=False)
self.__appendSeperator()
self.__appendMenuItem(stock=gtk.STOCK_DELETE,
callback=lambda a: self.__unlink(uri))
pixbuf = None
if icon_manager.theme.has_icon(u'gconf-editor'):
pixbuf = icon_manager.theme.load_icon(u'gconf-editor',
16, gtk.ICON_LOOKUP_USE_BUILTIN)
self.__appendSeperator()
self.__appendMenuItem(label=menu0002, pixbuf=pixbuf,
callback=lambda a: self.__display_settings())
pixbuf = None
icon_manager = None
self.popup(None, None, None, event.button, event.time)
def transfer(self, overwrite, cancel_func):
if cancel_func:
self._cancel_func = cancel_func
if overwrite:
mode = gnomevfs.XFER_OVERWRITE_MODE_REPLACE
else:
mode = gnomevfs.XFER_OVERWRITE_MODE_SKIP
log.debug("Transfering File %s -> %s" % (self._source, self._dest))
# recursively create all parent dirs if needed
parent = str(self._dest.parent)
if not gnomevfs.exists(parent):
d = FileImpl(None, impl=self._dest.parent)
d.make_directory_and_parents()
# Copy the file
try:
result = gnomevfs.xfer_uri(
source_uri=self._source,
target_uri=self._dest,
xfer_options=gnomevfs.XFER_NEW_UNIQUE_DIRECTORY,
error_mode=gnomevfs.XFER_ERROR_MODE_ABORT,
overwrite_mode=mode,
progress_callback=self._xfer_progress_callback,
)
# FIXME: Check error
return True, FileImpl(None, impl=self._dest)
except gnomevfs.InterruptedError:
return False, None
except Exception, e:
log.warn("File transfer error: %s" % e)
return False, None
def retrieve_new_file_name(uri=None):
"""Get the name of a file to create."""
dialog = gtk.FileChooserDialog(action=gtk.FILE_CHOOSER_ACTION_SAVE)
dialog.add_buttons(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_SAVE, gtk.RESPONSE_OK)
# Default to the users home directory
if uri is None:
uri = files.get_user_home_uri()
dialog.set_current_folder_uri(str(uri))
# Get the response and the URI
response = dialog.run()
file_uri = dialog.get_uri()
dialog.destroy()
if response == gtk.RESPONSE_OK:
if file_uri is not None:
write = True
# Check to be sure if the user wants to overwrite a file
if gnomevfs.exists(file_uri):
response = choice_yes_no(i.file_already_exists, True)
if response == gtk.RESPONSE_NO:
write = False
if write:
# Return the new filename
return file_uri
else:
raise IOError, i.no_file_specified
return None
def file_exists(file): "Checks if a file exists" if file is None: return False return gnomevfs.exists(file)
def thread_update_hash(self):
for f in self.files:
if self.abort:
# cancel button pressed
break
# for progress
self.current_file = os.path.basename(f.filename)
f.real_hash = self.get_file_hash(f.filename)
self.progress_file = self.progress_file + 1
if not f.expected_hash:
# new file in md5
f.status = HASH_OK
else:
#print self.current_file, f.real_hash, f.expected_hash
if f.real_hash.lower() == f.expected_hash.lower():
# matching md5
f.status = HASH_OK
else:
if not f.real_hash:
if gnomevfs.exists(f.filename):
# cannot read file
f.status = HASH_ERROR
else:
# file is missing
f.status = HASH_MISSING
else:
# md5 mismatch
f.status = HASH_DIFFERENT
# stop progress
self.progress_total_bytes = 0
def set_repository(self, uri=None, force=False):
"""Sets the repository to be viewed.
@param uri: The URI to set the repository to.
@type uri: a gnomevfs.URI
@param force: Should the repository be forced to refresh.
@type force: a boolean
@raise ValueError: If the URI passed does not exist, or if the URI does
not point to a directory.
"""
# Set the URI to the user's home directory if no URI was passed
if uri is None:
uri = self.get_settings().get_repository()
# Error if the file passed does not exist or is not a directory
if not gnomevfs.exists(uri):
raise ValueError, err0001
directory = gnomevfs.get_file_info(uri)
if not files.is_dir(directory):
raise ValueError, err0001
# Do nothing if the repository passed is the current repository and
# the set was not forced
if not force and str(uri) == str(self.get_repository()):
return
# Record what the default repository is in the settings
self.get_settings().set_repository(uri)
self.__tree_view.set_repository(uri)
def unlink(self, uri):
"""Deletes the specified URI.
@param uri: The URI to delete.
@type uri: a gnomevfs.URI
"""
# Be sure the file exists then delete it
if gnomevfs.exists(uri):
file_info = gnomevfs.get_file_info(uri)
# Double check the user wants to delete the file
response = dialogs.choice_ok_cancel(fmt0001 % str(uri), True)
if response == gtk.RESPONSE_OK:
try:
if files.is_dir(file_info):
self.__remove_directory(uri)
else:
gnomevfs.unlink(uri)
except Exception, e:
dialogs.error(fmt0002 % e)
self.refresh()
def do_reload(self):
self._places = PlacesManager.static_places[:]
try:
for line in file(self._bookmarks_path):
line = line.strip()
if " " in line:
uri, name = line.split(" ", 1)
else:
uri = line
path = urllib.splittype(uri)[1]
name = urllib.unquote(os.path.split(path)[1])
try:
if not gnomevfs.exists(uri):
continue
# Protect against a broken bookmarks file
except TypeError:
continue
mime = gnomevfs.get_mime_type(uri) or ""
icon = gnome.ui.icon_lookup(icon_theme, thumb_factory, uri, mime, 0)[0]
self._places.append((uri, name, mime, icon))
except IOError, err:
print "Error loading GTK bookmarks:", err
def __import_bookmark(self, dict):
needed_fields = [u'Abrir fichero', u'Abrir url', u'Fichero inicio', u'Url inicio']
print "---------------------------------"
print dict
print repr(dict)
print "----------------------------------"
for field in needed_fields:
if dict.has_key(field) == False:
self.__error_importing("Falta el campo %s en el fichero" % field)
return None
bookmark = {"name" : dict["Nombre servicio"]}
if dict[u"Abrir fichero"] == "1" :
bookmark["file"] = True
try:
if gnomevfs.exists(dict["Fichero inicio"]) == 1:
tmp_file = dict["Fichero inicio"]
if tmp_file.startswith("file://"):
bookmark["uri"] = tmp_file
else:
bookmark["uri"] = "file://" + dict["Fichero inicio"]
else:
bookmark["uri"] = None
except:
bookmark["uri"] = None
else:
bookmark["file"] = False
bookmark["uri"] = dict["Url inicio"]
return bookmark
def thread_update_hash(self): for f in self.files: if self.abort: # cancel button pressed break # for progress self.current_file = os.path.basename(f.filename) f.real_hash = self.get_file_hash(f.filename) self.progress_file=self.progress_file+1 if len(f.expected_hash) == 0: # new file in md5 f.status = HASH_OK else: #print self.current_file, f.real_hash, f.expected_hash if f.real_hash.lower() == f.expected_hash.lower(): # matching md5 f.status = HASH_OK else: if not f.real_hash: if gnomevfs.exists(f.filename): # cannot read file f.status = HASH_ERROR else: # file is missing f.status = HASH_MISSING else: # md5 mismatch f.status = HASH_DIFFERENT # stop progress self.progress_total_bytes=0
def set_destination_filename(self, name):
# if it exists and its a directory then transfer into that dir
# with the new filename
if gnomevfs.exists(self._dest):
info = gnomevfs.get_file_info(self._dest, gnomevfs.FILE_INFO_DEFAULT)
if info.type == gnomevfs.FILE_TYPE_DIRECTORY:
# append the new filename
self._dest = self._dest.append_file_name(name)
def is_valid(self): """ Checks if the represented file still exists returns 0 if it does not exist """ uri = self.get_uri() from gnomevfs import exists return exists(uri)
def init(self):
self.encoders = {
'audio/x-vorbis': self.add_oggvorbis_encoder,
'audio/x-flac': self.add_flac_encoder,
'audio/x-wav': self.add_wav_encoder,
'audio/mpeg': self.add_mp3_encoder,
'audio/x-m4a': self.add_aac_encoder,
'gst-profile': self.add_audio_profile,
}
self.add_command('audiorate')
self.add_command('audioresample')
self.add_command('audioconvert')
# audio resampling support
if self.output_resample:
self.add_command('audio/x-raw-int,rate=%d' % self.resample_rate)
self.add_command('audioresample')
self.add_command('audioconvert')
if self.force_mono:
self.add_command('audio/x-raw-int,channels=1')
self.add_command('audioconvert')
encoder = self.encoders[self.output_type]()
if not encoder:
# TODO: is this used ?
# TODO: add proper error management when an encoder cannot be created
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK,
_("Cannot create a decoder for \'%s\' format.") % \
self.output_type)
dialog.run()
dialog.hide()
return
self.add_command(encoder)
uri = gnomevfs.URI(self.output_filename)
dirname = uri.parent
if dirname and not gnomevfs.exists(dirname):
log('Creating folder: \'%s\'' % dirname)
if not vfs_makedirs(str(dirname)):
# TODO add better error management
dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL,
gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK,
_("Cannot create \'%s\' folder.") % \
dirname)
dialog.run()
dialog.hide()
return
self.add_command('%s location="%s"' % (
gstreamer_sink, encode_filename(self.output_filename)))
if self.overwrite and vfs_exists(self.output_filename):
log('overwriting \'%s\'' % self.output_filename)
vfs_unlink(self.output_filename)
def make_directory_and_parents(self):
dirs = []
directory = self._URI
exists = gnomevfs.exists(self._URI)
while not exists:
dirs.append(directory)
directory = directory.parent
exists = gnomevfs.exists(directory)
dirs.reverse()
for d in dirs:
log.debug("Making directory %s" % d)
gnomevfs.make_directory(
str(d),
gnomevfs.PERM_USER_ALL
| gnomevfs.PERM_GROUP_READ
| gnomevfs.PERM_GROUP_EXEC
| gnomevfs.PERM_OTHER_READ
| gnomevfs.PERM_OTHER_EXEC,
)
def edit_file_name(self, widget, path, new_text):
current_dir = self.flist.get_current_dir()
#root_iter = self.treestore.get_iter_first()
file_iter = self.treestore.get_iter_from_string(path)
tuple_path = self.treestore.get_path(file_iter)
old_file_name = self.treestore.get_value(file_iter, 1)
file_dir = current_dir
# for i in tuple_path[1:-1]:
# root_iter = self.treestore.iter_nth_child(root_iter, i)
# file_dir += '/' + self.treestore.get_value(root_iter, 1)
for i in range(1, len(tuple_path)):
dir_iter = self.treestore.get_iter(tuple_path[0:i])
file_dir = os.path.join(file_dir, self.treestore.get_value(dir_iter, 1))
if new_text != old_file_name:
old_file_uri = os.path.join(file_dir, old_file_name)
new_file_uri = os.path.join(file_dir, new_text)
if gnomevfs.exists(new_file_uri):
secondary_text = _("A file with the same name already exists. Please use a different name.")
main_text = _("<b>File already exists.</b>")
error = ErrorDialog(main_text, secondary_text)
error_return = error.run()
if error_return == gtk.RESPONSE_DELETE_EVENT:
error.destroy()
return
elif error_return == 1:
error.destroy()
return
old_file_info = gnomevfs.get_file_info(old_file_uri)
old_file_info.name = new_text
gnomevfs.set_file_info(old_file_uri, old_file_info,
gnomevfs.SET_FILE_INFO_NAME)
self.treestore.set_value(file_iter, 1, new_text)
self.refresh()
# Search for the row of the renamed file and select it
def search_new_file(model, path, iter, new_text):
file_name = model.get_value(iter, 1)
if file_name == new_text:
selection = self.treeview.get_selection()
selection.select_iter(iter)
return True
self.treestore.foreach(search_new_file, new_text)
def open_file_browser(self, uri):
"""Opens a file browser at the specified location."""
message = None
if not gnomevfs.exists(uri):
message = fmt0003 % uri
elif not uri.is_local:
message = fmt0004 % uri
if message is not None:
dialogs.error(message)
return
local_path = uri.path
app = gnomevfs.URI(self.get_settings().get_file_browser()).path
args = self.get_settings().get_browser_arguments()
os.spawnlp(os.P_NOWAIT, app, app, args % local_path)
def init(self):
self.encoders = {
'audio/x-vorbis': self.add_oggvorbis_encoder,
'audio/x-flac': self.add_flac_encoder,
'audio/x-wav': self.add_wav_encoder,
'audio/mpeg': self.add_mp3_encoder,
'audio/x-m4a': self.add_aac_encoder,
'audio/ogg; codecs=opus': self.add_opus_encoder,
'gst-profile': self.add_audio_profile,
}
self.add_command('audiorate tolerance=10000000')
self.add_command('audioconvert')
self.add_command('audioresample')
# audio resampling support
if self.output_resample:
self.add_command('audio/x-raw-int,rate=%d' % self.resample_rate)
self.add_command('audioconvert')
self.add_command('audioresample')
if self.force_mono:
self.add_command('audio/x-raw-int,channels=1')
self.add_command('audioconvert')
encoder = self.encoders[self.output_type]()
if not encoder:
# TODO: is this used ?
# TODO: add proper error management when an encoder cannot be created
show_error(
_('Error', "Cannot create a decoder for \'%s\' format.") %
self.output_type)
return
self.add_command(encoder)
uri = gnomevfs.URI(self.output_filename)
dirname = uri.parent
if dirname and not gnomevfs.exists(dirname):
log('Creating folder: \'%s\'' % dirname)
if not vfs_makedirs(str(dirname)):
show_error('Error',
_("Cannot create \'%s\' folder.") % dirname)
return
self.add_command(
'%s location="%s"' %
(gstreamer_sink, encode_filename(self.output_filename)))
def init(self):
self.encoders = {
'audio/x-vorbis': self.add_oggvorbis_encoder,
'audio/x-flac': self.add_flac_encoder,
'audio/x-wav': self.add_wav_encoder,
'audio/mpeg': self.add_mp3_encoder,
'audio/x-m4a': self.add_aac_encoder,
'audio/ogg; codecs=opus': self.add_opus_encoder,
'gst-profile': self.add_audio_profile,
}
self.add_command('audiorate')
self.add_command('audioconvert')
self.add_command('audioresample')
# audio resampling support
if self.output_resample:
self.add_command('audio/x-raw-int,rate=%d' % self.resample_rate)
self.add_command('audioconvert')
self.add_command('audioresample')
if self.force_mono:
self.add_command('audio/x-raw-int,channels=1')
self.add_command('audioconvert')
encoder = self.encoders[self.output_type]()
if not encoder:
# TODO: is this used ?
# TODO: add proper error management when an encoder cannot be created
show_error(_('Error', "Cannot create a decoder for \'%s\' format.") %
self.output_type)
return
self.add_command(encoder)
uri = gnomevfs.URI(self.output_filename)
dirname = uri.parent
if dirname and not gnomevfs.exists(dirname):
log('Creating folder: \'%s\'' % dirname)
if not vfs_makedirs(str(dirname)):
show_error('Error', _("Cannot create \'%s\' folder.") % dirname)
return
self.add_command('%s location="%s"' % (
gstreamer_sink, encode_filename(self.output_filename)))
if self.overwrite and vfs_exists(self.output_filename):
log('overwriting \'%s\'' % beautify_uri(self.output_filename))
vfs_unlink(self.output_filename)
def set_repository(self, uri=None, force=False):
"""Sets the repository to be viewed."""
# Set the URI to the user's home directory if no URI was passed
if uri is None:
uri = self.get_settings().get_repository()
# Error if the file passed does not exist or is not a directory
if not gnomevfs.exists(uri):
raise ValueError, err0001
directory = gnomevfs.get_file_info(uri)
if not files.is_dir(directory):
raise ValueError, err0001
# Do nothing if the repository passed is the current repository and
# the set was not forced
if not force and str(uri) == str(self.get_repository()):
return
# Record what the default repository is in the settings
self.get_settings().set_repository(uri)
self.__tree_view.set_repository(uri)
def retrieve_new_file_name(uri=None):
"""Get the name of a file to create.
@param uri: The URI of the folder to begin in
@type uri: a gnomevfs.URI
@raise IOError: if there was a problem retrieving the file URI
"""
dialog = gtk.FileChooserDialog(action=gtk.FILE_CHOOSER_ACTION_SAVE)
dialog.add_buttons(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_ADD, gtk.RESPONSE_OK)
# Default to the users home directory
if uri is None:
uri = files.get_user_home_uri()
dialog.set_current_folder_uri(str(uri))
# Get the response and the URI
response = dialog.run()
file_uri = dialog.get_uri()
dialog.destroy()
if response == gtk.RESPONSE_OK:
if file_uri is not None:
write = True
# Check to be sure if the user wants to overwrite a file
if gnomevfs.exists(file_uri):
response = choice_yes_no(msg0006, True)
if response == gtk.RESPONSE_NO:
write = False
if write:
# Return the new filename
return file_uri
else:
raise IOError, err0006
return None
def vfs_rename(original, newname):
"""Rename a gnomevfs file"""
uri = gnomevfs.URI(newname)
dirname = uri.parent
if dirname and not gnomevfs.exists(dirname):
log('Creating folder: \'%s\'' % dirname)
if not vfs_makedirs(str(dirname)):
show_error(_('Cannot create folder!'), unquote_filename(dirname.path))
return 'cannot-create-folder'
try:
gnomevfs.xfer_uri(gnomevfs.URI(original), uri,
gnomevfs.XFER_REMOVESOURCE,
gnomevfs.XFER_ERROR_MODE_ABORT,
gnomevfs.XFER_OVERWRITE_MODE_ABORT
)
except Exception as error:
# TODO: maybe we need a special case here. If dest folder is unwritable. Just stop.
# or an option to stop all processing.
show_error(_('Error while renaming file!'), '%s: %s' % (beautify_uri(newname), error))
return 'cannot-rename-file'
def vfs_rename(original, newname):
"""Rename a gnomevfs file"""
uri = gnomevfs.URI(newname)
dirname = uri.parent
if dirname and not gnomevfs.exists(dirname):
log('Creating folder: \'%s\'' % dirname)
if not vfs_makedirs(str(dirname)):
show_error(_('Cannot create folder!'),
unquote_filename(dirname.path))
return 'cannot-create-folder'
try:
gnomevfs.xfer_uri(gnomevfs.URI(original), uri,
gnomevfs.XFER_REMOVESOURCE,
gnomevfs.XFER_ERROR_MODE_ABORT,
gnomevfs.XFER_OVERWRITE_MODE_ABORT)
except Exception as error:
# TODO: maybe we need a special case here. If dest folder is unwritable. Just stop.
# or an option to stop all processing.
show_error(_('Error while renaming file!'),
'%s: %s' % (beautify_uri(newname), error))
return 'cannot-rename-file'
def open_terminal(self, uri):
"""Opens a terminal at the specified location.
@param uri: The local URI to open the terminal to.
@type uri: a gnomevfs.URI
"""
message = None
if not gnomevfs.exists(uri):
message = fmt0003 % uri
elif not uri.is_local:
message = fmt0004 % uri
if message is not None:
dialogs.error(message)
return
local_path = uri.path
app = gnomevfs.URI(self.get_settings().get_terminal()).path
args = self.get_settings().get_terminal_arguments()
os.spawnlp(os.P_NOWAIT, app, app, args % local_path)
def load_tree(self, target):
"""
Loads the tree information from the target backup directory
"""
self.treestore.clear()
# Checking if the target directory is local or remote
local = True
try:
if gnomevfs.URI(target).is_local:
target = gnomevfs.get_local_path_from_uri(target)
else:
local = False
except:
pass
self.local = local
self.target = target
# Checking if it is a readable directory
if local:
if not (os.path.exists(target) and os.path.isdir(target)
and os.access(target, os.R_OK | os.X_OK)):
self.treestore.append(
None, ["Error: backups directory does not exist!"])
self.target = False
else:
if not (gnomevfs.exists(target)
and gnomevfs.get_file_info(target).type == 2):
self.treestore.append(
None, ["Error: backups directory does not exist!"])
self.target = False
# Get list of backup directories
r = re.compile(
r"^(\d{4})-(\d{2})-(\d{2})_(\d{2})[\:\.](\d{2})[\:\.](\d{2})\.\d+\..*?\.(.+)$"
)
listing = []
if local and self.target:
listing = os.listdir(target)
listing = filter(r.search, listing)
elif self.target:
try:
d = gnomevfs.open_directory(target)
listing = []
for f in d:
if f.type == 2 and f.name != "." and f.name != ".." and r.search(
f.name):
listing.append(f.name)
except:
pass
# Check if these directories are complete and remove from the list those that are not
for adir in listing[:]:
if not gnomevfs.exists(self.target + "/" + adir + "/ver"):
listing.remove(adir)
continue
else:
if str(
gnomevfs.read_entire_file(self.target + "/" + adir +
"/ver"))[:3] != "1.4":
listing.remove(adir)
continue
listing.sort()
listing.reverse()
self.vtree = {}
if listing == []:
self.treestore.append(
None, ["Error: no backups found in the target directory"])
self.target = False
else:
for base in listing:
if str(gnomevfs.read_entire_file(target + "/" + base +
"/ver"))[:3] == "1.4":
self.vtree[base] = str(
gnomevfs.read_entire_file(target + "/" + base +
"/flist")).split("\000")
else:
self.vtree[base] = str(
gnomevfs.read_entire_file(target + "/" + base +
"/flist")).split("\n")
self.blist.clear()
for base in listing:
self.blist.append([base])
self.good = False
self.on_selection_change()
if self.target:
self.treestore.append(None, [
"Select any of the available backups to see list of files that can be restored."
])
def vfs_exists(filename):
try:
return gnomevfs.exists(filename)
except:
return False
def is_uri_dir(uri):
if uri is not None and gnomevfs.exists(uri):
file_info = gnomevfs.get_file_info(uri)
return is_dir(file_info)
return False
def exists(uri):
return gnomevfs.exists(gnomevfs.URI(uri))
def new_folder(self, widget):
"""
Create a new folder in the current directory.
@param widget: Reference to the button.
@type widget: A Button object.
"""
sel_model, sel_iter = self.treeview.get_selection().get_selected()
dir_iter = None
new_file_dir = self.flist.get_current_dir()
path = None
# If some selection exists
if sel_iter != None:
path = self.treestore.get_path(sel_iter)
if len(path) == 1: # New file will be created in current folder
dir_iter = None
else:
dir_iter = self.treestore.get_iter(path[0:len(path) - 1])
for i in range(1, len(path)):
dir_iter = self.treestore.get_iter(path[0:i])
iter_value = self.treestore.get_value(dir_iter, 1)
new_file_dir = os.path.join(new_file_dir, iter_value)
#Create file
i = 1
new_file_name = _("New Folder")
new_file_uri = os.path.join(new_file_dir, new_file_name)
while gnomevfs.exists(new_file_uri):
new_file_uri = \
os.path.join(new_file_dir, new_file_name + " " + str(i))
i += 1
old_file_dir = self.flist.get_current_dir()
self.flist.set_current_dir(new_file_dir)
try:
files = self.flist.get_files(False)
gnomevfs.make_directory(new_file_uri, 0755)
except gnomevfs.AccessDeniedError:
main_text = _("<b>You can't create a folder.</b>")
secondary_text = _("You don't have the required permissions to create a folder in this directory.")
error = ErrorDialog(main_text, secondary_text)
error_return = error.run()
if error_return == gtk.RESPONSE_DELETE_EVENT:
error.destroy()
return
elif error_return == 1:
error.destroy()
return
# Verifying if the directory is empty to delete "(Empty)" string.
if len(files) == 0:
if dir_iter == None:
empty_path = (0,)
else:
empty_path = list(path)
empty_path[len(path)-1] = 0
empty_path = tuple(empty_path)
empty_iter = self.treestore.get_iter(empty_path)
self.treestore.remove(empty_iter)
icon = self.treeview.render_icon(gtk.STOCK_DIRECTORY,
gtk.ICON_SIZE_MENU)
name = gnomevfs.URI(new_file_uri).short_name
new_iter = self.treestore.append(dir_iter, [icon, name])
if len(files) == 0 and dir_iter != None:
self.treeview.expand_row(path[0:len(path) - 1], False)
self.flist.set_current_dir(old_file_dir)
path = self.treestore.get_path(new_iter)
self.cell2.set_property('editable', True)
self.treeview.set_cursor_on_cell(path, self.tvcolumn, self.cell2,
start_editing=True)
self.cell2.set_property('editable', False)
def vfs_exists(filename):
try:
return gnomevfs.exists(filename)
except:
return False
def get_file_info(uri):
"""Return the File information if uri exists"""
if uri is not None and gnomevfs.exists(uri):
return gnomevfs.get_file_info(uri)
return False
def _open_file(self):
if not self.triedOpen:
self.triedOpen = True
self.fileExists = gnomevfs.exists(self._URI)
