public int compare(VFSFile file1, VFSFile file2) {
if (!sortMixFilesAndDirs) {
if (file1.getType() != file2.getType()) return file2.getType() - file1.getType();
}
return StandardUtilities.compareStrings(file1.getName(), file2.getName(), sortIgnoreCase);
}
/**
* Copy a file to another using VFS.
*
* @param progress the progress observer. It could be null if you don't want to monitor progress.
* If not null you should probably launch this command in a WorkThread
* @param sourceVFS the source VFS
* @param sourceSession the VFS session
* @param sourcePath the source path
* @param targetVFS the target VFS
* @param targetSession the target session
* @param targetPath the target path
* @param comp comp The component that will parent error dialog boxes
* @param canStop could this copy be stopped ?
* @return true if the copy was successful
* @throws IOException IOException If an I/O error occurs
* @since jEdit 4.3pre3
*/
public static boolean copy(
ProgressObserver progress,
VFS sourceVFS,
Object sourceSession,
String sourcePath,
VFS targetVFS,
Object targetSession,
String targetPath,
Component comp,
boolean canStop)
throws IOException {
if (progress != null) progress.setStatus("Initializing");
InputStream in = null;
OutputStream out = null;
try {
VFSFile sourceVFSFile = sourceVFS._getFile(sourceSession, sourcePath, comp);
if (sourceVFSFile == null) throw new FileNotFoundException(sourcePath);
if (progress != null) {
progress.setMaximum(sourceVFSFile.getLength());
}
VFSFile targetVFSFile = targetVFS._getFile(targetSession, targetPath, comp);
if (targetVFSFile.getType() == VFSFile.DIRECTORY) {
if (targetVFSFile.getPath().equals(sourceVFSFile.getPath())) return false;
targetPath = MiscUtilities.constructPath(targetPath, sourceVFSFile.getName());
}
in =
new BufferedInputStream(
sourceVFS._createInputStream(sourceSession, sourcePath, false, comp));
out =
new BufferedOutputStream(targetVFS._createOutputStream(targetSession, targetPath, comp));
boolean copyResult = IOUtilities.copyStream(IOBUFSIZE, progress, in, out, canStop);
VFSManager.sendVFSUpdate(targetVFS, targetPath, true);
return copyResult;
} finally {
IOUtilities.closeQuietly(in);
IOUtilities.closeQuietly(out);
}
}
// {{{ recursive listFiles() method
private void listFiles(
Object session,
Collection<String> stack,
List<String> files,
String directory,
VFSFileFilter filter,
boolean recursive,
Component comp,
boolean skipBinary,
boolean skipHidden)
throws IOException {
String resolvedPath = directory;
if (recursive && !MiscUtilities.isURL(directory)) {
resolvedPath = MiscUtilities.resolveSymlinks(directory);
/*
* If looking at a symlink, do not traverse the
* resolved path more than once.
*/
if (!directory.equals(resolvedPath)) {
if (stack.contains(resolvedPath)) {
Log.log(Log.ERROR, this, "Recursion in listFiles(): " + directory);
return;
}
stack.add(resolvedPath);
}
}
Thread ct = Thread.currentThread();
WorkThread wt = null;
if (ct instanceof WorkThread) {
wt = (WorkThread) ct;
}
VFSFile[] _files = _listFiles(session, directory, comp);
if (_files == null || _files.length == 0) return;
for (int i = 0; i < _files.length; i++) {
if (wt != null && wt.isAborted()) break;
VFSFile file = _files[i];
if (skipHidden && (file.isHidden() || MiscUtilities.isBackup(file.getName()))) continue;
if (!filter.accept(file)) continue;
if (file.getType() == VFSFile.DIRECTORY || file.getType() == VFSFile.FILESYSTEM) {
if (recursive) {
String canonPath = _canonPath(session, file.getPath(), comp);
listFiles(
session, stack, files, canonPath, filter, recursive, comp, skipBinary, skipHidden);
}
} else // It's a regular file
{
if (skipBinary) {
try {
if (file.isBinary(session)) {
Log.log(Log.NOTICE, this, file.getPath() + ": skipped as a binary file");
continue;
}
} catch (IOException e) {
Log.log(Log.ERROR, this, e);
// may be not binary...
}
}
files.add(file.getPath());
}
}
} // }}}
