null permitted).
* @param filename the file name.
*
* @return A new file object.
*/
public File createFileObject(File dir, String filename)
{
return new File(dir, filename);
}
/**
* Creates a new file object from the specified path.
*
* @param path the path.
*
* @return A new file object.
*/
public File createFileObject(String path)
{
File f = new File(path);
if (isFileSystemRoot(f))
f = this.createFileSystemRoot(f);
return f;
}
/**
* DOCUMENT ME!
*
* @param f DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
protected File createFileSystemRoot(File f)
{
File[] roots = File.listRoots();
if (roots == null)
return null;
return roots[0];
}
/**
* Creates a new folder with a unique name in the specified directory and
* returns a {@link File} object representing the new directory.
*
* @param containingDir the directory to contain the new folder
* (null not permitted).
*
* @return A {@link File} object representing the new directory.
*
* @throws IOException if an exception occurs while creating the new
* directory.
*/
public abstract File createNewFolder(File containingDir)
throws IOException;
/**
* DOCUMENT ME!
*
* @param parent DOCUMENT ME!
* @param fileName DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public File getChild(File parent, String fileName)
{
// FIXME: Handle the case when parent and child are special folders.
return new File(parent, fileName);
}
/**
* Returns the default directory.
*
* @return The default directory.
*/
public File getDefaultDirectory()
{
return getHomeDirectory();
}
/**
* Returns an array containing the files in the given directory. The
* useFileHiding controls whether or not hidden files are
* included in the result.
*
* @param dir the directory (if null
* @param useFileHiding a flag that controls whether or not hidden files are
* included in the result (pass in true to
* exclude hidden files).
*
* @return The files in the given directory (possibly null).
*/
public File[] getFiles(File dir, boolean useFileHiding)
{
if (dir == null || dir.listFiles() == null)
return null;
File[] files = dir.listFiles();
if (! useFileHiding)
return files;
ArrayList trim = new ArrayList();
for (int i = 0; i < files.length; i++)
if (! files[i].isHidden())
trim.add(files[i]);
File[] value = (File[]) trim.toArray(new File[trim.size()]);
return value;
}
/**
* Returns a default {@link FileSystemView} appropriate for the platform.
*
* @return A default {@link FileSystemView} appropriate for the platform.
*/
public static FileSystemView getFileSystemView()
{
if (defaultFileSystemView == null)
{
// FIXME: We need to support other file systems too.
defaultFileSystemView = new UnixFileSystemView();
}
return defaultFileSystemView;
}
/**
* Returns the home directory for the current user.
*
* @return The home directory for the current user.
*/
public File getHomeDirectory()
{
return createFileObject(System.getProperty("user.home"));
}
/**
* Returns the parent directory for the given file/directory.
*
* @param f the file/directory.
*
* @return The parent directory (or null if there is no parent
* directory).
*/
public File getParentDirectory(File f)
{
if (f == null)
return null;
return f.getParentFile();
}
/**
* Returns an array containing the file system roots. On Unix-like platforms,
* this array will contain just a single item ("/"), while other platforms
* may return multiple roots.
*
* This method is implemented to return null, subclasses must
* override this method.
*
* @return An array containing the file system roots.
*/
public File[] getRoots()
{
// subclass
return null;
}
/**
* Returns the name of a file as it would be displayed by the underlying
* system.
*
* @param f the file.
*
* @return the name of a file as it would be displayed by the underlying
* system
*
* @specnote The specification suggests that the information here is
* fetched from a ShellFolder class. This seems to be a non public
* private file handling class. We simply return File.getName()
* here and leave special handling to subclasses.
*/
public String getSystemDisplayName(File f)
{
String name = null;
if (f != null)
name = f.getName();
return name;
}
/**
* Returns the icon that would be displayed for the given file by the
* underlying system. This implementation returns null,
* subclasses must override.
*
* @param f the file.
*
* @return null.
*/
public Icon getSystemIcon(File f)
{
return null;
}
/**
* Returns the type description of a file that would be displayed by the
* underlying system. This implementation returns null,
* subclasses must override.
*
* @param f the file.
*
* @return null.
*/
public String getSystemTypeDescription(File f)
{
return null;
}
/**
* DOCUMENT ME!
*
* @param dir DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public boolean isComputerNode(File dir)
{
return false;
}
/**
* Returns true if the given directory represents a disk
* drive, and false otherwise. This default implementation
* always returns false.
*
* @param dir the directory.
*
* @return false.
*/
public boolean isDrive(File dir)
{
return false;
}
/**
* Returns true if f is a file or directory, and
* false otherwise.
*
* @param f the file/directory.
*
* @return true if f is a file or directory, and
* false otherwise.
*/
public boolean isFileSystem(File f)
{
return (f.isFile() || f.isDirectory());
}
/**
* Returns true if the given directory is a file system root,
* and false otherwise.
*
* @param dir the directory.
*
* @return true if the given directory is a file system root,
* and false otherwise.
*/
public boolean isFileSystemRoot(File dir)
{
File[] roots = File.listRoots();
if (roots == null || dir == null)
return false;
String filename = dir.getAbsolutePath();
for (int i = 0; i < roots.length; i++)
if (roots[i].getAbsolutePath().equals(filename))
return true;
return false;
}
/**
* Returns true if the given directory represents a floppy
* drive, and false otherwise. This default implementation
* always returns false.
*
* @param dir the directory.
*
* @return false.
*/
public boolean isFloppyDrive(File dir)
{
return false;
}
/**
* Returns true if the given file is hidden, and
* false otherwise.
*
* @param f the file.
*
* @return true if the given file is hidden, and
* false otherwise.
*/
public boolean isHiddenFile(File f)
{
return f.isHidden();
}
/**
* Returns true if folder is the parent of
* file, and false otherwise.
*
* @param folder the folder (null not permitted).
* @param file the file (null not permitted).
*
* @return true if folder is the parent of
* file, and false otherwise.
*/
public boolean isParent(File folder, File file)
{
File parent = file.getParentFile();
if (parent == null)
return false;
return folder.equals(parent);
}
/**
* DOCUMENT ME!
*
* @param f DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public boolean isRoot(File f)
{
// These are not file system roots.
return false;
}
/**
* Returns true if the file is traversable, and
* false otherwise. Here, all directories are considered
* traversable, and files are considered non-traversable.
*
* @param f the file or directory (null not permitted).
*
* @return true if the file is traversable, and
* false otherwise.
*/
public Boolean isTraversable(File f)
{
// Tested. A directory where the user has no permission to rwx is still
// traversable. (No files are listed when you traverse the directory)
// My best guess is that as long as it's a directory, the file is
// traversable.
return Boolean.valueOf(f.isDirectory());
}
}