1 /*
   2  * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.awt.shell;
  27 
  28 import javax.swing.*;
  29 import java.awt.Image;
  30 import java.awt.Toolkit;
  31 import java.io.*;
  32 import java.io.FileNotFoundException;
  33 import java.util.*;
  34 import java.util.concurrent.Callable;
  35 
  36 /**
  37  * @author Michael Martak
  38  * @since 1.4
  39  */
  40 @SuppressWarnings("serial") // JDK-implementation class
  41 public abstract class ShellFolder extends File {
  42     private static final String COLUMN_NAME = "FileChooser.fileNameHeaderText";
  43     private static final String COLUMN_SIZE = "FileChooser.fileSizeHeaderText";
  44     private static final String COLUMN_DATE = "FileChooser.fileDateHeaderText";
  45 
  46     protected ShellFolder parent;
  47 
  48     /**
  49      * Create a file system shell folder from a file
  50      */
  51     ShellFolder(ShellFolder parent, String pathname) {
  52         super((pathname != null) ? pathname : "ShellFolder");
  53         this.parent = parent;
  54     }
  55 
  56     /**
  57      * @return Whether this is a file system shell folder
  58      */
  59     public boolean isFileSystem() {
  60         return (!getPath().startsWith("ShellFolder"));
  61     }
  62 
  63     /**
  64      * This method must be implemented to make sure that no instances
  65      * of {@code ShellFolder} are ever serialized. If {@code isFileSystem()} returns
  66      * {@code true}, then the object should be representable with an instance of
  67      * {@code java.io.File} instead. If not, then the object is most likely
  68      * depending on some internal (native) state and cannot be serialized.
  69      *
  70      * @return a java.io.File replacement object, or null
  71      *         if no suitable replacement can be found.
  72      */
  73     protected abstract Object writeReplace() throws java.io.ObjectStreamException;
  74 
  75     /**
  76      * Returns the path for this object's parent,
  77      * or {@code null} if this object does not name a parent
  78      * folder.
  79      *
  80      * @return  the path as a String for this object's parent,
  81      * or {@code null} if this object does not name a parent
  82      * folder
  83      *
  84      * @see java.io.File#getParent()
  85      * @since 1.4
  86      */
  87     public String getParent() {
  88         if (parent == null && isFileSystem()) {
  89             return super.getParent();
  90         }
  91         if (parent != null) {
  92             return (parent.getPath());
  93         } else {
  94             return null;
  95         }
  96     }
  97 
  98     /**
  99      * Returns a File object representing this object's parent,
 100      * or {@code null} if this object does not name a parent
 101      * folder.
 102      *
 103      * @return  a File object representing this object's parent,
 104      * or {@code null} if this object does not name a parent
 105      * folder
 106      *
 107      * @see java.io.File#getParentFile()
 108      * @since 1.4
 109      */
 110     public File getParentFile() {
 111         if (parent != null) {
 112             return parent;
 113         } else if (isFileSystem()) {
 114             return super.getParentFile();
 115         } else {
 116             return null;
 117         }
 118     }
 119 
 120     public File[] listFiles() {
 121         return listFiles(true);
 122     }
 123 
 124     public File[] listFiles(boolean includeHiddenFiles) {
 125         File[] files = super.listFiles();
 126 
 127         if (!includeHiddenFiles) {
 128             Vector<File> v = new Vector<>();
 129             int nameCount = (files == null) ? 0 : files.length;
 130             for (int i = 0; i < nameCount; i++) {
 131                 if (!files[i].isHidden()) {
 132                     v.addElement(files[i]);
 133                 }
 134             }
 135             files = v.toArray(new File[v.size()]);
 136         }
 137 
 138         return files;
 139     }
 140 
 141 
 142     /**
 143      * @return Whether this shell folder is a link
 144      */
 145     public abstract boolean isLink();
 146 
 147     /**
 148      * @return The shell folder linked to by this shell folder, or null
 149      * if this shell folder is not a link
 150      */
 151     public abstract ShellFolder getLinkLocation() throws FileNotFoundException;
 152 
 153     /**
 154      * @return The name used to display this shell folder
 155      */
 156     public abstract String getDisplayName();
 157 
 158     /**
 159      * @return The type of shell folder as a string
 160      */
 161     public abstract String getFolderType();
 162 
 163     /**
 164      * @return The executable type as a string
 165      */
 166     public abstract String getExecutableType();
 167 
 168     /**
 169      * Compares this ShellFolder with the specified ShellFolder for order.
 170      *
 171      * @see #compareTo(Object)
 172      */
 173     public int compareTo(File file2) {
 174         if (file2 == null || !(file2 instanceof ShellFolder)
 175             || ((file2 instanceof ShellFolder) && ((ShellFolder)file2).isFileSystem())) {
 176 
 177             if (isFileSystem()) {
 178                 return super.compareTo(file2);
 179             } else {
 180                 return -1;
 181             }
 182         } else {
 183             if (isFileSystem()) {
 184                 return 1;
 185             } else {
 186                 return getName().compareTo(file2.getName());
 187             }
 188         }
 189     }
 190 
 191     /**
 192      * @param getLargeIcon whether to return large icon (ignored in base implementation)
 193      * @return The icon used to display this shell folder
 194      */
 195     public Image getIcon(boolean getLargeIcon) {
 196         return null;
 197     }
 198 
 199 
 200     // Static
 201 
 202     private static final ShellFolderManager shellFolderManager;
 203 
 204     private static final Invoker invoker;
 205 
 206     static {
 207         String managerClassName = (String)Toolkit.getDefaultToolkit().
 208                                       getDesktopProperty("Shell.shellFolderManager");
 209         Class<?> managerClass = null;
 210         try {
 211             managerClass = Class.forName(managerClassName, false, null);
 212             if (!ShellFolderManager.class.isAssignableFrom(managerClass)) {
 213                 managerClass = null;
 214             }
 215         // swallow the exceptions below and use default shell folder
 216         } catch(ClassNotFoundException e) {
 217         } catch(NullPointerException e) {
 218         } catch(SecurityException e) {
 219         }
 220 
 221         if (managerClass == null) {
 222             managerClass = ShellFolderManager.class;
 223         }
 224         try {
 225             shellFolderManager =
 226                 (ShellFolderManager)managerClass.newInstance();

 227         } catch (InstantiationException e) {
 228             throw new Error("Could not instantiate Shell Folder Manager: "
 229             + managerClass.getName());
 230         } catch (IllegalAccessException e) {
 231             throw new Error ("Could not access Shell Folder Manager: "
 232             + managerClass.getName());
 233         }
 234 
 235         invoker = shellFolderManager.createInvoker();
 236     }
 237 
 238     /**
 239      * Return a shell folder from a file object
 240      * @exception FileNotFoundException if file does not exist
 241      */
 242     public static ShellFolder getShellFolder(File file) throws FileNotFoundException {
 243         if (file instanceof ShellFolder) {
 244             return (ShellFolder)file;
 245         }
 246         if (!file.exists()) {
 247             throw new FileNotFoundException();
 248         }
 249         return shellFolderManager.createShellFolder(file);
 250     }
 251 
 252     /**
 253      * @param key a {@code String}
 254      * @return An Object matching the string {@code key}.
 255      * @see ShellFolderManager#get(String)
 256      */
 257     public static Object get(String key) {
 258         return shellFolderManager.get(key);
 259     }
 260 
 261     /**
 262      * Does {@code dir} represent a "computer" such as a node on the network, or
 263      * "My Computer" on the desktop.
 264      */
 265     public static boolean isComputerNode(File dir) {
 266         return shellFolderManager.isComputerNode(dir);
 267     }
 268 
 269     /**
 270      * @return Whether this is a file system root directory
 271      */
 272     public static boolean isFileSystemRoot(File dir) {
 273         return shellFolderManager.isFileSystemRoot(dir);
 274     }
 275 
 276     /**
 277      * Canonicalizes files that don't have symbolic links in their path.
 278      * Normalizes files that do, preserving symbolic links from being resolved.
 279      */
 280     public static File getNormalizedFile(File f) throws IOException {
 281         File canonical = f.getCanonicalFile();
 282         if (f.equals(canonical)) {
 283             // path of f doesn't contain symbolic links
 284             return canonical;
 285         }
 286 
 287         // preserve symbolic links from being resolved
 288         return new File(f.toURI().normalize());
 289     }
 290 
 291     // Override File methods
 292 
 293     public static void sort(final List<? extends File> files) {
 294         if (files == null || files.size() <= 1) {
 295             return;
 296         }
 297 
 298         // To avoid loads of synchronizations with Invoker and improve performance we
 299         // synchronize the whole code of the sort method once
 300         invoke(new Callable<Void>() {
 301             public Void call() {
 302                 // Check that we can use the ShellFolder.sortChildren() method:
 303                 //   1. All files have the same non-null parent
 304                 //   2. All files is ShellFolders
 305                 File commonParent = null;
 306 
 307                 for (File file : files) {
 308                     File parent = file.getParentFile();
 309 
 310                     if (parent == null || !(file instanceof ShellFolder)) {
 311                         commonParent = null;
 312 
 313                         break;
 314                     }
 315 
 316                     if (commonParent == null) {
 317                         commonParent = parent;
 318                     } else {
 319                         if (commonParent != parent && !commonParent.equals(parent)) {
 320                             commonParent = null;
 321 
 322                             break;
 323                         }
 324                     }
 325                 }
 326 
 327                 if (commonParent instanceof ShellFolder) {
 328                     ((ShellFolder) commonParent).sortChildren(files);
 329                 } else {
 330                     Collections.sort(files, FILE_COMPARATOR);
 331                 }
 332 
 333                 return null;
 334             }
 335         });
 336     }
 337 
 338     public void sortChildren(final List<? extends File> files) {
 339         // To avoid loads of synchronizations with Invoker and improve performance we
 340         // synchronize the whole code of the sort method once
 341         invoke(new Callable<Void>() {
 342             public Void call() {
 343                 Collections.sort(files, FILE_COMPARATOR);
 344 
 345                 return null;
 346             }
 347         });
 348     }
 349 
 350     public boolean isAbsolute() {
 351         return (!isFileSystem() || super.isAbsolute());
 352     }
 353 
 354     public File getAbsoluteFile() {
 355         return (isFileSystem() ? super.getAbsoluteFile() : this);
 356     }
 357 
 358     public boolean canRead() {
 359         return (isFileSystem() ? super.canRead() : true);       // ((Fix?))
 360     }
 361 
 362     /**
 363      * Returns true if folder allows creation of children.
 364      * True for the "Desktop" folder, but false for the "My Computer"
 365      * folder.
 366      */
 367     public boolean canWrite() {
 368         return (isFileSystem() ? super.canWrite() : false);     // ((Fix?))
 369     }
 370 
 371     public boolean exists() {
 372         // Assume top-level drives exist, because state is uncertain for
 373         // removable drives.
 374         return (!isFileSystem() || isFileSystemRoot(this) || super.exists()) ;
 375     }
 376 
 377     public boolean isDirectory() {
 378         return (isFileSystem() ? super.isDirectory() : true);   // ((Fix?))
 379     }
 380 
 381     public boolean isFile() {
 382         return (isFileSystem() ? super.isFile() : !isDirectory());      // ((Fix?))
 383     }
 384 
 385     public long lastModified() {
 386         return (isFileSystem() ? super.lastModified() : 0L);    // ((Fix?))
 387     }
 388 
 389     public long length() {
 390         return (isFileSystem() ? super.length() : 0L);  // ((Fix?))
 391     }
 392 
 393     public boolean createNewFile() throws IOException {
 394         return (isFileSystem() ? super.createNewFile() : false);
 395     }
 396 
 397     public boolean delete() {
 398         return (isFileSystem() ? super.delete() : false);       // ((Fix?))
 399     }
 400 
 401     public void deleteOnExit() {
 402         if (isFileSystem()) {
 403             super.deleteOnExit();
 404         } else {
 405             // Do nothing       // ((Fix?))
 406         }
 407     }
 408 
 409     public boolean mkdir() {
 410         return (isFileSystem() ? super.mkdir() : false);
 411     }
 412 
 413     public boolean mkdirs() {
 414         return (isFileSystem() ? super.mkdirs() : false);
 415     }
 416 
 417     public boolean renameTo(File dest) {
 418         return (isFileSystem() ? super.renameTo(dest) : false); // ((Fix?))
 419     }
 420 
 421     public boolean setLastModified(long time) {
 422         return (isFileSystem() ? super.setLastModified(time) : false); // ((Fix?))
 423     }
 424 
 425     public boolean setReadOnly() {
 426         return (isFileSystem() ? super.setReadOnly() : false); // ((Fix?))
 427     }
 428 
 429     public String toString() {
 430         return (isFileSystem() ? super.toString() : getDisplayName());
 431     }
 432 
 433     public static ShellFolderColumnInfo[] getFolderColumns(File dir) {
 434         ShellFolderColumnInfo[] columns = null;
 435 
 436         if (dir instanceof ShellFolder) {
 437             columns = ((ShellFolder) dir).getFolderColumns();
 438         }
 439 
 440         if (columns == null) {
 441             columns = new ShellFolderColumnInfo[]{
 442                     new ShellFolderColumnInfo(COLUMN_NAME, 150,
 443                             SwingConstants.LEADING, true, null,
 444                             FILE_COMPARATOR),
 445                     new ShellFolderColumnInfo(COLUMN_SIZE, 75,
 446                             SwingConstants.RIGHT, true, null,
 447                             DEFAULT_COMPARATOR, true),
 448                     new ShellFolderColumnInfo(COLUMN_DATE, 130,
 449                             SwingConstants.LEADING, true, null,
 450                             DEFAULT_COMPARATOR, true)
 451             };
 452         }
 453 
 454         return columns;
 455     }
 456 
 457     public ShellFolderColumnInfo[] getFolderColumns() {
 458         return null;
 459     }
 460 
 461     public static Object getFolderColumnValue(File file, int column) {
 462         if (file instanceof ShellFolder) {
 463             Object value = ((ShellFolder)file).getFolderColumnValue(column);
 464             if (value != null) {
 465                 return value;
 466             }
 467         }
 468 
 469         if (file == null || !file.exists()) {
 470             return null;
 471         }
 472 
 473         switch (column) {
 474             case 0:
 475                 // By default, file name will be rendered using getSystemDisplayName()
 476                 return file;
 477 
 478             case 1: // size
 479                 return file.isDirectory() ? null : Long.valueOf(file.length());
 480 
 481             case 2: // date
 482                 if (isFileSystemRoot(file)) {
 483                     return null;
 484                 }
 485                 long time = file.lastModified();
 486                 return (time == 0L) ? null : new Date(time);
 487 
 488             default:
 489                 return null;
 490         }
 491     }
 492 
 493     public Object getFolderColumnValue(int column) {
 494         return null;
 495     }
 496 
 497     /**
 498      * Invokes the {@code task} which doesn't throw checked exceptions
 499      * from its {@code call} method. If invokation is interrupted then Thread.currentThread().isInterrupted() will
 500      * be set and result will be {@code null}
 501      */
 502     public static <T> T invoke(Callable<T> task) {
 503         try {
 504             return invoke(task, RuntimeException.class);
 505         } catch (InterruptedException e) {
 506             return null;
 507         }
 508     }
 509 
 510     /**
 511      * Invokes the {@code task} which throws checked exceptions from its {@code call} method.
 512      * If invokation is interrupted then Thread.currentThread().isInterrupted() will
 513      * be set and InterruptedException will be thrown as well.
 514      */
 515     public static <T, E extends Throwable> T invoke(Callable<T> task, Class<E> exceptionClass)
 516             throws InterruptedException, E {
 517         try {
 518             return invoker.invoke(task);
 519         } catch (Exception e) {
 520             if (e instanceof RuntimeException) {
 521                 // Rethrow unchecked exceptions
 522                 throw (RuntimeException) e;
 523             }
 524 
 525             if (e instanceof InterruptedException) {
 526                 // Set isInterrupted flag for current thread
 527                 Thread.currentThread().interrupt();
 528 
 529                 // Rethrow InterruptedException
 530                 throw (InterruptedException) e;
 531             }
 532 
 533             if (exceptionClass.isInstance(e)) {
 534                 throw exceptionClass.cast(e);
 535             }
 536 
 537             throw new RuntimeException("Unexpected error", e);
 538         }
 539     }
 540 
 541     /**
 542      * Interface allowing to invoke tasks in different environments on different platforms.
 543      */
 544     public static interface Invoker {
 545         /**
 546          * Invokes a callable task.
 547          *
 548          * @param task a task to invoke
 549          * @throws Exception {@code InterruptedException} or an exception that was thrown from the {@code task}
 550          * @return the result of {@code task}'s invokation
 551          */
 552         <T> T invoke(Callable<T> task) throws Exception;
 553     }
 554 
 555     /**
 556      * Provides a default comparator for the default column set
 557      */
 558     private static final Comparator<Object> DEFAULT_COMPARATOR = new Comparator<Object>() {
 559         public int compare(Object o1, Object o2) {
 560             int gt;
 561 
 562             if (o1 == null && o2 == null) {
 563                 gt = 0;
 564             } else if (o1 != null && o2 == null) {
 565                 gt = 1;
 566             } else if (o1 == null && o2 != null) {
 567                 gt = -1;
 568             } else if (o1 instanceof Comparable) {
 569                 @SuppressWarnings("unchecked")
 570                 Comparable<Object> o = (Comparable<Object>) o1;
 571                 gt = o.compareTo(o2);
 572             } else {
 573                 gt = 0;
 574             }
 575 
 576             return gt;
 577         }
 578     };
 579 
 580     private static final Comparator<File> FILE_COMPARATOR = new Comparator<File>() {
 581         public int compare(File f1, File f2) {
 582             ShellFolder sf1 = null;
 583             ShellFolder sf2 = null;
 584 
 585             if (f1 instanceof ShellFolder) {
 586                 sf1 = (ShellFolder) f1;
 587                 if (sf1.isFileSystem()) {
 588                     sf1 = null;
 589                 }
 590             }
 591             if (f2 instanceof ShellFolder) {
 592                 sf2 = (ShellFolder) f2;
 593                 if (sf2.isFileSystem()) {
 594                     sf2 = null;
 595                 }
 596             }
 597 
 598             if (sf1 != null && sf2 != null) {
 599                 return sf1.compareTo(sf2);
 600             } else if (sf1 != null) {
 601                 // Non-file shellfolders sort before files
 602                 return -1;
 603             } else if (sf2 != null) {
 604                 return 1;
 605             } else {
 606                 String name1 = f1.getName();
 607                 String name2 = f2.getName();
 608 
 609                 // First ignore case when comparing
 610                 int diff = name1.compareToIgnoreCase(name2);
 611                 if (diff != 0) {
 612                     return diff;
 613                 } else {
 614                     // May differ in case (e.g. "mail" vs. "Mail")
 615                     // We need this test for consistent sorting
 616                     return name1.compareTo(name2);
 617                 }
 618             }
 619         }
 620     };
 621 }
--- EOF ---