1 /*
   2  * Copyright (c) 2003, 2015, 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 java.awt.Image;
  29 import java.awt.Toolkit;
  30 import java.awt.image.BufferedImage;
  31 import java.io.File;
  32 import java.io.FileNotFoundException;
  33 import java.io.IOException;
  34 import java.util.*;
  35 import java.util.concurrent.*;
  36 import javax.swing.SwingConstants;
  37 
  38 // NOTE: This class supersedes Win32ShellFolder, which was removed from
  39 //       distribution after version 1.4.2.
  40 
  41 /**
  42  * Win32 Shell Folders
  43  * <P>
  44  * <BR>
  45  * There are two fundamental types of shell folders : file system folders
  46  * and non-file system folders.  File system folders are relatively easy
  47  * to deal with.  Non-file system folders are items such as My Computer,
  48  * Network Neighborhood, and the desktop.  Some of these non-file system
  49  * folders have special values and properties.
  50  * <P>
  51  * <BR>
  52  * Win32 keeps two basic data structures for shell folders.  The first
  53  * of these is called an ITEMIDLIST.  Usually a pointer, called an
  54  * LPITEMIDLIST, or more frequently just "PIDL".  This structure holds
  55  * a series of identifiers and can be either relative to the desktop
  56  * (an absolute PIDL), or relative to the shell folder that contains them.
  57  * Some Win32 functions can take absolute or relative PIDL values, and
  58  * others can only accept relative values.
  59  * <BR>
  60  * The second data structure is an IShellFolder COM interface.  Using
  61  * this interface, one can enumerate the relative PIDLs in a shell
  62  * folder, get attributes, etc.
  63  * <BR>
  64  * All Win32ShellFolder2 objects which are folder types (even non-file
  65  * system folders) contain an IShellFolder object. Files are named in
  66  * directories via relative PIDLs.
  67  *
  68  * @author Michael Martak
  69  * @author Leif Samuelsson
  70  * @author Kenneth Russell
  71  * @since 1.4 */
  72 @SuppressWarnings("serial") // JDK-implementation class
  73 final class Win32ShellFolder2 extends ShellFolder {
  74 
  75     private static native void initIDs();
  76 
  77     static {
  78         initIDs();
  79     }
  80 
  81     // Win32 Shell Folder Constants
  82     public static final int DESKTOP = 0x0000;
  83     public static final int INTERNET = 0x0001;
  84     public static final int PROGRAMS = 0x0002;
  85     public static final int CONTROLS = 0x0003;
  86     public static final int PRINTERS = 0x0004;
  87     public static final int PERSONAL = 0x0005;
  88     public static final int FAVORITES = 0x0006;
  89     public static final int STARTUP = 0x0007;
  90     public static final int RECENT = 0x0008;
  91     public static final int SENDTO = 0x0009;
  92     public static final int BITBUCKET = 0x000a;
  93     public static final int STARTMENU = 0x000b;
  94     public static final int DESKTOPDIRECTORY = 0x0010;
  95     public static final int DRIVES = 0x0011;
  96     public static final int NETWORK = 0x0012;
  97     public static final int NETHOOD = 0x0013;
  98     public static final int FONTS = 0x0014;
  99     public static final int TEMPLATES = 0x0015;
 100     public static final int COMMON_STARTMENU = 0x0016;
 101     public static final int COMMON_PROGRAMS = 0X0017;
 102     public static final int COMMON_STARTUP = 0x0018;
 103     public static final int COMMON_DESKTOPDIRECTORY = 0x0019;
 104     public static final int APPDATA = 0x001a;
 105     public static final int PRINTHOOD = 0x001b;
 106     public static final int ALTSTARTUP = 0x001d;
 107     public static final int COMMON_ALTSTARTUP = 0x001e;
 108     public static final int COMMON_FAVORITES = 0x001f;
 109     public static final int INTERNET_CACHE = 0x0020;
 110     public static final int COOKIES = 0x0021;
 111     public static final int HISTORY = 0x0022;
 112 
 113     // Win32 shell folder attributes
 114     public static final int ATTRIB_CANCOPY          = 0x00000001;
 115     public static final int ATTRIB_CANMOVE          = 0x00000002;
 116     public static final int ATTRIB_CANLINK          = 0x00000004;
 117     public static final int ATTRIB_CANRENAME        = 0x00000010;
 118     public static final int ATTRIB_CANDELETE        = 0x00000020;
 119     public static final int ATTRIB_HASPROPSHEET     = 0x00000040;
 120     public static final int ATTRIB_DROPTARGET       = 0x00000100;
 121     public static final int ATTRIB_LINK             = 0x00010000;
 122     public static final int ATTRIB_SHARE            = 0x00020000;
 123     public static final int ATTRIB_READONLY         = 0x00040000;
 124     public static final int ATTRIB_GHOSTED          = 0x00080000;
 125     public static final int ATTRIB_HIDDEN           = 0x00080000;
 126     public static final int ATTRIB_FILESYSANCESTOR  = 0x10000000;
 127     public static final int ATTRIB_FOLDER           = 0x20000000;
 128     public static final int ATTRIB_FILESYSTEM       = 0x40000000;
 129     public static final int ATTRIB_HASSUBFOLDER     = 0x80000000;
 130     public static final int ATTRIB_VALIDATE         = 0x01000000;
 131     public static final int ATTRIB_REMOVABLE        = 0x02000000;
 132     public static final int ATTRIB_COMPRESSED       = 0x04000000;
 133     public static final int ATTRIB_BROWSABLE        = 0x08000000;
 134     public static final int ATTRIB_NONENUMERATED    = 0x00100000;
 135     public static final int ATTRIB_NEWCONTENT       = 0x00200000;
 136 
 137     // IShellFolder::GetDisplayNameOf constants
 138     public static final int SHGDN_NORMAL            = 0;
 139     public static final int SHGDN_INFOLDER          = 1;
 140     public static final int SHGDN_INCLUDE_NONFILESYS= 0x2000;
 141     public static final int SHGDN_FORADDRESSBAR     = 0x4000;
 142     public static final int SHGDN_FORPARSING        = 0x8000;
 143 
 144     /** The referent to be registered with the Disposer. */
 145     private Object disposerReferent = new Object();
 146 
 147     // Values for system call LoadIcon()
 148     public enum SystemIcon {
 149         IDI_APPLICATION(32512),
 150         IDI_HAND(32513),
 151         IDI_ERROR(32513),
 152         IDI_QUESTION(32514),
 153         IDI_EXCLAMATION(32515),
 154         IDI_WARNING(32515),
 155         IDI_ASTERISK(32516),
 156         IDI_INFORMATION(32516),
 157         IDI_WINLOGO(32517);
 158 
 159         private final int iconID;
 160 
 161         SystemIcon(int iconID) {
 162             this.iconID = iconID;
 163         }
 164 
 165         public int getIconID() {
 166             return iconID;
 167         }
 168     }
 169 
 170     // Known Folder data
 171     static class KnownFolderDefinition {
 172         String guid;
 173         int category;
 174         String name;
 175         String description;
 176         String parent;
 177         String relativePath;
 178         String parsingName;
 179         String tooltip;
 180         String localizedName;
 181         String icon;
 182         String security;
 183         long attributes;
 184         int defenitionFlags;
 185         String ftidType;
 186         String path;
 187         String saveLocation;
 188         static final List<KnownFolderDefinition> libraries = getLibraries();
 189     }
 190 
 191     static class FolderDisposer implements sun.java2d.DisposerRecord {
 192         /*
 193          * This is cached as a concession to getFolderType(), which needs
 194          * an absolute PIDL.
 195          */
 196         long absolutePIDL;
 197         /*
 198          * We keep track of shell folders through the IShellFolder
 199          * interface of their parents plus their relative PIDL.
 200          */
 201         long pIShellFolder;
 202         long relativePIDL;
 203 
 204         boolean disposed;
 205         public void dispose() {
 206             if (disposed) return;
 207             invoke(new Callable<Void>() {
 208                 public Void call() {
 209                     if (relativePIDL != 0) {
 210                         releasePIDL(relativePIDL);
 211                     }
 212                     if (absolutePIDL != 0) {
 213                         releasePIDL(absolutePIDL);
 214                     }
 215                     if (pIShellFolder != 0) {
 216                         releaseIShellFolder(pIShellFolder);
 217                     }
 218                     return null;
 219                 }
 220             });
 221             disposed = true;
 222         }
 223     }
 224     FolderDisposer disposer = new FolderDisposer();
 225     private void setIShellFolder(long pIShellFolder) {
 226         disposer.pIShellFolder = pIShellFolder;
 227     }
 228     private void setRelativePIDL(long relativePIDL) {
 229         disposer.relativePIDL = relativePIDL;
 230     }
 231     /*
 232      * The following are for caching various shell folder properties.
 233      */
 234     private long pIShellIcon = -1L;
 235     private String folderType = null;
 236     private String displayName = null;
 237     private Image smallIcon = null;
 238     private Image largeIcon = null;
 239     private Boolean isDir = null;
 240     private final boolean isLib;
 241 
 242     /*
 243      * The following is to identify the My Documents folder as being special
 244      */
 245     private boolean isPersonal;
 246 
 247     private static String composePathForCsidl(int csidl) throws IOException, InterruptedException {
 248         String path = getFileSystemPath(csidl);
 249         return path == null
 250                 ? ("ShellFolder: 0x" + Integer.toHexString(csidl))
 251                 : path;
 252     }
 253 
 254     /**
 255      * Create a system special shell folder, such as the
 256      * desktop or Network Neighborhood.
 257      */
 258     Win32ShellFolder2(final int csidl) throws IOException, InterruptedException {
 259         // Desktop is parent of DRIVES and NETWORK, not necessarily
 260         // other special shell folders.
 261         super(null, composePathForCsidl(csidl));
 262         isLib = false;
 263 
 264         invoke(new Callable<Void>() {
 265             public Void call() throws InterruptedException {
 266                 if (csidl == DESKTOP) {
 267                     initDesktop();
 268                 } else {
 269                     initSpecial(getDesktop().getIShellFolder(), csidl);
 270                     // At this point, the native method initSpecial() has set our relativePIDL
 271                     // relative to the Desktop, which may not be our immediate parent. We need
 272                     // to traverse this ID list and break it into a chain of shell folders from
 273                     // the top, with each one having an immediate parent and a relativePIDL
 274                     // relative to that parent.
 275                     long pIDL = disposer.relativePIDL;
 276                     parent = getDesktop();
 277                     while (pIDL != 0) {
 278                         // Get a child pidl relative to 'parent'
 279                         long childPIDL = copyFirstPIDLEntry(pIDL);
 280                         if (childPIDL != 0) {
 281                             // Get a handle to the rest of the ID list
 282                             // i,e, parent's grandchilren and down
 283                             pIDL = getNextPIDLEntry(pIDL);
 284                             if (pIDL != 0) {
 285                                 // Now we know that parent isn't immediate to 'this' because it
 286                                 // has a continued ID list. Create a shell folder for this child
 287                                 // pidl and make it the new 'parent'.
 288                                 parent = createShellFolder((Win32ShellFolder2) parent, childPIDL);
 289                             } else {
 290                                 // No grandchildren means we have arrived at the parent of 'this',
 291                                 // and childPIDL is directly relative to parent.
 292                                 disposer.relativePIDL = childPIDL;
 293                             }
 294                         } else {
 295                             break;
 296                         }
 297                     }
 298                 }
 299                 return null;
 300             }
 301         }, InterruptedException.class);
 302 
 303         sun.java2d.Disposer.addObjectRecord(disposerReferent, disposer);
 304     }
 305 
 306 
 307     /**
 308      * Create a system shell folder
 309      */
 310     Win32ShellFolder2(Win32ShellFolder2 parent, long pIShellFolder, long relativePIDL, String path, boolean isLib) {
 311         super(parent, (path != null) ? path : "ShellFolder: ");
 312         this.isLib = isLib;
 313         this.disposer.pIShellFolder = pIShellFolder;
 314         this.disposer.relativePIDL = relativePIDL;
 315         sun.java2d.Disposer.addObjectRecord(disposerReferent, disposer);
 316     }
 317 
 318 
 319     /**
 320      * Creates a shell folder with a parent and relative PIDL
 321      */
 322     static Win32ShellFolder2 createShellFolder(Win32ShellFolder2 parent, long pIDL)
 323             throws InterruptedException {
 324         String path = invoke(new Callable<String>() {
 325             public String call() {
 326                 return getFileSystemPath(parent.getIShellFolder(), pIDL);
 327             }
 328         }, RuntimeException.class);
 329         String libPath = resolveLibrary(path);
 330         if (libPath == null) {
 331             return new Win32ShellFolder2(parent, 0, pIDL, path, false);
 332         } else {
 333             return new Win32ShellFolder2(parent, 0, pIDL, libPath, true);
 334         }
 335     }
 336 
 337     // Initializes the desktop shell folder
 338     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 339     private native void initDesktop();
 340 
 341     // Initializes a special, non-file system shell folder
 342     // from one of the above constants
 343     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 344     private native void initSpecial(long desktopIShellFolder, int csidl);
 345 
 346     /** Marks this folder as being the My Documents (Personal) folder */
 347     public void setIsPersonal() {
 348         isPersonal = true;
 349     }
 350 
 351     /**
 352      * This method is implemented to make sure that no instances
 353      * of {@code ShellFolder} are ever serialized. If {@code isFileSystem()} returns
 354      * {@code true}, then the object is representable with an instance of
 355      * {@code java.io.File} instead. If not, then the object depends
 356      * on native PIDL state and should not be serialized.
 357      *
 358      * @return a {@code java.io.File} replacement object. If the folder
 359      * is a not a normal directory, then returns the first non-removable
 360      * drive (normally "C:\").
 361      */
 362     protected Object writeReplace() throws java.io.ObjectStreamException {
 363         return invoke(new Callable<File>() {
 364             public File call() {
 365                 if (isFileSystem()) {
 366                     return new File(getPath());
 367                 } else {
 368                     Win32ShellFolder2 drives = Win32ShellFolderManager2.getDrives();
 369                     if (drives != null) {
 370                         File[] driveRoots = drives.listFiles();
 371                         if (driveRoots != null) {
 372                             for (int i = 0; i < driveRoots.length; i++) {
 373                                 if (driveRoots[i] instanceof Win32ShellFolder2) {
 374                                     Win32ShellFolder2 sf = (Win32ShellFolder2) driveRoots[i];
 375                                     if (sf.isFileSystem() && !sf.hasAttribute(ATTRIB_REMOVABLE)) {
 376                                         return new File(sf.getPath());
 377                                     }
 378                                 }
 379                             }
 380                         }
 381                     }
 382                     // Ouch, we have no hard drives. Return something "valid" anyway.
 383                     return new File("C:\\");
 384                 }
 385             }
 386         });
 387     }
 388 
 389 
 390     /**
 391      * Finalizer to clean up any COM objects or PIDLs used by this object.
 392      */
 393     protected void dispose() {
 394         disposer.dispose();
 395     }
 396 
 397 
 398     // Given a (possibly multi-level) relative PIDL (with respect to
 399     // the desktop, at least in all of the usage cases in this code),
 400     // return a pointer to the next entry. Does not mutate the PIDL in
 401     // any way. Returns 0 if the null terminator is reached.
 402     // Needs to be accessible to Win32ShellFolderManager2
 403     static native long getNextPIDLEntry(long pIDL);
 404 
 405     // Given a (possibly multi-level) relative PIDL (with respect to
 406     // the desktop, at least in all of the usage cases in this code),
 407     // copy the first entry into a newly-allocated PIDL. Returns 0 if
 408     // the PIDL is at the end of the list.
 409     // Needs to be accessible to Win32ShellFolderManager2
 410     static native long copyFirstPIDLEntry(long pIDL);
 411 
 412     // Given a parent's absolute PIDL and our relative PIDL, build an absolute PIDL
 413     private static native long combinePIDLs(long ppIDL, long pIDL);
 414 
 415     // Release a PIDL object
 416     // Needs to be accessible to Win32ShellFolderManager2
 417     static native void releasePIDL(long pIDL);
 418 
 419     // Release an IShellFolder object
 420     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 421     private static native void releaseIShellFolder(long pIShellFolder);
 422 
 423     /**
 424      * Accessor for IShellFolder
 425      */
 426     private long getIShellFolder() {
 427         if (disposer.pIShellFolder == 0) {
 428             try {
 429                 disposer.pIShellFolder = invoke(new Callable<Long>() {
 430                     public Long call() {
 431                         assert(isDirectory());
 432                         assert(parent != null);
 433                         long parentIShellFolder = getParentIShellFolder();
 434                         if (parentIShellFolder == 0) {
 435                             throw new InternalError("Parent IShellFolder was null for "
 436                                     + getAbsolutePath());
 437                         }
 438                         // We are a directory with a parent and a relative PIDL.
 439                         // We want to bind to the parent so we get an
 440                         // IShellFolder instance associated with us.
 441                         long pIShellFolder = bindToObject(parentIShellFolder,
 442                                 disposer.relativePIDL);
 443                         if (pIShellFolder == 0) {
 444                             throw new InternalError("Unable to bind "
 445                                     + getAbsolutePath() + " to parent");
 446                         }
 447                         return pIShellFolder;
 448                     }
 449                 }, RuntimeException.class);
 450             } catch (InterruptedException e) {
 451                 // Ignore error
 452             }
 453         }
 454         return disposer.pIShellFolder;
 455     }
 456 
 457     /**
 458      * Get the parent ShellFolder's IShellFolder interface
 459      */
 460     public long getParentIShellFolder() {
 461         Win32ShellFolder2 parent = (Win32ShellFolder2)getParentFile();
 462         if (parent == null) {
 463             // Parent should only be null if this is the desktop, whose
 464             // relativePIDL is relative to its own IShellFolder.
 465             return getIShellFolder();
 466         }
 467         return parent.getIShellFolder();
 468     }
 469 
 470     /**
 471      * Accessor for relative PIDL
 472      */
 473     public long getRelativePIDL() {
 474         if (disposer.relativePIDL == 0) {
 475             throw new InternalError("Should always have a relative PIDL");
 476         }
 477         return disposer.relativePIDL;
 478     }
 479 
 480     private long getAbsolutePIDL() {
 481         if (parent == null) {
 482             // This is the desktop
 483             return getRelativePIDL();
 484         } else {
 485             if (disposer.absolutePIDL == 0) {
 486                 disposer.absolutePIDL = combinePIDLs(((Win32ShellFolder2)parent).getAbsolutePIDL(), getRelativePIDL());
 487             }
 488 
 489             return disposer.absolutePIDL;
 490         }
 491     }
 492 
 493     /**
 494      * Helper function to return the desktop
 495      */
 496     public Win32ShellFolder2 getDesktop() {
 497         return Win32ShellFolderManager2.getDesktop();
 498     }
 499 
 500     /**
 501      * Helper function to return the desktop IShellFolder interface
 502      */
 503     public long getDesktopIShellFolder() {
 504         return getDesktop().getIShellFolder();
 505     }
 506 
 507     private static boolean pathsEqual(String path1, String path2) {
 508         // Same effective implementation as Win32FileSystem
 509         return path1.equalsIgnoreCase(path2);
 510     }
 511 
 512     /**
 513      * Check to see if two ShellFolder objects are the same
 514      */
 515     public boolean equals(Object o) {
 516         if (o == null || !(o instanceof Win32ShellFolder2)) {
 517             // Short-circuit circuitous delegation path
 518             if (!(o instanceof File)) {
 519                 return super.equals(o);
 520             }
 521             return pathsEqual(getPath(), ((File) o).getPath());
 522         }
 523         Win32ShellFolder2 rhs = (Win32ShellFolder2) o;
 524         if ((parent == null && rhs.parent != null) ||
 525             (parent != null && rhs.parent == null)) {
 526             return false;
 527         }
 528 
 529         if (isFileSystem() && rhs.isFileSystem()) {
 530             // Only folders with identical parents can be equal
 531             return (pathsEqual(getPath(), rhs.getPath()) &&
 532                     (parent == rhs.parent || parent.equals(rhs.parent)));
 533         }
 534 
 535         if (parent == rhs.parent || parent.equals(rhs.parent)) {
 536             try {
 537                 return pidlsEqual(getParentIShellFolder(), disposer.relativePIDL, rhs.disposer.relativePIDL);
 538             } catch (InterruptedException e) {
 539                 return false;
 540             }
 541         }
 542 
 543         return false;
 544     }
 545 
 546     private static boolean pidlsEqual(final long pIShellFolder, final long pidl1, final long pidl2)
 547             throws InterruptedException {
 548         return invoke(new Callable<Boolean>() {
 549             public Boolean call() {
 550                 return compareIDs(pIShellFolder, pidl1, pidl2) == 0;
 551             }
 552         }, RuntimeException.class);
 553     }
 554 
 555     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 556     private static native int compareIDs(long pParentIShellFolder, long pidl1, long pidl2);
 557 
 558     private volatile Boolean cachedIsFileSystem;
 559 
 560     /**
 561      * @return Whether this is a file system shell folder
 562      */
 563     public boolean isFileSystem() {
 564         if (cachedIsFileSystem == null) {
 565             cachedIsFileSystem = hasAttribute(ATTRIB_FILESYSTEM);
 566         }
 567 
 568         return cachedIsFileSystem;
 569     }
 570 
 571     /**
 572      * Return whether the given attribute flag is set for this object
 573      */
 574     public boolean hasAttribute(final int attribute) {
 575         Boolean result = invoke(new Callable<Boolean>() {
 576             public Boolean call() {
 577                 // Caching at this point doesn't seem to be cost efficient
 578                 return (getAttributes0(getParentIShellFolder(),
 579                     getRelativePIDL(), attribute)
 580                     & attribute) != 0;
 581             }
 582         });
 583 
 584         return result != null && result;
 585     }
 586 
 587     /**
 588      * Returns the queried attributes specified in attrsMask.
 589      *
 590      * Could plausibly be used for attribute caching but have to be
 591      * very careful not to touch network drives and file system roots
 592      * with a full attrsMask
 593      * NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 594      */
 595 
 596     private static native int getAttributes0(long pParentIShellFolder, long pIDL, int attrsMask);
 597 
 598     // Return the path to the underlying file system object
 599     // Should be called from the COM thread
 600     private static String getFileSystemPath(final long parentIShellFolder, final long relativePIDL) {
 601         int linkedFolder = ATTRIB_LINK | ATTRIB_FOLDER;
 602         if (parentIShellFolder == Win32ShellFolderManager2.getNetwork().getIShellFolder() &&
 603                 getAttributes0(parentIShellFolder, relativePIDL, linkedFolder) == linkedFolder) {
 604 
 605             String s =
 606                     getFileSystemPath(Win32ShellFolderManager2.getDesktop().getIShellFolder(),
 607                             getLinkLocation(parentIShellFolder, relativePIDL, false));
 608             if (s != null && s.startsWith("\\\\")) {
 609                 return s;
 610             }
 611         }
 612         String path = getDisplayNameOf(parentIShellFolder, relativePIDL,
 613                         SHGDN_FORPARSING);
 614         return path;
 615     }
 616 
 617     private static String resolveLibrary(String path) {
 618         // if this is a library its default save location is taken as a path
 619         // this is a temp fix until java.io starts support Libraries
 620         if( path != null && path.startsWith("::{") &&
 621                 path.toLowerCase().endsWith(".library-ms")) {
 622             for (KnownFolderDefinition kf : KnownFolderDefinition.libraries) {
 623                 if (path.toLowerCase().endsWith(
 624                         "\\" + kf.relativePath.toLowerCase()) &&
 625                         path.toUpperCase().startsWith(
 626                         kf.parsingName.substring(0, 40).toUpperCase())) {
 627                     return kf.saveLocation;
 628                 }
 629             }
 630         }
 631         return null;
 632     }
 633 
 634     // Needs to be accessible to Win32ShellFolderManager2
 635     static String getFileSystemPath(final int csidl) throws IOException, InterruptedException {
 636         String path = invoke(new Callable<String>() {
 637             public String call() throws IOException {
 638                 return getFileSystemPath0(csidl);
 639             }
 640         }, IOException.class);
 641         if (path != null) {
 642             SecurityManager security = System.getSecurityManager();
 643             if (security != null) {
 644                 security.checkRead(path);
 645             }
 646         }
 647         return path;
 648     }
 649 
 650     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 651     private static native String getFileSystemPath0(int csidl) throws IOException;
 652 
 653     // Return whether the path is a network root.
 654     // Path is assumed to be non-null
 655     private static boolean isNetworkRoot(String path) {
 656         return (path.equals("\\\\") || path.equals("\\") || path.equals("//") || path.equals("/"));
 657     }
 658 
 659     /**
 660      * @return The parent shell folder of this shell folder, null if
 661      * there is no parent
 662      */
 663     public File getParentFile() {
 664         return parent;
 665     }
 666 
 667     public boolean isDirectory() {
 668         if (isDir == null) {
 669             // Folders with SFGAO_BROWSABLE have "shell extension" handlers and are
 670             // not traversable in JFileChooser.
 671             if (hasAttribute(ATTRIB_FOLDER) && !hasAttribute(ATTRIB_BROWSABLE)) {
 672                 isDir = Boolean.TRUE;
 673             } else if (isLink()) {
 674                 ShellFolder linkLocation = getLinkLocation(false);
 675                 isDir = Boolean.valueOf(linkLocation != null && linkLocation.isDirectory());
 676             } else {
 677                 isDir = Boolean.FALSE;
 678             }
 679         }
 680         return isDir.booleanValue();
 681     }
 682 
 683     /*
 684      * Functions for enumerating an IShellFolder's children
 685      */
 686     // Returns an IEnumIDList interface for an IShellFolder.  The value
 687     // returned must be released using releaseEnumObjects().
 688     private long getEnumObjects(final boolean includeHiddenFiles) throws InterruptedException {
 689         return invoke(new Callable<Long>() {
 690             public Long call() {
 691                 boolean isDesktop = disposer.pIShellFolder == getDesktopIShellFolder();
 692 
 693                 return getEnumObjects(disposer.pIShellFolder, isDesktop, includeHiddenFiles);
 694             }
 695         }, RuntimeException.class);
 696     }
 697 
 698     // Returns an IEnumIDList interface for an IShellFolder.  The value
 699     // returned must be released using releaseEnumObjects().
 700     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 701     private native long getEnumObjects(long pIShellFolder, boolean isDesktop,
 702                                        boolean includeHiddenFiles);
 703     // Returns the next sequential child as a relative PIDL
 704     // from an IEnumIDList interface.  The value returned must
 705     // be released using releasePIDL().
 706     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 707     private native long getNextChild(long pEnumObjects);
 708     // Releases the IEnumIDList interface
 709     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 710     private native void releaseEnumObjects(long pEnumObjects);
 711 
 712     // Returns the IShellFolder of a child from a parent IShellFolder
 713     // and a relative PIDL.  The value returned must be released
 714     // using releaseIShellFolder().
 715     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 716     private static native long bindToObject(long parentIShellFolder, long pIDL);
 717 
 718     /**
 719      * @return An array of shell folders that are children of this shell folder
 720      *         object. The array will be empty if the folder is empty.  Returns
 721      *         {@code null} if this shellfolder does not denote a directory.
 722      */
 723     public File[] listFiles(final boolean includeHiddenFiles) {
 724         SecurityManager security = System.getSecurityManager();
 725         if (security != null) {
 726             security.checkRead(getPath());
 727         }
 728 
 729         try {
 730             return invoke(new Callable<File[]>() {
 731                 public File[] call() throws InterruptedException {
 732                     if (!isDirectory()) {
 733                         return null;
 734                     }
 735                     // Links to directories are not directories and cannot be parents.
 736                     // This does not apply to folders in My Network Places (NetHood)
 737                     // because they are both links and real directories!
 738                     if (isLink() && !hasAttribute(ATTRIB_FOLDER)) {
 739                         return new File[0];
 740                     }
 741 
 742                     Win32ShellFolder2 desktop = Win32ShellFolderManager2.getDesktop();
 743                     Win32ShellFolder2 personal = Win32ShellFolderManager2.getPersonal();
 744 
 745                     // If we are a directory, we have a parent and (at least) a
 746                     // relative PIDL. We must first ensure we are bound to the
 747                     // parent so we have an IShellFolder to query.
 748                     long pIShellFolder = getIShellFolder();
 749                     // Now we can enumerate the objects in this folder.
 750                     ArrayList<Win32ShellFolder2> list = new ArrayList<Win32ShellFolder2>();
 751                     long pEnumObjects = getEnumObjects(includeHiddenFiles);
 752                     if (pEnumObjects != 0) {
 753                         try {
 754                             long childPIDL;
 755                             int testedAttrs = ATTRIB_FILESYSTEM | ATTRIB_FILESYSANCESTOR;
 756                             do {
 757                                 childPIDL = getNextChild(pEnumObjects);
 758                                 boolean releasePIDL = true;
 759                                 if (childPIDL != 0 &&
 760                                         (getAttributes0(pIShellFolder, childPIDL, testedAttrs) & testedAttrs) != 0) {
 761                                     Win32ShellFolder2 childFolder;
 762                                     if (Win32ShellFolder2.this.equals(desktop)
 763                                             && personal != null
 764                                             && pidlsEqual(pIShellFolder, childPIDL, personal.disposer.relativePIDL)) {
 765                                         childFolder = personal;
 766                                     } else {
 767                                         childFolder = createShellFolder(Win32ShellFolder2.this, childPIDL);
 768                                         releasePIDL = false;
 769                                     }
 770                                     list.add(childFolder);
 771                                 }
 772                                 if (releasePIDL) {
 773                                     releasePIDL(childPIDL);
 774                                 }
 775                             } while (childPIDL != 0 && !Thread.currentThread().isInterrupted());
 776                         } finally {
 777                             releaseEnumObjects(pEnumObjects);
 778                         }
 779                     }
 780                     return Thread.currentThread().isInterrupted()
 781                         ? new File[0]
 782                         : list.toArray(new ShellFolder[list.size()]);
 783                 }
 784             }, InterruptedException.class);
 785         } catch (InterruptedException e) {
 786             return new File[0];
 787         }
 788     }
 789 
 790 
 791     /**
 792      * Look for (possibly special) child folder by it's path
 793      *
 794      * @return The child shellfolder, or null if not found.
 795      */
 796     Win32ShellFolder2 getChildByPath(final String filePath) throws InterruptedException {
 797         return invoke(new Callable<Win32ShellFolder2>() {
 798             public Win32ShellFolder2 call() throws InterruptedException {
 799                 long pIShellFolder = getIShellFolder();
 800                 long pEnumObjects = getEnumObjects(true);
 801                 Win32ShellFolder2 child = null;
 802                 long childPIDL;
 803 
 804                 while ((childPIDL = getNextChild(pEnumObjects)) != 0) {
 805                     if (getAttributes0(pIShellFolder, childPIDL, ATTRIB_FILESYSTEM) != 0) {
 806                         String path = getFileSystemPath(pIShellFolder, childPIDL);
 807                         if(isLib) path = resolveLibrary( path );
 808                         if (path != null && path.equalsIgnoreCase(filePath)) {
 809                             long childIShellFolder = bindToObject(pIShellFolder, childPIDL);
 810                             child = new Win32ShellFolder2(Win32ShellFolder2.this,
 811                                     childIShellFolder, childPIDL, path, isLib);
 812                             break;
 813                         }
 814                     }
 815                     releasePIDL(childPIDL);
 816                 }
 817                 releaseEnumObjects(pEnumObjects);
 818                 return child;
 819             }
 820         }, InterruptedException.class);
 821     }
 822 
 823     private volatile Boolean cachedIsLink;
 824 
 825     /**
 826      * @return Whether this shell folder is a link
 827      */
 828     public boolean isLink() {
 829         if (cachedIsLink == null) {
 830             cachedIsLink = hasAttribute(ATTRIB_LINK);
 831         }
 832 
 833         return cachedIsLink;
 834     }
 835 
 836     /**
 837      * @return Whether this shell folder is marked as hidden
 838      */
 839     public boolean isHidden() {
 840         return hasAttribute(ATTRIB_HIDDEN);
 841     }
 842 
 843 
 844     // Return the link location of a shell folder
 845     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 846     private static native long getLinkLocation(long parentIShellFolder,
 847                                         long relativePIDL, boolean resolve);
 848 
 849     /**
 850      * @return The shell folder linked to by this shell folder, or null
 851      * if this shell folder is not a link or is a broken or invalid link
 852      */
 853     public ShellFolder getLinkLocation()  {
 854         return getLinkLocation(true);
 855     }
 856 
 857     private Win32ShellFolder2 getLinkLocation(final boolean resolve) {
 858         return invoke(new Callable<Win32ShellFolder2>() {
 859             public Win32ShellFolder2 call() {
 860                 if (!isLink()) {
 861                     return null;
 862                 }
 863 
 864                 Win32ShellFolder2 location = null;
 865                 long linkLocationPIDL = getLinkLocation(getParentIShellFolder(),
 866                         getRelativePIDL(), resolve);
 867                 if (linkLocationPIDL != 0) {
 868                     try {
 869                         location =
 870                                 Win32ShellFolderManager2.createShellFolderFromRelativePIDL(getDesktop(),
 871                                         linkLocationPIDL);
 872                     } catch (InterruptedException e) {
 873                         // Return null
 874                     } catch (InternalError e) {
 875                         // Could be a link to a non-bindable object, such as a network connection
 876                         // TODO: getIShellFolder() should throw FileNotFoundException instead
 877                     }
 878                 }
 879                 return location;
 880             }
 881         });
 882     }
 883 
 884     // Parse a display name into a PIDL relative to the current IShellFolder.
 885     long parseDisplayName(final String name) throws IOException, InterruptedException {
 886         return invoke(new Callable<Long>() {
 887             public Long call() throws IOException {
 888                 return parseDisplayName0(getIShellFolder(), name);
 889             }
 890         }, IOException.class);
 891     }
 892 
 893     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 894     private static native long parseDisplayName0(long pIShellFolder, String name) throws IOException;
 895 
 896     // Return the display name of a shell folder
 897     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 898     private static native String getDisplayNameOf(long parentIShellFolder,
 899                                                   long relativePIDL,
 900                                                   int attrs);
 901 
 902     // Returns data of all Known Folders registered in the system
 903     private static native KnownFolderDefinition[] loadKnownFolders();
 904 
 905     /**
 906      * @return The name used to display this shell folder
 907      */
 908     public String getDisplayName() {
 909         if (displayName == null) {
 910             displayName =
 911                 invoke(new Callable<String>() {
 912                     public String call() {
 913                         return getDisplayNameOf(getParentIShellFolder(),
 914                                 getRelativePIDL(), SHGDN_NORMAL);
 915                     }
 916                 });
 917         }
 918         return displayName;
 919     }
 920 
 921     // Return the folder type of a shell folder
 922     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 923     private static native String getFolderType(long pIDL);
 924 
 925     /**
 926      * @return The type of shell folder as a string
 927      */
 928     public String getFolderType() {
 929         if (folderType == null) {
 930             final long absolutePIDL = getAbsolutePIDL();
 931             folderType =
 932                 invoke(new Callable<String>() {
 933                     public String call() {
 934                         return getFolderType(absolutePIDL);
 935                     }
 936                 });
 937         }
 938         return folderType;
 939     }
 940 
 941     // Return the executable type of a file system shell folder
 942     private native String getExecutableType(String path);
 943 
 944     /**
 945      * @return The executable type as a string
 946      */
 947     public String getExecutableType() {
 948         if (!isFileSystem()) {
 949             return null;
 950         }
 951         return getExecutableType(getAbsolutePath());
 952     }
 953 
 954 
 955 
 956     // Icons
 957 
 958     private static Map<Integer, Image> smallSystemImages = new HashMap<>();
 959     private static Map<Integer, Image> largeSystemImages = new HashMap<>();
 960     private static Map<Integer, Image> smallLinkedSystemImages = new HashMap<>();
 961     private static Map<Integer, Image> largeLinkedSystemImages = new HashMap<>();
 962 
 963     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 964     private static native long getIShellIcon(long pIShellFolder);
 965 
 966     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 967     private static native int getIconIndex(long parentIShellIcon, long relativePIDL);
 968 
 969     // Return the icon of a file system shell folder in the form of an HICON
 970     private static native long getIcon(String absolutePath, boolean getLargeIcon);
 971 
 972     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 973     private static native long extractIcon(long parentIShellFolder, long relativePIDL,
 974                                            boolean getLargeIcon, boolean getDefaultIcon);
 975 
 976     // Returns an icon from the Windows system icon list in the form of an HICON
 977     private static native long getSystemIcon(int iconID);
 978     private static native long getIconResource(String libName, int iconID,
 979                                                int cxDesired, int cyDesired,
 980                                                boolean useVGAColors);
 981                                                // Note: useVGAColors is ignored on XP and later
 982 
 983     // Return the bits from an HICON.  This has a side effect of setting
 984     // the imageHash variable for efficient caching / comparing.
 985     private static native int[] getIconBits(long hIcon);
 986     // Dispose the HICON
 987     private static native void disposeIcon(long hIcon);
 988 
 989     // Get buttons from native toolbar implementation.
 990     static native int[] getStandardViewButton0(int iconIndex, boolean small);
 991 
 992     // Should be called from the COM thread
 993     private long getIShellIcon() {
 994         if (pIShellIcon == -1L) {
 995             pIShellIcon = getIShellIcon(getIShellFolder());
 996         }
 997 
 998         return pIShellIcon;
 999     }
1000 
1001     private static Image makeIcon(long hIcon) {
1002         if (hIcon != 0L && hIcon != -1L) {
1003             // Get the bits.  This has the side effect of setting the imageHash value for this object.
1004             final int[] iconBits = getIconBits(hIcon);
1005             // icons are always square
1006             final int size = (int)Math.sqrt(iconBits.length);
1007             if (iconBits != null) {
1008                 final BufferedImage img = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
1009                 img.setRGB(0, 0, size, size, iconBits, 0, size);
1010                 return img;
1011             }
1012         }
1013         return null;
1014     }
1015 
1016 
1017     /**
1018      * @return The icon image used to display this shell folder
1019      */
1020     public Image getIcon(final boolean getLargeIcon) {
1021         Image icon = getLargeIcon ? largeIcon : smallIcon;
1022         if (icon == null) {
1023             icon =
1024                 invoke(new Callable<Image>() {
1025                     public Image call() {
1026                         Image newIcon = null;
1027                         if (isLink()) {
1028                             Win32ShellFolder2 folder = getLinkLocation(false);
1029                             if (folder != null && folder.isLibrary()) {
1030                                 return folder.getIcon(getLargeIcon);
1031                             }
1032                         }
1033                         if (isFileSystem() || isLibrary()) {
1034                             long parentIShellIcon = (parent != null)
1035                                 ? ((Win32ShellFolder2) parent).getIShellIcon()
1036                                 : 0L;
1037                             long relativePIDL = getRelativePIDL();
1038 
1039                             // These are cached per type (using the index in the system image list)
1040                             int index = getIconIndex(parentIShellIcon, relativePIDL);
1041                             if (index > 0) {
1042                                 Map<Integer, Image> imageCache;
1043                                 if (isLink()) {
1044                                     imageCache = getLargeIcon ? largeLinkedSystemImages : smallLinkedSystemImages;
1045                                 } else {
1046                                     imageCache = getLargeIcon ? largeSystemImages : smallSystemImages;
1047                                 }
1048                                 newIcon = imageCache.get(Integer.valueOf(index));
1049                                 if (newIcon == null) {
1050                                     long hIcon = getIcon(getAbsolutePath(), getLargeIcon);
1051                                     newIcon = makeIcon(hIcon);
1052                                     disposeIcon(hIcon);
1053                                     if (newIcon != null) {
1054                                         imageCache.put(Integer.valueOf(index), newIcon);
1055                                     }
1056                                 }
1057                             }
1058                         }
1059 
1060                         if (newIcon == null) {
1061                             // These are only cached per object
1062                             long hIcon = extractIcon(getParentIShellFolder(),
1063                                     getRelativePIDL(), getLargeIcon, false);
1064                             // E_PENDING: loading can take time so get the default
1065                             if(hIcon <= 0) {
1066                                 hIcon = extractIcon(getParentIShellFolder(),
1067                                          getRelativePIDL(), getLargeIcon, true);
1068                                 if(hIcon <= 0) {
1069                                     if (isDirectory()) {
1070                                         return getShell32Icon(4, getLargeIcon);
1071                                     } else {
1072                                         return getShell32Icon(1, getLargeIcon);
1073                                     }
1074                                 }
1075                             }
1076                             newIcon = makeIcon(hIcon);
1077                             disposeIcon(hIcon);
1078                         }
1079 
1080                         if (newIcon == null) {
1081                             newIcon = Win32ShellFolder2.super.getIcon(getLargeIcon);
1082                         }
1083                         return newIcon;
1084                     }
1085                 });
1086             if (getLargeIcon) {
1087                 largeIcon = icon;
1088             } else {
1089                 smallIcon = icon;
1090             }
1091         }
1092         return icon;
1093     }
1094 
1095     /**
1096      * Gets an icon from the Windows system icon list as an {@code Image}
1097      */
1098     static Image getSystemIcon(SystemIcon iconType) {
1099         long hIcon = getSystemIcon(iconType.getIconID());
1100         Image icon = makeIcon(hIcon);
1101         disposeIcon(hIcon);
1102         return icon;
1103     }
1104 
1105     /**
1106      * Gets an icon from the Windows system icon list as an {@code Image}
1107      */
1108     static Image getShell32Icon(int iconID, boolean getLargeIcon) {
1109         boolean useVGAColors = true; // Will be ignored on XP and later
1110 
1111         int size = getLargeIcon ? 32 : 16;
1112 
1113         Toolkit toolkit = Toolkit.getDefaultToolkit();
1114         String shellIconBPP = (String)toolkit.getDesktopProperty("win.icon.shellIconBPP");
1115         if (shellIconBPP != null) {
1116             useVGAColors = shellIconBPP.equals("4");
1117         }
1118 
1119         long hIcon = getIconResource("shell32.dll", iconID, size, size, useVGAColors);
1120         if (hIcon != 0) {
1121             Image icon = makeIcon(hIcon);
1122             disposeIcon(hIcon);
1123             return icon;
1124         }
1125         return null;
1126     }
1127 
1128     /**
1129      * Returns the canonical form of this abstract pathname.  Equivalent to
1130      * <code>new&nbsp;Win32ShellFolder2(getParentFile(), this.{@link java.io.File#getCanonicalPath}())</code>.
1131      *
1132      * @see java.io.File#getCanonicalFile
1133      */
1134     public File getCanonicalFile() throws IOException {
1135         return this;
1136     }
1137 
1138     /*
1139      * Indicates whether this is a special folder (includes My Documents)
1140      */
1141     public boolean isSpecial() {
1142         return isPersonal || !isFileSystem() || (this == getDesktop());
1143     }
1144 
1145     /**
1146      * Compares this object with the specified object for order.
1147      *
1148      * @see sun.awt.shell.ShellFolder#compareTo(File)
1149      */
1150     public int compareTo(File file2) {
1151         if (!(file2 instanceof Win32ShellFolder2)) {
1152             if (isFileSystem() && !isSpecial()) {
1153                 return super.compareTo(file2);
1154             } else {
1155                 return -1; // Non-file shellfolders sort before files
1156             }
1157         }
1158         return Win32ShellFolderManager2.compareShellFolders(this, (Win32ShellFolder2) file2);
1159     }
1160 
1161     // native constants from commctrl.h
1162     private static final int LVCFMT_LEFT = 0;
1163     private static final int LVCFMT_RIGHT = 1;
1164     private static final int LVCFMT_CENTER = 2;
1165 
1166     public ShellFolderColumnInfo[] getFolderColumns() {
1167         ShellFolder library = resolveLibrary();
1168         if (library != null) return library.getFolderColumns();
1169         return invoke(new Callable<ShellFolderColumnInfo[]>() {
1170             public ShellFolderColumnInfo[] call() {
1171                 ShellFolderColumnInfo[] columns = doGetColumnInfo(getIShellFolder());
1172 
1173                 if (columns != null) {
1174                     List<ShellFolderColumnInfo> notNullColumns =
1175                             new ArrayList<ShellFolderColumnInfo>();
1176                     for (int i = 0; i < columns.length; i++) {
1177                         ShellFolderColumnInfo column = columns[i];
1178                         if (column != null) {
1179                             column.setAlignment(column.getAlignment() == LVCFMT_RIGHT
1180                                     ? SwingConstants.RIGHT
1181                                     : column.getAlignment() == LVCFMT_CENTER
1182                                     ? SwingConstants.CENTER
1183                                     : SwingConstants.LEADING);
1184 
1185                             column.setComparator(new ColumnComparator(Win32ShellFolder2.this, i));
1186 
1187                             notNullColumns.add(column);
1188                         }
1189                     }
1190                     columns = new ShellFolderColumnInfo[notNullColumns.size()];
1191                     notNullColumns.toArray(columns);
1192                 }
1193                 return columns;
1194             }
1195         });
1196     }
1197 
1198     public Object getFolderColumnValue(final int column) {
1199         if(!isLibrary()) {
1200             ShellFolder library = resolveLibrary();
1201             if (library != null) return library.getFolderColumnValue(column);
1202         }
1203         return invoke(new Callable<Object>() {
1204             public Object call() {
1205                 return doGetColumnValue(getParentIShellFolder(), getRelativePIDL(), column);
1206             }
1207         });
1208     }
1209 
1210     boolean isLibrary() {
1211         return isLib;
1212     }
1213 
1214     private ShellFolder resolveLibrary() {
1215         for (ShellFolder f = this; f != null; f = f.parent) {
1216             if (!f.isFileSystem()) {
1217                 if (f instanceof Win32ShellFolder2 &&
1218                                            ((Win32ShellFolder2)f).isLibrary()) {
1219                     try {
1220                         return getShellFolder(new File(getPath()));
1221                     } catch (FileNotFoundException e) {
1222                     }
1223                 }
1224                 break;
1225             }
1226         }
1227         return null;
1228     }
1229 
1230     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
1231     private native ShellFolderColumnInfo[] doGetColumnInfo(long iShellFolder2);
1232 
1233     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
1234     private native Object doGetColumnValue(long parentIShellFolder2, long childPIDL, int columnIdx);
1235 
1236     // NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
1237     private static native int compareIDsByColumn(long pParentIShellFolder, long pidl1, long pidl2, int columnIdx);
1238 
1239 
1240     public void sortChildren(final List<? extends File> files) {
1241         // To avoid loads of synchronizations with Invoker and improve performance we
1242         // synchronize the whole code of the sort method once
1243         invoke(new Callable<Void>() {
1244             public Void call() {
1245                 Collections.sort(files, new ColumnComparator(Win32ShellFolder2.this, 0));
1246 
1247                 return null;
1248             }
1249         });
1250     }
1251 
1252     private static class ColumnComparator implements Comparator<File> {
1253         private final Win32ShellFolder2 shellFolder;
1254 
1255         private final int columnIdx;
1256 
1257         public ColumnComparator(Win32ShellFolder2 shellFolder, int columnIdx) {
1258             this.shellFolder = shellFolder;
1259             this.columnIdx = columnIdx;
1260         }
1261 
1262         // compares 2 objects within this folder by the specified column
1263         public int compare(final File o, final File o1) {
1264             Integer result = invoke(new Callable<Integer>() {
1265                 public Integer call() {
1266                     if (o instanceof Win32ShellFolder2
1267                         && o1 instanceof Win32ShellFolder2) {
1268                         // delegates comparison to native method
1269                         return compareIDsByColumn(shellFolder.getIShellFolder(),
1270                             ((Win32ShellFolder2) o).getRelativePIDL(),
1271                             ((Win32ShellFolder2) o1).getRelativePIDL(),
1272                             columnIdx);
1273                     }
1274                     return 0;
1275                 }
1276             });
1277 
1278             return result == null ? 0 : result;
1279         }
1280     }
1281 
1282     // Extracts libraries and their default save locations from Known Folders list
1283     private static List<KnownFolderDefinition> getLibraries() {
1284         return invoke(new Callable<List<KnownFolderDefinition>>() {
1285             @Override
1286             public List<KnownFolderDefinition> call() throws Exception {
1287                 KnownFolderDefinition[] all = loadKnownFolders();
1288                 List<KnownFolderDefinition> folders = new ArrayList<>();
1289                 if (all != null) {
1290                     for (KnownFolderDefinition kf : all) {
1291                         if (kf.relativePath == null || kf.parsingName == null ||
1292                                 kf.saveLocation == null) {
1293                             continue;
1294                         }
1295                         folders.add(kf);
1296                     }
1297                 }
1298                 return folders;
1299             }
1300         });
1301     }
1302 
1303 }