jdk-sandbox: comparison jdk/src/windows/classes/sun/awt/shell/Win32ShellFolder2.java

equal deleted inserted replaced

-:4d54c9133cda
+:5052722686e2
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.*;
+import java.util.concurrent.*;
 import javax.swing.SwingConstants;
 // NOTE: This class supersedes Win32ShellFolder, which was removed from
 //       distribution after version 1.4.2.
 long relativePIDL;
 boolean disposed;
 public void dispose() {
 if (disposed) return;
-if (relativePIDL != 0) {
+ShellFolder.getInvoker().invoke(new Callable<Void>() {
-releasePIDL(relativePIDL);
+public Void call() throws Exception {
-}
+if (relativePIDL != 0) {
-if (absolutePIDL != 0) {
+releasePIDL(relativePIDL);
-releasePIDL(absolutePIDL);
+}
-}
+if (absolutePIDL != 0) {
-if (pIShellFolder != 0) {
+releasePIDL(absolutePIDL);
-releaseIShellFolder(pIShellFolder);
+}
-}
+if (pIShellFolder != 0) {
+releaseIShellFolder(pIShellFolder);
+}
+return null;
+}
+});
 disposed = true;
 }
 }
 FolderDisposer disposer = new FolderDisposer();
 private void setIShellFolder(long pIShellFolder) {
 /*
 * The following is to identify the My Documents folder as being special
 */
 private boolean isPersonal;
+private static String composePathForCsidl(int csidl) throws IOException {
+String path = getFileSystemPath(csidl);
+return path == null
+? ("ShellFolder: 0x" + Integer.toHexString(csidl))
+: path;
+}
 /**
 * Create a system special shell folder, such as the
 * desktop or Network Neighborhood.
 */
-Win32ShellFolder2(int csidl) throws IOException {
+Win32ShellFolder2(final int csidl) throws IOException {
 // Desktop is parent of DRIVES and NETWORK, not necessarily
 // other special shell folders.
-super(null,
+super(null, composePathForCsidl(csidl));
-(getFileSystemPath(csidl) == null)
+ShellFolder.getInvoker().invoke(new Callable<Void>() {
-? ("ShellFolder: 0x"+Integer.toHexString(csidl)) : getFileSystemPath(csidl));
+public Void call() throws Exception {
 if (csidl == DESKTOP) {
 initDesktop();
-} else {
-initSpecial(getDesktop().getIShellFolder(), csidl);
-// At this point, the native method initSpecial() has set our relativePIDL
-// relative to the Desktop, which may not be our immediate parent. We need
-// to traverse this ID list and break it into a chain of shell folders from
-// the top, with each one having an immediate parent and a relativePIDL
-// relative to that parent.
-long pIDL = disposer.relativePIDL;
-parent = getDesktop();
-while (pIDL != 0) {
-// Get a child pidl relative to 'parent'
-long childPIDL = copyFirstPIDLEntry(pIDL);
-if (childPIDL != 0) {
-// Get a handle to the the rest of the ID list
-// i,e, parent's grandchilren and down
-pIDL = getNextPIDLEntry(pIDL);
-if (pIDL != 0) {
-// Now we know that parent isn't immediate to 'this' because it
-// has a continued ID list. Create a shell folder for this child
-// pidl and make it the new 'parent'.
-parent = new Win32ShellFolder2((Win32ShellFolder2)parent, childPIDL);
-} else {
-// No grandchildren means we have arrived at the parent of 'this',
-// and childPIDL is directly relative to parent.
-disposer.relativePIDL = childPIDL;
-}
 } else {
-break;
+initSpecial(getDesktop().getIShellFolder(), csidl);
-}
+// At this point, the native method initSpecial() has set our relativePIDL
-}
+// relative to the Desktop, which may not be our immediate parent. We need
-}
+// to traverse this ID list and break it into a chain of shell folders from
+// the top, with each one having an immediate parent and a relativePIDL
+// relative to that parent.
+long pIDL = disposer.relativePIDL;
+parent = getDesktop();
+while (pIDL != 0) {
+// Get a child pidl relative to 'parent'
+long childPIDL = copyFirstPIDLEntry(pIDL);
+if (childPIDL != 0) {
+// Get a handle to the the rest of the ID list
+// i,e, parent's grandchilren and down
+pIDL = getNextPIDLEntry(pIDL);
+if (pIDL != 0) {
+// Now we know that parent isn't immediate to 'this' because it
+// has a continued ID list. Create a shell folder for this child
+// pidl and make it the new 'parent'.
+parent = new Win32ShellFolder2((Win32ShellFolder2) parent, childPIDL);
+} else {
+// No grandchildren means we have arrived at the parent of 'this',
+// and childPIDL is directly relative to parent.
+disposer.relativePIDL = childPIDL;
+}
+} else {
+break;
+}
+}
+}
+return null;
+}
+});
 sun.java2d.Disposer.addRecord(this, disposer);
 }
 /**
 * Creates a shell folder with a parent and relative PIDL
 */
-Win32ShellFolder2(Win32ShellFolder2 parent, long relativePIDL) {
+Win32ShellFolder2(final Win32ShellFolder2 parent, final long relativePIDL) {
-super(parent, getFileSystemPath(parent.getIShellFolder(), relativePIDL));
+super(parent,
+ShellFolder.getInvoker().invoke(new Callable<String>() {
+public String call() throws Exception {
+return getFileSystemPath(parent.getIShellFolder(), relativePIDL);
+}
+})
+);
 this.disposer.relativePIDL = relativePIDL;
 getAbsolutePath();
 sun.java2d.Disposer.addRecord(this, disposer);
 }
 // Initializes the desktop shell folder
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native void initDesktop();
 // Initializes a special, non-file system shell folder
 // from one of the above constants
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native void initSpecial(long desktopIShellFolder, int csidl);
 /** Marks this folder as being the My Documents (Personal) folder */
 public void setIsPersonal() {
 isPersonal = true;
 * @return a <code>java.io.File</code> replacement object. If the folder
 * is a not a normal directory, then returns the first non-removable
 * drive (normally "C:\").
 */
 protected Object writeReplace() throws java.io.ObjectStreamException {
-if (isFileSystem()) {
+return ShellFolder.getInvoker().invoke(new Callable<File>() {
-return new File(getPath());
+public File call() throws Exception {
-} else {
+if (isFileSystem()) {
-Win32ShellFolder2 drives = Win32ShellFolderManager2.getDrives();
+return new File(getPath());
-if (drives != null) {
+} else {
-File[] driveRoots = drives.listFiles();
+Win32ShellFolder2 drives = Win32ShellFolderManager2.getDrives();
-if (driveRoots != null) {
+if (drives != null) {
-for (int i = 0; i < driveRoots.length; i++) {
+File[] driveRoots = drives.listFiles();
-if (driveRoots[i] instanceof Win32ShellFolder2) {
+if (driveRoots != null) {
-Win32ShellFolder2 sf = (Win32ShellFolder2)driveRoots[i];
+for (int i = 0; i < driveRoots.length; i++) {
-if (sf.isFileSystem() && !sf.hasAttribute(ATTRIB_REMOVABLE)) {
+if (driveRoots[i] instanceof Win32ShellFolder2) {
-return new File(sf.getPath());
+Win32ShellFolder2 sf = (Win32ShellFolder2) driveRoots[i];
+if (sf.isFileSystem() && !sf.hasAttribute(ATTRIB_REMOVABLE)) {
+return new File(sf.getPath());
+}
+}
 }
 }
 }
-}
+// Ouch, we have no hard drives. Return something "valid" anyway.
-}
+return new File("C:\\");
-// Ouch, we have no hard drives. Return something "valid" anyway.
+}
-return new File("C:\\");
+}
-}
+});
 }
 /**
 * Finalizer to clean up any COM objects or PIDLs used by this object.
 // Release a PIDL object
 // Needs to be accessible to Win32ShellFolderManager2
 static native void releasePIDL(long pIDL);
 // Release an IShellFolder object
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native void releaseIShellFolder(long pIShellFolder);
 /**
 * Accessor for IShellFolder
 */
 public long getIShellFolder() {
 if (disposer.pIShellFolder == 0) {
-assert(isDirectory());
+disposer.pIShellFolder =
-assert(parent != null);
+ShellFolder.getInvoker().invoke(new Callable<Long>() {
-long parentIShellFolder = getParentIShellFolder();
+public Long call() throws Exception {
-if (parentIShellFolder == 0) {
+assert(isDirectory());
-throw new InternalError("Parent IShellFolder was null for " + getAbsolutePath());
+assert(parent != null);
-}
+long parentIShellFolder = getParentIShellFolder();
-// We are a directory with a parent and a relative PIDL.
+if (parentIShellFolder == 0) {
-// We want to bind to the parent so we get an IShellFolder instance associated with us.
+throw new InternalError("Parent IShellFolder was null for "
-disposer.pIShellFolder = bindToObject(parentIShellFolder, disposer.relativePIDL);
++ getAbsolutePath());
-if (disposer.pIShellFolder == 0) {
+}
-throw new InternalError("Unable to bind " + getAbsolutePath() + " to parent");
+// We are a directory with a parent and a relative PIDL.
-}
+// We want to bind to the parent so we get an
+// IShellFolder instance associated with us.
+long pIShellFolder = bindToObject(parentIShellFolder,
+disposer.relativePIDL);
+if (pIShellFolder == 0) {
+throw new InternalError("Unable to bind "
++ getAbsolutePath() + " to parent");
+}
+return pIShellFolder;
+}
+});
 }
 return disposer.pIShellFolder;
 }
 /**
 }
 return false;
 }
-private static boolean pidlsEqual(long pIShellFolder, long pidl1, long pidl2) {
+private static boolean pidlsEqual(final long pIShellFolder, final long pidl1, final long pidl2) {
-return (compareIDs(pIShellFolder, pidl1, pidl2) == 0);
+return ShellFolder.getInvoker().invoke(new Callable<Boolean>() {
-}
+public Boolean call() throws Exception {
+return (compareIDs(pIShellFolder, pidl1, pidl2) == 0);
+}
+});
+}
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native int compareIDs(long pParentIShellFolder, long pidl1, long pidl2);
+private Boolean cachedIsFileSystem;
 /**
 * @return Whether this is a file system shell folder
 */
-public boolean isFileSystem() {
+public synchronized boolean isFileSystem() {
-return hasAttribute(ATTRIB_FILESYSTEM);
+if (cachedIsFileSystem == null) {
+cachedIsFileSystem = hasAttribute(ATTRIB_FILESYSTEM);
+}
+return cachedIsFileSystem;
 }
 /**
 * Return whether the given attribute flag is set for this object
 */
-public boolean hasAttribute(int attribute) {
+public boolean hasAttribute(final int attribute) {
-// Caching at this point doesn't seem to be cost efficient
+return ShellFolder.getInvoker().invoke(new Callable<Boolean>() {
-return (getAttributes0(getParentIShellFolder(), getRelativePIDL(), attribute) & attribute) != 0;
+public Boolean call() throws Exception {
+// Caching at this point doesn't seem to be cost efficient
+return (getAttributes0(getParentIShellFolder(),
+getRelativePIDL(), attribute)
+& attribute) != 0;
+}
+});
 }
 /**
 * Returns the queried attributes specified in attrsMask.
 *
 * Could plausibly be used for attribute caching but have to be
 * very careful not to touch network drives and file system roots
 * with a full attrsMask
-*/
+* NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
+*/
 private static native int getAttributes0(long pParentIShellFolder, long pIDL, int attrsMask);
 // Return the path to the underlying file system object
-private static String getFileSystemPath(long parentIShellFolder, long relativePIDL) {
+private static String getFileSystemPath(final long parentIShellFolder, final long relativePIDL) {
-int linkedFolder = ATTRIB_LINK | ATTRIB_FOLDER;
+return ShellFolder.getInvoker().invoke(new Callable<String>() {
-if (parentIShellFolder == Win32ShellFolderManager2.getNetwork().getIShellFolder() &&
+public String call() throws Exception {
-getAttributes0(parentIShellFolder, relativePIDL, linkedFolder) == linkedFolder) {
+int linkedFolder = ATTRIB_LINK | ATTRIB_FOLDER;
+if (parentIShellFolder == Win32ShellFolderManager2.getNetwork().getIShellFolder() &&
-String s =
+getAttributes0(parentIShellFolder, relativePIDL, linkedFolder) == linkedFolder) {
-getFileSystemPath(Win32ShellFolderManager2.getDesktop().getIShellFolder(),
-getLinkLocation(parentIShellFolder, relativePIDL, false));
+String s =
-if (s != null && s.startsWith("\\\\")) {
+getFileSystemPath(Win32ShellFolderManager2.getDesktop().getIShellFolder(),
-return s;
+getLinkLocation(parentIShellFolder, relativePIDL, false));
-}
+if (s != null && s.startsWith("\\\\")) {
-}
+return s;
-return getDisplayNameOf(parentIShellFolder, relativePIDL, SHGDN_NORMAL | SHGDN_FORPARSING);
+}
 }
+return getDisplayNameOf(parentIShellFolder, relativePIDL, SHGDN_FORPARSING);
+}
+});
+}
 // Needs to be accessible to Win32ShellFolderManager2
-static native String getFileSystemPath(int csidl) throws IOException;
+static String getFileSystemPath(final int csidl) throws IOException {
+return ShellFolder.getInvoker().invoke(new Callable<String>() {
+public String call() throws Exception {
+return getFileSystemPath0(csidl);
+}
+});
+}
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
+private static native String getFileSystemPath0(int csidl) throws IOException;
 // Return whether the path is a network root.
 // Path is assumed to be non-null
 private static boolean isNetworkRoot(String path) {
 return (path.equals("\\\\") || path.equals("\\") || path.equals("//") || path.equals("/"));
 /*
 * Functions for enumerating an IShellFolder's children
 */
 // Returns an IEnumIDList interface for an IShellFolder.  The value
 // returned must be released using releaseEnumObjects().
-private long getEnumObjects(long pIShellFolder, boolean includeHiddenFiles) {
+private long getEnumObjects(long pIShellFolder, final boolean includeHiddenFiles) {
-boolean isDesktop = (disposer.pIShellFolder == getDesktopIShellFolder());
+final boolean isDesktop = (disposer.pIShellFolder == getDesktopIShellFolder());
-return getEnumObjects(disposer.pIShellFolder, isDesktop, includeHiddenFiles);
+return ShellFolder.getInvoker().invoke(new Callable<Long>() {
-}
+public Long call() throws Exception {
+return getEnumObjects(disposer.pIShellFolder, isDesktop, includeHiddenFiles);
+}
+});
+}
 // Returns an IEnumIDList interface for an IShellFolder.  The value
 // returned must be released using releaseEnumObjects().
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native long getEnumObjects(long pIShellFolder, boolean isDesktop,
 boolean includeHiddenFiles);
 // Returns the next sequential child as a relative PIDL
 // from an IEnumIDList interface.  The value returned must
 // be released using releasePIDL().
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native long getNextChild(long pEnumObjects);
 // Releases the IEnumIDList interface
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native void releaseEnumObjects(long pEnumObjects);
 // Returns the IShellFolder of a child from a parent IShellFolder
 // and a relative PIDL.  The value returned must be released
 // using releaseIShellFolder().
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native long bindToObject(long parentIShellFolder, long pIDL);
 /**
 * @return An array of shell folders that are children of this shell folder
 *         object. The array will be empty if the folder is empty.  Returns
 *         <code>null</code> if this shellfolder does not denote a directory.
 */
-public File[] listFiles(boolean includeHiddenFiles) {
+public File[] listFiles(final boolean includeHiddenFiles) {
 SecurityManager security = System.getSecurityManager();
 if (security != null) {
 security.checkRead(getPath());
 }
-if (!isDirectory()) {
-return null;
+return ShellFolder.getInvoker().invoke(new Callable<File[]>() {
-}
+public File[] call() throws Exception {
-// Links to directories are not directories and cannot be parents.
+if (!isDirectory()) {
-// This does not apply to folders in My Network Places (NetHood)
+return null;
-// because they are both links and real directories!
+}
-if (isLink() && !hasAttribute(ATTRIB_FOLDER)) {
+// Links to directories are not directories and cannot be parents.
-return new File[0];
+// This does not apply to folders in My Network Places (NetHood)
-}
+// because they are both links and real directories!
+if (isLink() && !hasAttribute(ATTRIB_FOLDER)) {
-Win32ShellFolder2 desktop = Win32ShellFolderManager2.getDesktop();
-Win32ShellFolder2 personal = Win32ShellFolderManager2.getPersonal();
-// If we are a directory, we have a parent and (at least) a
-// relative PIDL. We must first ensure we are bound to the
-// parent so we have an IShellFolder to query.
-long pIShellFolder = getIShellFolder();
-// Now we can enumerate the objects in this folder.
-ArrayList<Win32ShellFolder2> list = new ArrayList<Win32ShellFolder2>();
-long pEnumObjects = getEnumObjects(pIShellFolder, includeHiddenFiles);
-if (pEnumObjects != 0) {
-long childPIDL;
-int testedAttrs = ATTRIB_FILESYSTEM | ATTRIB_FILESYSANCESTOR;
-do {
-if (Thread.currentThread().isInterrupted()) {
 return new File[0];
 }
-childPIDL = getNextChild(pEnumObjects);
-boolean releasePIDL = true;
+Win32ShellFolder2 desktop = Win32ShellFolderManager2.getDesktop();
-if (childPIDL != 0 &&
+Win32ShellFolder2 personal = Win32ShellFolderManager2.getPersonal();
-(getAttributes0(pIShellFolder, childPIDL, testedAttrs) & testedAttrs) != 0) {
-Win32ShellFolder2 childFolder = null;
+// If we are a directory, we have a parent and (at least) a
-if (this.equals(desktop)
+// relative PIDL. We must first ensure we are bound to the
-&& personal != null
+// parent so we have an IShellFolder to query.
-&& pidlsEqual(pIShellFolder, childPIDL, personal.disposer.relativePIDL)) {
+long pIShellFolder = getIShellFolder();
-childFolder = personal;
+// Now we can enumerate the objects in this folder.
-} else {
+ArrayList<Win32ShellFolder2> list = new ArrayList<Win32ShellFolder2>();
-childFolder = new Win32ShellFolder2(this, childPIDL);
+long pEnumObjects = getEnumObjects(pIShellFolder, includeHiddenFiles);
-releasePIDL = false;
+if (pEnumObjects != 0) {
-}
+long childPIDL;
-list.add(childFolder);
+int testedAttrs = ATTRIB_FILESYSTEM | ATTRIB_FILESYSANCESTOR;
-}
+do {
-if (releasePIDL) {
+childPIDL = getNextChild(pEnumObjects);
-releasePIDL(childPIDL);
+boolean releasePIDL = true;
-}
+if (childPIDL != 0 &&
-} while (childPIDL != 0);
+(getAttributes0(pIShellFolder, childPIDL, testedAttrs) & testedAttrs) != 0) {
-releaseEnumObjects(pEnumObjects);
+Win32ShellFolder2 childFolder;
-}
+if (Win32ShellFolder2.this.equals(desktop)
-return list.toArray(new ShellFolder[list.size()]);
+&& personal != null
+&& pidlsEqual(pIShellFolder, childPIDL, personal.disposer.relativePIDL)) {
+childFolder = personal;
+} else {
+childFolder = new Win32ShellFolder2(Win32ShellFolder2.this, childPIDL);
+releasePIDL = false;
+}
+list.add(childFolder);
+}
+if (releasePIDL) {
+releasePIDL(childPIDL);
+}
+} while (childPIDL != 0 && !Thread.currentThread().isInterrupted());
+releaseEnumObjects(pEnumObjects);
+}
+return Thread.currentThread().isInterrupted()
+? new File[0]
+: list.toArray(new ShellFolder[list.size()]);
+}
+});
 }
 /**
 * Look for (possibly special) child folder by it's path
 *
 * @return The child shellfolder, or null if not found.
 */
-Win32ShellFolder2 getChildByPath(String filePath) {
+Win32ShellFolder2 getChildByPath(final String filePath) {
-long pIShellFolder = getIShellFolder();
+return ShellFolder.getInvoker().invoke(new Callable<Win32ShellFolder2>() {
-long pEnumObjects =  getEnumObjects(pIShellFolder, true);
+public Win32ShellFolder2 call() throws Exception {
-Win32ShellFolder2 child = null;
+long pIShellFolder = getIShellFolder();
-long childPIDL;
+long pEnumObjects = getEnumObjects(pIShellFolder, true);
+Win32ShellFolder2 child = null;
-while ((childPIDL = getNextChild(pEnumObjects)) != 0) {
+long childPIDL = 0;
-if (getAttributes0(pIShellFolder, childPIDL, ATTRIB_FILESYSTEM) != 0) {
-String path = getFileSystemPath(pIShellFolder, childPIDL);
+while ((childPIDL = getNextChild(pEnumObjects)) != 0) {
-if (path != null && path.equalsIgnoreCase(filePath)) {
+if (getAttributes0(pIShellFolder, childPIDL, ATTRIB_FILESYSTEM) != 0) {
-long childIShellFolder = bindToObject(pIShellFolder, childPIDL);
+String path = getFileSystemPath(pIShellFolder, childPIDL);
-child = new Win32ShellFolder2(this, childIShellFolder, childPIDL, path);
+if (path != null && path.equalsIgnoreCase(filePath)) {
-break;
+long childIShellFolder = bindToObject(pIShellFolder, childPIDL);
-}
+child = new Win32ShellFolder2(Win32ShellFolder2.this,
-}
+childIShellFolder, childPIDL, path);
-releasePIDL(childPIDL);
+break;
 }
-releaseEnumObjects(pEnumObjects);
+}
-return child;
+releasePIDL(childPIDL);
 }
+releaseEnumObjects(pEnumObjects);
+return child;
+}
+});
+}
+private Boolean cachedIsLink;
 /**
 * @return Whether this shell folder is a link
 */
-public boolean isLink() {
+public synchronized boolean isLink() {
-return hasAttribute(ATTRIB_LINK);
+if (cachedIsLink == null) {
+cachedIsLink = hasAttribute(ATTRIB_LINK);
+}
+return cachedIsLink;
 }
 /**
 * @return Whether this shell folder is marked as hidden
 */
 return hasAttribute(ATTRIB_HIDDEN);
 }
 // Return the link location of a shell folder
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native long getLinkLocation(long parentIShellFolder,
 long relativePIDL, boolean resolve);
 /**
 * @return The shell folder linked to by this shell folder, or null
 */
 public ShellFolder getLinkLocation()  {
 return getLinkLocation(true);
 }
-private ShellFolder getLinkLocation(boolean resolve)  {
+private ShellFolder getLinkLocation(final boolean resolve) {
-if (!isLink()) {
+return ShellFolder.getInvoker().invoke(new Callable<ShellFolder>() {
-return null;
+public ShellFolder call() throws Exception {
-}
+if (!isLink()) {
+return null;
-ShellFolder location = null;
+}
-long linkLocationPIDL = getLinkLocation(getParentIShellFolder(),
-getRelativePIDL(), resolve);
+ShellFolder location = null;
-if (linkLocationPIDL != 0) {
+long linkLocationPIDL = getLinkLocation(getParentIShellFolder(),
-try {
+getRelativePIDL(), resolve);
-location =
+if (linkLocationPIDL != 0) {
-Win32ShellFolderManager2.createShellFolderFromRelativePIDL(getDesktop(),
+try {
-linkLocationPIDL);
+location =
-} catch (InternalError e) {
+Win32ShellFolderManager2.createShellFolderFromRelativePIDL(getDesktop(),
-// Could be a link to a non-bindable object, such as a network connection
+linkLocationPIDL);
-// TODO: getIShellFolder() should throw FileNotFoundException instead
+} catch (InternalError e) {
-}
+// Could be a link to a non-bindable object, such as a network connection
-}
+// TODO: getIShellFolder() should throw FileNotFoundException instead
-return location;
+}
+}
+return location;
+}
+});
 }
 // Parse a display name into a PIDL relative to the current IShellFolder.
-long parseDisplayName(String name) throws FileNotFoundException {
+long parseDisplayName(final String name) throws FileNotFoundException {
 try {
-return parseDisplayName0(getIShellFolder(), name);
+return ShellFolder.getInvoker().invoke(new Callable<Long>() {
-} catch (IOException e) {
+public Long call() throws Exception {
-throw new FileNotFoundException("Could not find file " + name);
+return parseDisplayName0(getIShellFolder(), name);
 }
-}
+});
+} catch (RuntimeException e) {
+if (e.getCause() instanceof IOException) {
+throw new FileNotFoundException("Could not find file " + name);
+}
+throw e;
+}
+}
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native long parseDisplayName0(long pIShellFolder, String name) throws IOException;
 // Return the display name of a shell folder
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native String getDisplayNameOf(long parentIShellFolder,
 long relativePIDL,
 int attrs);
 /**
 * @return The name used to display this shell folder
 */
 public String getDisplayName() {
 if (displayName == null) {
-displayName = getDisplayNameOf(getParentIShellFolder(), getRelativePIDL(), SHGDN_NORMAL);
+displayName =
+ShellFolder.getInvoker().invoke(new Callable<String>() {
+public String call() throws Exception {
+return getDisplayNameOf(getParentIShellFolder(),
+getRelativePIDL(), SHGDN_NORMAL);
+}
+});
 }
 return displayName;
 }
 // Return the folder type of a shell folder
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native String getFolderType(long pIDL);
 /**
 * @return The type of shell folder as a string
 */
 public String getFolderType() {
 if (folderType == null) {
-folderType = getFolderType(getAbsolutePIDL());
+final long absolutePIDL = getAbsolutePIDL();
+folderType =
+ShellFolder.getInvoker().invoke(new Callable<String>() {
+public String call() throws Exception {
+return getFolderType(absolutePIDL);
+}
+});
 }
 return folderType;
 }
 // Return the executable type of a file system shell folder
 private static Map smallSystemImages = new HashMap();
 private static Map largeSystemImages = new HashMap();
 private static Map smallLinkedSystemImages = new HashMap();
 private static Map largeLinkedSystemImages = new HashMap();
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native long getIShellIcon(long pIShellFolder);
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native int getIconIndex(long parentIShellIcon, long relativePIDL);
 // Return the icon of a file system shell folder in the form of an HICON
 private static native long getIcon(String absolutePath, boolean getLargeIcon);
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native long extractIcon(long parentIShellFolder, long relativePIDL,
 boolean getLargeIcon);
 // Returns an icon from the Windows system icon list in the form of an HICON
 private static native long getSystemIcon(int iconID);
 public static native int[] getFileChooserBitmapBits();
 private long getIShellIcon() {
 if (pIShellIcon == -1L) {
-pIShellIcon = getIShellIcon(getIShellFolder());
+pIShellIcon =
+ShellFolder.getInvoker().invoke(new Callable<Long>() {
+public Long call() throws Exception {
+return getIShellIcon(getIShellFolder());
+}
+});
 }
 return pIShellIcon;
 }
 /**
 * @return The icon image used to display this shell folder
 */
-public Image getIcon(boolean getLargeIcon) {
+public Image getIcon(final boolean getLargeIcon) {
 Image icon = getLargeIcon ? largeIcon : smallIcon;
 if (icon == null) {
-long parentIShellIcon = (parent != null) ? ((Win32ShellFolder2)parent).getIShellIcon() : 0L;
+icon =
-long relativePIDL = getRelativePIDL();
+ShellFolder.getInvoker().invoke(new Callable<Image>() {
+public Image call() throws Exception {
-if (isFileSystem()) {
+Image newIcon = null;
-// These are cached per type (using the index in the system image list)
+if (isFileSystem()) {
-int index = getIconIndex(parentIShellIcon, relativePIDL);
+long parentIShellIcon = (parent != null)
-if (index > 0) {
+? ((Win32ShellFolder2) parent).getIShellIcon()
-Map imageCache;
+: 0L;
-if (isLink()) {
+long relativePIDL = getRelativePIDL();
-imageCache = getLargeIcon ? largeLinkedSystemImages : smallLinkedSystemImages;
-} else {
+// These are cached per type (using the index in the system image list)
-imageCache = getLargeIcon ? largeSystemImages : smallSystemImages;
+int index = getIconIndex(parentIShellIcon, relativePIDL);
-}
+if (index > 0) {
-icon = (Image)imageCache.get(Integer.valueOf(index));
+Map imageCache;
-if (icon == null) {
+if (isLink()) {
-long hIcon = getIcon(getAbsolutePath(), getLargeIcon);
+imageCache = getLargeIcon ? largeLinkedSystemImages : smallLinkedSystemImages;
-icon = makeIcon(hIcon, getLargeIcon);
+} else {
-disposeIcon(hIcon);
+imageCache = getLargeIcon ? largeSystemImages : smallSystemImages;
-if (icon != null) {
+}
-imageCache.put(Integer.valueOf(index), icon);
+newIcon = (Image) imageCache.get(Integer.valueOf(index));
+if (newIcon == null) {
+long hIcon = getIcon(getAbsolutePath(), getLargeIcon);
+newIcon = makeIcon(hIcon, getLargeIcon);
+disposeIcon(hIcon);
+if (newIcon != null) {
+imageCache.put(Integer.valueOf(index), newIcon);
+}
+}
+}
 }
-}
-}
+if (newIcon == null) {
-}
+// These are only cached per object
+long hIcon = extractIcon(getParentIShellFolder(),
-if (icon == null) {
+getRelativePIDL(), getLargeIcon);
-// These are only cached per object
+newIcon = makeIcon(hIcon, getLargeIcon);
-long hIcon = extractIcon(getParentIShellFolder(), getRelativePIDL(), getLargeIcon);
+disposeIcon(hIcon);
-icon = makeIcon(hIcon, getLargeIcon);
+}
-disposeIcon(hIcon);
-}
+if (newIcon == null) {
+newIcon = Win32ShellFolder2.super.getIcon(getLargeIcon);
+}
+return newIcon;
+}
+});
 if (getLargeIcon) {
 largeIcon = icon;
 } else {
 smallIcon = icon;
 }
-}
-if (icon == null) {
-icon = super.getIcon(getLargeIcon);
 }
 return icon;
 }
 /**
 private static final int LVCFMT_LEFT = 0;
 private static final int LVCFMT_RIGHT = 1;
 private static final int LVCFMT_CENTER = 2;
 public ShellFolderColumnInfo[] getFolderColumns() {
-ShellFolderColumnInfo[] columns = doGetColumnInfo(getIShellFolder());
+return ShellFolder.getInvoker().invoke(new Callable<ShellFolderColumnInfo[]>() {
+public ShellFolderColumnInfo[] call() throws Exception {
-if (columns != null) {
+ShellFolderColumnInfo[] columns = doGetColumnInfo(getIShellFolder());
-List<ShellFolderColumnInfo> notNullColumns =
-new ArrayList<ShellFolderColumnInfo>();
+if (columns != null) {
-for (int i = 0; i < columns.length; i++) {
+List<ShellFolderColumnInfo> notNullColumns =
-ShellFolderColumnInfo column = columns[i];
+new ArrayList<ShellFolderColumnInfo>();
-if (column != null) {
+for (int i = 0; i < columns.length; i++) {
-column.setAlignment(column.getAlignment() == LVCFMT_RIGHT
+ShellFolderColumnInfo column = columns[i];
-? SwingConstants.RIGHT
+if (column != null) {
-: column.getAlignment() == LVCFMT_CENTER
+column.setAlignment(column.getAlignment() == LVCFMT_RIGHT
-? SwingConstants.CENTER
+? SwingConstants.RIGHT
-: SwingConstants.LEADING);
+: column.getAlignment() == LVCFMT_CENTER
+? SwingConstants.CENTER
-column.setComparator(new ColumnComparator(getIShellFolder(), i));
+: SwingConstants.LEADING);
-notNullColumns.add(column);
+column.setComparator(new ColumnComparator(getIShellFolder(), i));
-}
-}
+notNullColumns.add(column);
-columns = new ShellFolderColumnInfo[notNullColumns.size()];
+}
-notNullColumns.toArray(columns);
+}
-}
+columns = new ShellFolderColumnInfo[notNullColumns.size()];
-return columns;
+notNullColumns.toArray(columns);
 }
+return columns;
-public Object getFolderColumnValue(int column) {
+}
-return doGetColumnValue(getParentIShellFolder(), getRelativePIDL(), column);
+});
 }
+public Object getFolderColumnValue(final int column) {
+return ShellFolder.getInvoker().invoke(new Callable<Object>() {
+public Object call() throws Exception {
+return doGetColumnValue(getParentIShellFolder(), getRelativePIDL(), column);
+}
+});
+}
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native ShellFolderColumnInfo[] doGetColumnInfo(long iShellFolder2);
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private native Object doGetColumnValue(long parentIShellFolder2, long childPIDL, int columnIdx);
+// NOTE: this method uses COM and must be called on the 'COM thread'. See ComInvoker for the details
 private static native int compareIDsByColumn(long pParentIShellFolder, long pidl1, long pidl2, int columnIdx);
 public void sortChildren(List<? extends File> files) {
 Collections.sort(files, new ColumnComparator(getIShellFolder(), 0));
 this.parentIShellFolder = parentIShellFolder;
 this.columnIdx = columnIdx;
 }
 // compares 2 objects within this folder by the specified column
-public int compare(File o, File o1) {
+public int compare(final File o, final File o1) {
-if (o instanceof Win32ShellFolder2
+return ShellFolder.getInvoker().invoke(new Callable<Integer>() {
-&& o1 instanceof Win32ShellFolder2) {
+public Integer call() throws Exception {
-// delegates comparison to native method
+if (o instanceof Win32ShellFolder2
-return compareIDsByColumn(parentIShellFolder,
+&& o1 instanceof Win32ShellFolder2) {
-((Win32ShellFolder2) o).getRelativePIDL(),
+// delegates comparison to native method
-((Win32ShellFolder2) o1).getRelativePIDL(),
+return compareIDsByColumn(parentIShellFolder,
-columnIdx);
+((Win32ShellFolder2) o).getRelativePIDL(),
-}
+((Win32ShellFolder2) o1).getRelativePIDL(),
-return 0;
+columnIdx);
 }
-}
+return 0;
+}
+});
+}
+}
 }

changeset 2489	5052722686e2
parent 715	f16baef3a20e
child 2817	f171f2417978