1 /*
   2  * Copyright (c) 2003, 2012, 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.*;
  29 import java.awt.image.BufferedImage;
  30 
  31 import java.io.File;
  32 import java.io.FileNotFoundException;
  33 import java.io.IOException;
  34 import java.security.AccessController;
  35 import java.security.PrivilegedAction;
  36 import java.util.*;
  37 import java.util.List;
  38 import java.util.concurrent.*;
  39 
  40 import static sun.awt.shell.Win32ShellFolder2.*;
  41 import sun.awt.OSInfo;
  42 import sun.misc.ThreadGroupUtils;
  43 
  44 // NOTE: This class supersedes Win32ShellFolderManager, which was removed
  45 //       from distribution after version 1.4.2.
  46 
  47 /**
  48  * @author Michael Martak
  49  * @author Leif Samuelsson
  50  * @author Kenneth Russell
  51  * @since 1.4
  52  */
  53 
  54 public class Win32ShellFolderManager2 extends ShellFolderManager {
  55 
  56     static {
  57         // Load library here
  58         sun.awt.windows.WToolkit.loadLibraries();
  59     }
  60 
  61     public ShellFolder createShellFolder(File file) throws FileNotFoundException {
  62         try {
  63             return createShellFolder(getDesktop(), file);
  64         } catch (InterruptedException e) {
  65             throw new FileNotFoundException("Execution was interrupted");
  66         }
  67     }
  68 
  69     static Win32ShellFolder2 createShellFolder(Win32ShellFolder2 parent, File file)
  70             throws FileNotFoundException, InterruptedException {
  71         long pIDL;
  72         try {
  73             pIDL = parent.parseDisplayName(file.getCanonicalPath());
  74         } catch (IOException ex) {
  75             pIDL = 0;
  76         }
  77         if (pIDL == 0) {
  78             // Shouldn't happen but watch for it anyway
  79             throw new FileNotFoundException("File " + file.getAbsolutePath() + " not found");
  80         }
  81 
  82         try {
  83             return createShellFolderFromRelativePIDL(parent, pIDL);
  84         } finally {
  85             Win32ShellFolder2.releasePIDL(pIDL);
  86         }
  87     }
  88 
  89     static Win32ShellFolder2 createShellFolderFromRelativePIDL(Win32ShellFolder2 parent, long pIDL)
  90             throws InterruptedException {
  91         // Walk down this relative pIDL, creating new nodes for each of the entries
  92         while (pIDL != 0) {
  93             long curPIDL = Win32ShellFolder2.copyFirstPIDLEntry(pIDL);
  94             if (curPIDL != 0) {
  95                 parent = new Win32ShellFolder2(parent, curPIDL);
  96                 pIDL = Win32ShellFolder2.getNextPIDLEntry(pIDL);
  97             } else {
  98                 // The list is empty if the parent is Desktop and pIDL is a shortcut to Desktop
  99                 break;
 100             }
 101         }
 102         return parent;
 103     }
 104 
 105     private static final int VIEW_LIST = 2;
 106     private static final int VIEW_DETAILS = 3;
 107     private static final int VIEW_PARENTFOLDER = 8;
 108     private static final int VIEW_NEWFOLDER = 11;
 109 
 110     private static final Image[] STANDARD_VIEW_BUTTONS = new Image[12];
 111 
 112     private static Image getStandardViewButton(int iconIndex) {
 113         Image result = STANDARD_VIEW_BUTTONS[iconIndex];
 114 
 115         if (result != null) {
 116             return result;
 117         }
 118 
 119         BufferedImage img = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
 120 
 121         img.setRGB(0, 0, 16, 16, Win32ShellFolder2.getStandardViewButton0(iconIndex), 0, 16);
 122 
 123         STANDARD_VIEW_BUTTONS[iconIndex] = img;
 124 
 125         return img;
 126     }
 127 
 128     // Special folders
 129     private static Win32ShellFolder2 desktop;
 130     private static Win32ShellFolder2 drives;
 131     private static Win32ShellFolder2 recent;
 132     private static Win32ShellFolder2 network;
 133     private static Win32ShellFolder2 personal;
 134 
 135     static Win32ShellFolder2 getDesktop() {
 136         if (desktop == null) {
 137             try {
 138                 desktop = new Win32ShellFolder2(DESKTOP);
 139             } catch (IOException e) {
 140                 // Ignore error
 141             } catch (InterruptedException e) {
 142                 // Ignore error
 143             }
 144         }
 145         return desktop;
 146     }
 147 
 148     static Win32ShellFolder2 getDrives() {
 149         if (drives == null) {
 150             try {
 151                 drives = new Win32ShellFolder2(DRIVES);
 152             } catch (IOException e) {
 153                 // Ignore error
 154             } catch (InterruptedException e) {
 155                 // Ignore error
 156             }
 157         }
 158         return drives;
 159     }
 160 
 161     static Win32ShellFolder2 getRecent() {
 162         if (recent == null) {
 163             try {
 164                 String path = Win32ShellFolder2.getFileSystemPath(RECENT);
 165                 if (path != null) {
 166                     recent = createShellFolder(getDesktop(), new File(path));
 167                 }
 168             } catch (InterruptedException e) {
 169                 // Ignore error
 170             } catch (IOException e) {
 171                 // Ignore error
 172             }
 173         }
 174         return recent;
 175     }
 176 
 177     static Win32ShellFolder2 getNetwork() {
 178         if (network == null) {
 179             try {
 180                 network = new Win32ShellFolder2(NETWORK);
 181             } catch (IOException e) {
 182                 // Ignore error
 183             } catch (InterruptedException e) {
 184                 // Ignore error
 185             }
 186         }
 187         return network;
 188     }
 189 
 190     static Win32ShellFolder2 getPersonal() {
 191         if (personal == null) {
 192             try {
 193                 String path = Win32ShellFolder2.getFileSystemPath(PERSONAL);
 194                 if (path != null) {
 195                     Win32ShellFolder2 desktop = getDesktop();
 196                     personal = desktop.getChildByPath(path);
 197                     if (personal == null) {
 198                         personal = createShellFolder(getDesktop(), new File(path));
 199                     }
 200                     if (personal != null) {
 201                         personal.setIsPersonal();
 202                     }
 203                 }
 204             } catch (InterruptedException e) {
 205                 // Ignore error
 206             } catch (IOException e) {
 207                 // Ignore error
 208             }
 209         }
 210         return personal;
 211     }
 212 
 213 
 214     private static File[] roots;
 215 
 216     /**
 217      * @param key a <code>String</code>
 218      *  "fileChooserDefaultFolder":
 219      *    Returns a <code>File</code> - the default shellfolder for a new filechooser
 220      *  "roots":
 221      *    Returns a <code>File[]</code> - containing the root(s) of the displayable hierarchy
 222      *  "fileChooserComboBoxFolders":
 223      *    Returns a <code>File[]</code> - an array of shellfolders representing the list to
 224      *    show by default in the file chooser's combobox
 225      *   "fileChooserShortcutPanelFolders":
 226      *    Returns a <code>File[]</code> - an array of shellfolders representing well-known
 227      *    folders, such as Desktop, Documents, History, Network, Home, etc.
 228      *    This is used in the shortcut panel of the filechooser on Windows 2000
 229      *    and Windows Me.
 230      *  "fileChooserIcon <icon>":
 231      *    Returns an <code>Image</code> - icon can be ListView, DetailsView, UpFolder, NewFolder or
 232      *    ViewMenu (Windows only).
 233      *  "optionPaneIcon iconName":
 234      *    Returns an <code>Image</code> - icon from the system icon list
 235      *
 236      * @return An Object matching the key string.
 237      */
 238     public Object get(String key) {
 239         if (key.equals("fileChooserDefaultFolder")) {
 240             File file = getPersonal();
 241             if (file == null) {
 242                 file = getDesktop();
 243             }
 244             return file;
 245         } else if (key.equals("roots")) {
 246             // Should be "History" and "Desktop" ?
 247             if (roots == null) {
 248                 File desktop = getDesktop();
 249                 if (desktop != null) {
 250                     roots = new File[] { desktop };
 251                 } else {
 252                     roots = (File[])super.get(key);
 253                 }
 254             }
 255             return roots;
 256         } else if (key.equals("fileChooserComboBoxFolders")) {
 257             Win32ShellFolder2 desktop = getDesktop();
 258 
 259             if (desktop != null) {
 260                 ArrayList<File> folders = new ArrayList<File>();
 261                 Win32ShellFolder2 drives = getDrives();
 262 
 263                 Win32ShellFolder2 recentFolder = getRecent();
 264                 if (recentFolder != null && OSInfo.getWindowsVersion().compareTo(OSInfo.WINDOWS_2000) >= 0) {
 265                     folders.add(recentFolder);
 266                 }
 267 
 268                 folders.add(desktop);
 269                 // Add all second level folders
 270                 File[] secondLevelFolders = desktop.listFiles();
 271                 Arrays.sort(secondLevelFolders);
 272                 for (File secondLevelFolder : secondLevelFolders) {
 273                     Win32ShellFolder2 folder = (Win32ShellFolder2) secondLevelFolder;
 274                     if (!folder.isFileSystem() || (folder.isDirectory() && !folder.isLink())) {
 275                         folders.add(folder);
 276                         // Add third level for "My Computer"
 277                         if (folder.equals(drives)) {
 278                             File[] thirdLevelFolders = folder.listFiles();
 279                             if (thirdLevelFolders != null && thirdLevelFolders.length > 0) {
 280                                 List<File> thirdLevelFoldersList = Arrays.asList(thirdLevelFolders);
 281 
 282                                 folder.sortChildren(thirdLevelFoldersList);
 283                                 folders.addAll(thirdLevelFoldersList);
 284                             }
 285                         }
 286                     }
 287                 }
 288                 return folders.toArray(new File[folders.size()]);
 289             } else {
 290                 return super.get(key);
 291             }
 292         } else if (key.equals("fileChooserShortcutPanelFolders")) {
 293             Toolkit toolkit = Toolkit.getDefaultToolkit();
 294             ArrayList<File> folders = new ArrayList<File>();
 295             int i = 0;
 296             Object value;
 297             do {
 298                 value = toolkit.getDesktopProperty("win.comdlg.placesBarPlace" + i++);
 299                 try {
 300                     if (value instanceof Integer) {
 301                         // A CSIDL
 302                         folders.add(new Win32ShellFolder2((Integer)value));
 303                     } else if (value instanceof String) {
 304                         // A path
 305                         folders.add(createShellFolder(new File((String)value)));
 306                     }
 307                 } catch (IOException e) {
 308                     // Skip this value
 309                 } catch (InterruptedException e) {
 310                     // Return empty result
 311                     return new File[0];
 312                 }
 313             } while (value != null);
 314 
 315             if (folders.size() == 0) {
 316                 // Use default list of places
 317                 for (File f : new File[] {
 318                     getRecent(), getDesktop(), getPersonal(), getDrives(), getNetwork()
 319                 }) {
 320                     if (f != null) {
 321                         folders.add(f);
 322                     }
 323                 }
 324             }
 325             return folders.toArray(new File[folders.size()]);
 326         } else if (key.startsWith("fileChooserIcon ")) {
 327             String name = key.substring(key.indexOf(" ") + 1);
 328 
 329             int iconIndex;
 330 
 331             if (name.equals("ListView") || name.equals("ViewMenu")) {
 332                 iconIndex = VIEW_LIST;
 333             } else if (name.equals("DetailsView")) {
 334                 iconIndex = VIEW_DETAILS;
 335             } else if (name.equals("UpFolder")) {
 336                 iconIndex = VIEW_PARENTFOLDER;
 337             } else if (name.equals("NewFolder")) {
 338                 iconIndex = VIEW_NEWFOLDER;
 339             } else {
 340                 return null;
 341             }
 342 
 343             return getStandardViewButton(iconIndex);
 344         } else if (key.startsWith("optionPaneIcon ")) {
 345             Win32ShellFolder2.SystemIcon iconType;
 346             if (key == "optionPaneIcon Error") {
 347                 iconType = Win32ShellFolder2.SystemIcon.IDI_ERROR;
 348             } else if (key == "optionPaneIcon Information") {
 349                 iconType = Win32ShellFolder2.SystemIcon.IDI_INFORMATION;
 350             } else if (key == "optionPaneIcon Question") {
 351                 iconType = Win32ShellFolder2.SystemIcon.IDI_QUESTION;
 352             } else if (key == "optionPaneIcon Warning") {
 353                 iconType = Win32ShellFolder2.SystemIcon.IDI_EXCLAMATION;
 354             } else {
 355                 return null;
 356             }
 357             return Win32ShellFolder2.getSystemIcon(iconType);
 358         } else if (key.startsWith("shell32Icon ") || key.startsWith("shell32LargeIcon ")) {
 359             String name = key.substring(key.indexOf(" ") + 1);
 360             try {
 361                 int i = Integer.parseInt(name);
 362                 if (i >= 0) {
 363                     return Win32ShellFolder2.getShell32Icon(i, key.startsWith("shell32LargeIcon "));
 364                 }
 365             } catch (NumberFormatException ex) {
 366             }
 367         }
 368         return null;
 369     }
 370 
 371     /**
 372      * Does <code>dir</code> represent a "computer" such as a node on the network, or
 373      * "My Computer" on the desktop.
 374      */
 375     public boolean isComputerNode(final File dir) {
 376         if (dir != null && dir == getDrives()) {
 377             return true;
 378         } else {
 379             String path = AccessController.doPrivileged(new PrivilegedAction<String>() {
 380                 public String run() {
 381                     return dir.getAbsolutePath();
 382                 }
 383             });
 384 
 385             return (path.startsWith("\\\\") && path.indexOf("\\", 2) < 0);      //Network path
 386         }
 387     }
 388 
 389     public boolean isFileSystemRoot(File dir) {
 390         //Note: Removable drives don't "exist" but are listed in "My Computer"
 391         if (dir != null) {
 392             Win32ShellFolder2 drives = getDrives();
 393             if (dir instanceof Win32ShellFolder2) {
 394                 Win32ShellFolder2 sf = (Win32ShellFolder2)dir;
 395                 if (sf.isFileSystem()) {
 396                     if (sf.parent != null) {
 397                         return sf.parent.equals(drives);
 398                     }
 399                     // else fall through ...
 400                 } else {
 401                     return false;
 402                 }
 403             }
 404             String path = dir.getPath();
 405 
 406             if (path.length() != 3 || path.charAt(1) != ':') {
 407                 return false;
 408             }
 409 
 410             File[] files = drives.listFiles();
 411 
 412             return files != null && Arrays.asList(files).contains(dir);
 413         }
 414         return false;
 415     }
 416 
 417     private static List topFolderList = null;
 418     static int compareShellFolders(Win32ShellFolder2 sf1, Win32ShellFolder2 sf2) {
 419         boolean special1 = sf1.isSpecial();
 420         boolean special2 = sf2.isSpecial();
 421 
 422         if (special1 || special2) {
 423             if (topFolderList == null) {
 424                 ArrayList tmpTopFolderList = new ArrayList();
 425                 tmpTopFolderList.add(Win32ShellFolderManager2.getPersonal());
 426                 tmpTopFolderList.add(Win32ShellFolderManager2.getDesktop());
 427                 tmpTopFolderList.add(Win32ShellFolderManager2.getDrives());
 428                 tmpTopFolderList.add(Win32ShellFolderManager2.getNetwork());
 429                 topFolderList = tmpTopFolderList;
 430             }
 431             int i1 = topFolderList.indexOf(sf1);
 432             int i2 = topFolderList.indexOf(sf2);
 433             if (i1 >= 0 && i2 >= 0) {
 434                 return (i1 - i2);
 435             } else if (i1 >= 0) {
 436                 return -1;
 437             } else if (i2 >= 0) {
 438                 return 1;
 439             }
 440         }
 441 
 442         // Non-file shellfolders sort before files
 443         if (special1 && !special2) {
 444             return -1;
 445         } else if (special2 && !special1) {
 446             return  1;
 447         }
 448 
 449         return compareNames(sf1.getAbsolutePath(), sf2.getAbsolutePath());
 450     }
 451 
 452     static int compareNames(String name1, String name2) {
 453         // First ignore case when comparing
 454         int diff = name1.compareToIgnoreCase(name2);
 455         if (diff != 0) {
 456             return diff;
 457         } else {
 458             // May differ in case (e.g. "mail" vs. "Mail")
 459             // We need this test for consistent sorting
 460             return name1.compareTo(name2);
 461         }
 462     }
 463 
 464     @Override
 465     protected Invoker createInvoker() {
 466         return new ComInvoker();
 467     }
 468 
 469     private static class ComInvoker extends ThreadPoolExecutor implements ThreadFactory, ShellFolder.Invoker {
 470         private static Thread comThread;
 471 
 472         private ComInvoker() {
 473             super(1, 1, 0, TimeUnit.DAYS, new LinkedBlockingQueue<Runnable>());
 474             allowCoreThreadTimeOut(false);
 475             setThreadFactory(this);
 476             final Runnable shutdownHook = new Runnable() {
 477                 public void run() {
 478                     AccessController.doPrivileged(new PrivilegedAction<Void>() {
 479                         public Void run() {
 480                             shutdownNow();
 481                             return null;
 482                         }
 483                     });
 484                 }
 485             };
 486             AccessController.doPrivileged(new PrivilegedAction<Void>() {
 487                 public Void run() {
 488                     Runtime.getRuntime().addShutdownHook(
 489                         new Thread(shutdownHook)
 490                     );
 491                     return null;
 492                 }
 493             });
 494         }
 495 
 496         public synchronized Thread newThread(final Runnable task) {
 497             final Runnable comRun = new Runnable() {
 498                 public void run() {
 499                     try {
 500                         initializeCom();
 501                         task.run();
 502                     } finally {
 503                         uninitializeCom();
 504                     }
 505                 }
 506             };
 507             comThread =  AccessController.doPrivileged((PrivilegedAction<Thread>) () -> {
 508                             /* The thread must be a member of a thread group
 509                              * which will not get GCed before VM exit.
 510                              * Make its parent the top-level thread group.
 511                              */
 512                             ThreadGroup rootTG = ThreadGroupUtils.getRootThreadGroup();
 513                             Thread thread = new Thread(rootTG, comRun, "Swing-Shell");
 514                             thread.setDaemon(true);
 515                             return thread;
 516                         }
 517                 );
 518             return comThread;
 519         }
 520 
 521         public <T> T invoke(Callable<T> task) throws Exception {
 522             if (Thread.currentThread() == comThread) {
 523                 // if it's already called from the COM
 524                 // thread, we don't need to delegate the task
 525                 return task.call();
 526             } else {
 527                 final Future<T> future;
 528 
 529                 try {
 530                     future = submit(task);
 531                 } catch (RejectedExecutionException e) {
 532                     throw new InterruptedException(e.getMessage());
 533                 }
 534 
 535                 try {
 536                     return future.get();
 537                 } catch (InterruptedException e) {
 538                     AccessController.doPrivileged(new PrivilegedAction<Void>() {
 539                         public Void run() {
 540                             future.cancel(true);
 541 
 542                             return null;
 543                         }
 544                     });
 545 
 546                     throw e;
 547                 } catch (ExecutionException e) {
 548                     Throwable cause = e.getCause();
 549 
 550                     if (cause instanceof Exception) {
 551                         throw (Exception) cause;
 552                     }
 553 
 554                     if (cause instanceof Error) {
 555                         throw (Error) cause;
 556                     }
 557 
 558                     throw new RuntimeException("Unexpected error", cause);
 559                 }
 560             }
 561         }
 562     }
 563 
 564     static native void initializeCom();
 565 
 566     static native void uninitializeCom();
 567 }
--- EOF ---