// {{{ loadDirectory() method
public void loadDirectory(
final Object node, String path, final boolean addToHistory, final Runnable delayedAWTTask) {
path = MiscUtilities.constructPath(browser.getDirectory(), path);
VFS vfs = VFSManager.getVFSForPath(path);
Object session = vfs.createVFSSession(path, this);
if (session == null) {
if (delayedAWTTask != null) ThreadUtilities.runInDispatchThread(delayedAWTTask);
return;
}
if (node == null) {
parentDirectories.setListData(new Object[] {new LoadingPlaceholder()});
}
final Object[] loadInfo = new Object[2];
Runnable awtRunnable =
new Runnable() {
public void run() {
browser.directoryLoaded(node, loadInfo, addToHistory);
if (delayedAWTTask != null) delayedAWTTask.run();
}
};
ThreadUtilities.runInBackground(
new ListDirectoryBrowserTask(browser, session, vfs, path, loadInfo, awtRunnable));
} // }}}
public static void registerVFS(String protocol, VFS vfs) {
Log.log(
Log.DEBUG,
VFSManager.class,
"Registered " + vfs.getName() + " filesystem for " + protocol + " protocol");
vfsHash.put(vfs.getName(), vfs);
protocolHash.put(protocol, vfs);
}
private String getPrevOrNextFile(View view, String path, Direction direction) {
if (files == null) files = _getFiles(view);
if (files == null || files.length == 0) return null;
if (path == null) {
path = view.getBuffer().getSymlinkPath();
VFS vfs = VFSManager.getVFSForPath(path);
boolean ignoreCase = ((vfs.getCapabilities() & VFS.CASE_INSENSITIVE_CAP) != 0);
for (int i = 0; i < files.length; i++) {
if (StandardUtilities.compareStrings(files[i], path, ignoreCase) == 0) {
return path;
}
}
if (direction == Direction.NEXT) {
return getFirstFile(view);
} else {
return getLastFile(view);
}
} else {
// -1 so that the last isn't checked
VFS vfs = VFSManager.getVFSForPath(path);
boolean ignoreCase = ((vfs.getCapabilities() & VFS.CASE_INSENSITIVE_CAP) != 0);
if (direction == Direction.NEXT
&& StandardUtilities.compareStrings(files[files.length - 1], path, ignoreCase) == 0) {
// Going forward and already at the last file
return null;
} else if (direction == Direction.PREV
&& StandardUtilities.compareStrings(files[0], path, ignoreCase) == 0) {
// Going backward and already at the first file
return null;
}
for (int i = 0; i < files.length - 1; i++) {
if (StandardUtilities.compareStrings(files[i], path, ignoreCase) == 0) {
if (direction == Direction.NEXT) return files[i + 1];
else {
if (i == 0) return files[files.length - 1];
return files[i - 1];
}
}
}
return null;
}
} // }}}
public static void sendVFSUpdate(VFS vfs, String path, boolean parent) {
if (parent) {
sendVFSUpdate(vfs, vfs.getParentOfPath(path), false);
sendVFSUpdate(vfs, path, false);
} else {
if (path.length() != 1 && (path.endsWith("/") || path.endsWith(java.io.File.separator)))
path = path.substring(0, path.length() - 1);
synchronized (vfsUpdateLock) {
for (int i = 0; i < vfsUpdates.size(); i++) {
VFSUpdate msg = (VFSUpdate) vfsUpdates.get(i);
if (msg.getPath().equals(path)) {
return;
}
}
vfsUpdates.add(new VFSUpdate(path));
if (vfsUpdates.size() == 1) {
VFSManager.runInAWTThread(new SendVFSUpdatesSafely());
}
}
}
}
// {{{ DirectoryEntry constructor
public DirectoryEntry(
String name, String path, String deletePath, int type, long length, boolean hidden) {
this.name = name;
this.path = path;
this.deletePath = deletePath;
this.symlinkPath = path;
this.type = type;
this.length = length;
this.hidden = hidden;
if (path != null) {
// maintain backwards compatibility
VFS vfs = VFSManager.getVFSForPath(path);
canRead = ((vfs.getCapabilities() & READ_CAP) != 0);
canWrite = ((vfs.getCapabilities() & WRITE_CAP) != 0);
}
} // }}}
/**
* 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);
}
}
/**
* 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 sourcePath the source path
* @param targetPath the target path
* @param comp comp The component that will parent error dialog boxes
* @param canStop if true the copy can 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,
String sourcePath,
String targetPath,
Component comp,
boolean canStop)
throws IOException {
VFS sourceVFS = VFSManager.getVFSForPath(sourcePath);
Object sourceSession = sourceVFS.createVFSSession(sourcePath, comp);
if (sourceSession == null) {
Log.log(
Log.WARNING,
VFS.class,
"Unable to get a valid session from " + sourceVFS + " for path " + sourcePath);
return false;
}
VFS targetVFS = VFSManager.getVFSForPath(targetPath);
Object targetSession = targetVFS.createVFSSession(targetPath, comp);
if (targetSession == null) {
Log.log(
Log.WARNING,
VFS.class,
"Unable to get a valid session from " + targetVFS + " for path " + targetPath);
return false;
}
return copy(
progress,
sourceVFS,
sourceSession,
sourcePath,
targetVFS,
targetSession,
targetPath,
comp,
canStop);
} // }}}
/**
* Rebuild the parent view after a directory has been loaded.
*
* @param node
* @param path
* @param directory
*/
public void directoryLoaded(Object node, String path, java.util.List<VFSFile> directory) {
// {{{ If reloading root, update parent directory list
if (node == null) {
DefaultListModel parentList = new DefaultListModel();
String parent = path;
for (; ; ) {
VFS _vfs = VFSManager.getVFSForPath(parent);
VFSFile file = null;
if (_vfs instanceof FileVFS) {
Object session = _vfs.createVFSSession(path, browser);
try {
file = _vfs._getFile(session, parent, browser);
if (file != null) {
file.setName(_vfs.getFileName(parent));
}
} catch (IOException e) {
Log.log(Log.ERROR, this, e, e);
}
}
if (file == null) {
// create a DirectoryEntry manually
// instead of using _vfs._getFile()
// since so many VFS's have broken
// implementations of this method
file =
new VFSFile(_vfs.getFileName(parent), parent, parent, VFSFile.DIRECTORY, 0L, false);
}
/*parentList.insertElementAt(new VFSFile(
_vfs.getFileName(parent),
parent,parent,
VFSFile.DIRECTORY,
0L,false),0);*/
parentList.insertElementAt(file, 0);
String newParent = _vfs.getParentOfPath(parent);
if (newParent == null || MiscUtilities.pathsEqual(parent, newParent)) break;
else parent = newParent;
}
parentDirectories.setModel(parentList);
int index = parentList.getSize() - 1;
parentDirectories.setSelectedIndex(index);
parentDirectories.ensureIndexIsVisible(index);
} // }}}
table.setDirectory(VFSManager.getVFSForPath(path), node, directory, tmpExpanded);
} // }}}