| /* |
| * Copyright 2000-2006 Sun Microsystems, Inc. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Sun designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Sun in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| |
| package sun.awt.shell; |
| |
| import java.awt.Image; |
| import java.awt.Toolkit; |
| import java.io.*; |
| import java.io.FileNotFoundException; |
| import java.util.*; |
| |
| /** |
| * @author Michael Martak |
| * @since 1.4 |
| */ |
| |
| public abstract class ShellFolder extends File { |
| protected ShellFolder parent; |
| |
| /** |
| * Create a file system shell folder from a file |
| */ |
| ShellFolder(ShellFolder parent, String pathname) { |
| super((pathname != null) ? pathname : "ShellFolder"); |
| this.parent = parent; |
| } |
| |
| /** |
| * @return Whether this is a file system shell folder |
| */ |
| public boolean isFileSystem() { |
| return (!getPath().startsWith("ShellFolder")); |
| } |
| |
| /** |
| * This method must be implemented to make sure that no instances |
| * of <code>ShellFolder</code> are ever serialized. If <code>isFileSystem()</code> returns |
| * <code>true</code>, then the object should be representable with an instance of |
| * <code>java.io.File</code> instead. If not, then the object is most likely |
| * depending on some internal (native) state and cannot be serialized. |
| * |
| * @returns a <code>java.io.File</code> replacement object, or <code>null</code> |
| * if no suitable replacement can be found. |
| */ |
| protected abstract Object writeReplace() throws java.io.ObjectStreamException; |
| |
| /** |
| * Returns the path for this object's parent, |
| * or <code>null</code> if this object does not name a parent |
| * folder. |
| * |
| * @return the path as a String for this object's parent, |
| * or <code>null</code> if this object does not name a parent |
| * folder |
| * |
| * @see java.io.File#getParent() |
| * @since 1.4 |
| */ |
| public String getParent() { |
| if (parent == null && isFileSystem()) { |
| return super.getParent(); |
| } |
| if (parent != null) { |
| return (parent.getPath()); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns a File object representing this object's parent, |
| * or <code>null</code> if this object does not name a parent |
| * folder. |
| * |
| * @return a File object representing this object's parent, |
| * or <code>null</code> if this object does not name a parent |
| * folder |
| * |
| * @see java.io.File#getParentFile() |
| * @since 1.4 |
| */ |
| public File getParentFile() { |
| if (parent != null) { |
| return parent; |
| } else if (isFileSystem()) { |
| return super.getParentFile(); |
| } else { |
| return null; |
| } |
| } |
| |
| public File[] listFiles() { |
| return listFiles(true); |
| } |
| |
| public File[] listFiles(boolean includeHiddenFiles) { |
| File[] files = super.listFiles(); |
| |
| if (!includeHiddenFiles) { |
| Vector v = new Vector(); |
| int nameCount = (files == null) ? 0 : files.length; |
| for (int i = 0; i < nameCount; i++) { |
| if (!files[i].isHidden()) { |
| v.addElement(files[i]); |
| } |
| } |
| files = (File[])v.toArray(new File[v.size()]); |
| } |
| |
| return files; |
| } |
| |
| |
| /** |
| * @return Whether this shell folder is a link |
| */ |
| public abstract boolean isLink(); |
| |
| /** |
| * @return The shell folder linked to by this shell folder, or null |
| * if this shell folder is not a link |
| */ |
| public abstract ShellFolder getLinkLocation() throws FileNotFoundException; |
| |
| /** |
| * @return The name used to display this shell folder |
| */ |
| public abstract String getDisplayName(); |
| |
| /** |
| * @return The type of shell folder as a string |
| */ |
| public abstract String getFolderType(); |
| |
| /** |
| * @return The executable type as a string |
| */ |
| public abstract String getExecutableType(); |
| |
| /** |
| * Compares this ShellFolder with the specified ShellFolder for order. |
| * |
| * @see #compareTo(Object) |
| */ |
| public int compareTo(File file2) { |
| if (file2 == null || !(file2 instanceof ShellFolder) |
| || ((file2 instanceof ShellFolder) && ((ShellFolder)file2).isFileSystem())) { |
| |
| if (isFileSystem()) { |
| return super.compareTo(file2); |
| } else { |
| return -1; |
| } |
| } else { |
| if (isFileSystem()) { |
| return 1; |
| } else { |
| return getName().compareTo(file2.getName()); |
| } |
| } |
| } |
| |
| /** |
| * @param getLargeIcon whether to return large icon (ignored in base implementation) |
| * @return The icon used to display this shell folder |
| */ |
| public Image getIcon(boolean getLargeIcon) { |
| return null; |
| } |
| |
| |
| // Static |
| |
| private static ShellFolderManager shellFolderManager; |
| |
| static { |
| Class managerClass = (Class)Toolkit.getDefaultToolkit(). |
| getDesktopProperty("Shell.shellFolderManager"); |
| if (managerClass == null) { |
| managerClass = ShellFolderManager.class; |
| } |
| try { |
| shellFolderManager = |
| (ShellFolderManager)managerClass.newInstance(); |
| } catch (InstantiationException e) { |
| throw new Error("Could not instantiate Shell Folder Manager: " |
| + managerClass.getName()); |
| } catch (IllegalAccessException e) { |
| throw new Error ("Could not access Shell Folder Manager: " |
| + managerClass.getName()); |
| } |
| } |
| |
| /** |
| * Return a shell folder from a file object |
| * @exception FileNotFoundException if file does not exist |
| */ |
| public static ShellFolder getShellFolder(File file) throws FileNotFoundException { |
| if (file instanceof ShellFolder) { |
| return (ShellFolder)file; |
| } |
| if (!file.exists()) { |
| throw new FileNotFoundException(); |
| } |
| return shellFolderManager.createShellFolder(file); |
| } |
| |
| /** |
| * @param key a <code>String</code> |
| * @return An Object matching the string <code>key</code>. |
| * @see ShellFolderManager#get(String) |
| */ |
| public static Object get(String key) { |
| return shellFolderManager.get(key); |
| } |
| |
| /** |
| * Does <code>dir</code> represent a "computer" such as a node on the network, or |
| * "My Computer" on the desktop. |
| */ |
| public static boolean isComputerNode(File dir) { |
| return shellFolderManager.isComputerNode(dir); |
| } |
| |
| /** |
| * @return Whether this is a file system root directory |
| */ |
| public static boolean isFileSystemRoot(File dir) { |
| return shellFolderManager.isFileSystemRoot(dir); |
| } |
| |
| /** |
| * Canonicalizes files that don't have symbolic links in their path. |
| * Normalizes files that do, preserving symbolic links from being resolved. |
| */ |
| public static File getNormalizedFile(File f) throws IOException { |
| File canonical = f.getCanonicalFile(); |
| if (f.equals(canonical)) { |
| // path of f doesn't contain symbolic links |
| return canonical; |
| } |
| |
| // preserve symbolic links from being resolved |
| return new File(f.toURI().normalize()); |
| } |
| |
| // Override File methods |
| |
| public static void sortFiles(List files) { |
| shellFolderManager.sortFiles(files); |
| } |
| |
| public boolean isAbsolute() { |
| return (!isFileSystem() || super.isAbsolute()); |
| } |
| |
| public File getAbsoluteFile() { |
| return (isFileSystem() ? super.getAbsoluteFile() : this); |
| } |
| |
| public boolean canRead() { |
| return (isFileSystem() ? super.canRead() : true); // ((Fix?)) |
| } |
| |
| /** |
| * Returns true if folder allows creation of children. |
| * True for the "Desktop" folder, but false for the "My Computer" |
| * folder. |
| */ |
| public boolean canWrite() { |
| return (isFileSystem() ? super.canWrite() : false); // ((Fix?)) |
| } |
| |
| public boolean exists() { |
| // Assume top-level drives exist, because state is uncertain for |
| // removable drives. |
| return (!isFileSystem() || isFileSystemRoot(this) || super.exists()) ; |
| } |
| |
| public boolean isDirectory() { |
| return (isFileSystem() ? super.isDirectory() : true); // ((Fix?)) |
| } |
| |
| public boolean isFile() { |
| return (isFileSystem() ? super.isFile() : !isDirectory()); // ((Fix?)) |
| } |
| |
| public long lastModified() { |
| return (isFileSystem() ? super.lastModified() : 0L); // ((Fix?)) |
| } |
| |
| public long length() { |
| return (isFileSystem() ? super.length() : 0L); // ((Fix?)) |
| } |
| |
| public boolean createNewFile() throws IOException { |
| return (isFileSystem() ? super.createNewFile() : false); |
| } |
| |
| public boolean delete() { |
| return (isFileSystem() ? super.delete() : false); // ((Fix?)) |
| } |
| |
| public void deleteOnExit() { |
| if (isFileSystem()) { |
| super.deleteOnExit(); |
| } else { |
| // Do nothing // ((Fix?)) |
| } |
| } |
| |
| public boolean mkdir() { |
| return (isFileSystem() ? super.mkdir() : false); |
| } |
| |
| public boolean mkdirs() { |
| return (isFileSystem() ? super.mkdirs() : false); |
| } |
| |
| public boolean renameTo(File dest) { |
| return (isFileSystem() ? super.renameTo(dest) : false); // ((Fix?)) |
| } |
| |
| public boolean setLastModified(long time) { |
| return (isFileSystem() ? super.setLastModified(time) : false); // ((Fix?)) |
| } |
| |
| public boolean setReadOnly() { |
| return (isFileSystem() ? super.setReadOnly() : false); // ((Fix?)) |
| } |
| |
| public String toString() { |
| return (isFileSystem() ? super.toString() : getDisplayName()); |
| } |
| |
| public static ShellFolderColumnInfo[] getFolderColumns(File dir) { |
| return shellFolderManager.getFolderColumns(dir); |
| } |
| |
| public static Object getFolderColumnValue(File file, int column) { |
| return shellFolderManager.getFolderColumnValue(file, column); |
| } |
| |
| public ShellFolderColumnInfo[] getFolderColumns() { |
| return null; |
| } |
| |
| public Object getFolderColumnValue(int column) { |
| return null; |
| } |
| } |