/**
* Updates this window's title to show currently active folder and window number. This method is
* called by this class and WindowManager.
*/
public void updateWindowTitle() {
// Update window title
String title = activeTable.getFolderPanel().getCurrentFolder().getAbsolutePath();
// Add the application name to window title on all OSs except MAC
if (!OsFamily.MAC_OS_X.isCurrent()) title += " - muCommander";
java.util.List<MainFrame> mainFrames = WindowManager.getMainFrames();
if (mainFrames.size() > 1) title += " [" + (mainFrames.indexOf(this) + 1) + "]";
setTitle(title);
// Use new Window decorations introduced in Mac OS X 10.5 (Leopard)
if (OsFamily.MAC_OS_X.isCurrent() && OsVersion.MAC_OS_X_10_5.isCurrentOrHigher()) {
// Displays the document icon in the window title bar, works only for local files
AbstractFile currentFolder = activeTable.getFolderPanel().getCurrentFolder();
Object javaIoFile;
if (currentFolder.getURL().getScheme().equals(FileProtocols.FILE)) {
// If the current folder is an archive entry, display the archive file, this is the closest
// we can get
// with a java.io.File
if (currentFolder.hasAncestor(AbstractArchiveEntryFile.class))
javaIoFile = currentFolder.getParentArchive().getUnderlyingFileObject();
else javaIoFile = currentFolder.getUnderlyingFileObject();
} else {
// If the current folder is not a local file, use the special /Network directory which is
// sort of
// 'Network Neighborhood'.
javaIoFile = new java.io.File("/Network");
}
// Note that for some strange reason (looks like a bug), setting the property to null won't
// remove
// the previous icon.
getRootPane().putClientProperty("Window.documentFile", javaIoFile);
}
}
/**
* Creates a new ProxyFile using the given file to delegate AbstractFile method calls to.
*
* @param file the file to be proxied
*/
public ProxyFile(AbstractFile file) {
super(file.getURL());
this.file = file;
}
@Override
public FileURL getURL() {
return file.getURL();
}
/**
* Moves recursively the given file or folder.
*
* @param file the file or folder to move
* @param recurseParams destination folder where the given file will be moved (null for top level
* files)
* @return <code>true</code> if the file has been moved completly (copied + deleted).
*/
@Override
protected boolean processFile(AbstractFile file, Object recurseParams) {
// Stop if interrupted
if (getState() == State.INTERRUPTED) return false;
// Destination folder
AbstractFile destFolder = recurseParams == null ? baseDestFolder : (AbstractFile) recurseParams;
// Is current file at the base folder level ?
boolean isFileInBaseFolder = files.contains(file);
// Determine filename in destination
String originalName = file.getName();
String destFileName = isFileInBaseFolder && newName != null ? newName : originalName;
// create destination AbstractFile instance
AbstractFile destFile = createDestinationFile(destFolder, destFileName);
if (destFile == null) return false;
// Do not follow symlink, simply delete it and return
if (file.isSymlink()) {
do { // Loop for retry
try {
file.delete();
return true;
} catch (IOException e) {
LOGGER.debug("IOException caught", e);
int ret =
showErrorDialog(
errorDialogTitle, Translator.get("cannot_delete_file", file.getAbsolutePath()));
// Retry loops
if (ret == RETRY_ACTION) {
continue;
}
// Cancel, skip or close dialog returns false
return false;
}
} while (true);
}
destFile = checkForCollision(file, destFolder, destFile, renameMode);
if (destFile == null) return false;
// Let's try to rename the file using AbstractFile#renameTo() whenever possible, as it is more
// efficient
// than moving the file manually.
//
// Do not attempt to rename the file in the following cases:
// - destination has to be appended
// - file schemes do not match (at the time of writing, no filesystem supports mixed scheme
// renaming)
// - if the 'rename' operation is not supported
// Note: we want to avoid calling AbstractFile#renameTo when we know it will fail, as it
// performs some costly
// I/O bound checks and ends up throwing an exception which also comes at a cost.
if (!append
&& file.getURL().schemeEquals(destFile.getURL())
&& file.isFileOperationSupported(FileOperation.RENAME)) {
try {
file.renameTo(destFile);
return true;
} catch (IOException e) {
// Fail silently: renameTo might fail under normal conditions, for instance for local files
// which are
// not located on the same volume.
LOGGER.debug(
"Failed to rename " + file + " into " + destFile + " (not necessarily an error)", e);
}
}
// Rename couldn't be used or didn't succeed: move the file manually
// Move the directory and all its children recursively, by copying files to the destination and
// then deleting them.
if (file.isDirectory()) {
// create the destination folder if it doesn't exist
if (!(destFile.exists() && destFile.isDirectory())) {
do { // Loop for retry
try {
destFile.mkdir();
} catch (IOException e) {
int ret =
showErrorDialog(
errorDialogTitle,
Translator.get("cannot_create_folder", destFile.getAbsolutePath()));
// Retry loops
if (ret == RETRY_ACTION) {
continue;
}
// Cancel, skip or close dialog returns false
return false;
}
break;
} while (true);
}
// move each file in this folder recursively
do { // Loop for retry
try {
AbstractFile subFiles[] = file.ls();
boolean isFolderEmpty = true;
for (AbstractFile subFile : subFiles) {
// Return now if the job was interrupted, so that we do not attempt to delete this
// folder
if (getState() == State.INTERRUPTED) return false;
// Notify job that we're starting to process this file (needed for recursive calls to
// processFile)
nextFile(subFile);
if (!processFile(subFile, destFile)) isFolderEmpty = false;
}
// Only when finished with folder, set destination folder's date to match the original
// folder one
if (destFile.isFileOperationSupported(FileOperation.CHANGE_DATE)) {
try {
destFile.changeDate(file.getDate());
} catch (IOException e) {
LOGGER.debug("failed to change the date of " + destFile, e);
// Fail silently
}
}
// If one file failed to be moved, return false (failure) since this folder could not be
// moved totally
if (!isFolderEmpty) return false;
} catch (IOException e) {
// file.ls() failed
int ret =
showErrorDialog(
errorDialogTitle, Translator.get("cannot_read_folder", file.getName()));
// Retry loops
if (ret == RETRY_ACTION) continue;
// Cancel, skip or close dialog returns false
return false;
}
break;
} while (true);
// Return now if the job was interrupted, so that we do not attempt to delete this folder
if (getState() == State.INTERRUPTED) return false;
// finally, delete the empty folder
do { // Loop for retry
try {
file.delete();
return true;
} catch (IOException e) {
int ret =
showErrorDialog(
errorDialogTitle, Translator.get("cannot_delete_folder", file.getAbsolutePath()));
// Retry loops
if (ret == RETRY_ACTION) continue;
// Cancel, skip or close dialog returns false
return false;
}
} while (true);
}
// File is a regular file, move it by copying it to the destination and then deleting it
else {
// if renameTo() was not supported or failed, or if it wasn't possible because of 'append',
// try the hard way by copying the file first, and then deleting the source file.
if (tryCopyFile(file, destFile, append, errorDialogTitle)
&& getState() != State.INTERRUPTED) {
// Delete the source file
do { // Loop for retry
try {
file.delete();
// All OK
return true;
} catch (IOException e) {
LOGGER.debug("IOException caught", e);
int ret =
showErrorDialog(
errorDialogTitle, Translator.get("cannot_delete_file", file.getAbsolutePath()));
// Retry loops
if (ret == RETRY_ACTION) continue;
// Cancel, skip or close dialog returns false
return false;
}
} while (true);
}
return false;
}
}
/** ****************** MuActions support ****************** */
public void add(AbstractFile file) {
addTab(defaultTabsFactory.createTab(file.getURL()));
}