/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.awt.shell;

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.*;

import javax.swing.SwingConstants;

// NOTE: This class supersedes Win32ShellFolder, which was removed from

//       distribution after version 1.4.2.

/**

 * Win32 Shell Folders

 * <P>

 * <BR>

 * There are two fundamental types of shell folders : file system folders

 * and non-file system folders.  File system folders are relatively easy

 * to deal with.  Non-file system folders are items such as My Computer,

 * Network Neighborhood, and the desktop.  Some of these non-file system

 * folders have special values and properties.

 * <P>

 * <BR>

 * Win32 keeps two basic data structures for shell folders.  The first

 * of these is called an ITEMIDLIST.  Usually a pointer, called an

 * LPITEMIDLIST, or more frequently just "PIDL".  This structure holds

 * a series of identifiers and can be either relative to the desktop

 * (an absolute PIDL), or relative to the shell folder that contains them.

 * Some Win32 functions can take absolute or relative PIDL values, and

 * others can only accept relative values.

 * <BR>

 * The second data structure is an IShellFolder COM interface.  Using

 * this interface, one can enumerate the relative PIDLs in a shell

 * folder, get attributes, etc.

 * <BR>

 * All Win32ShellFolder2 objects which are folder types (even non-file

 * system folders) contain an IShellFolder object. Files are named in

 * directories via relative PIDLs.

 *

 * @author Michael Martak

 * @author Leif Samuelsson

 * @author Kenneth Russell

 * @since 1.4 */

final class Win32ShellFolder2 extends ShellFolder {

    private static native void initIDs();

    private static final boolean is98;

    static {

        String osName = System.getProperty("os.name");

        is98 = (osName != null && osName.startsWith("Windows 98"));

        initIDs();

    }

    // Win32 Shell Folder Constants

    public static final int DESKTOP = 0x0000;

    public static final int INTERNET = 0x0001;

    public static final int PROGRAMS = 0x0002;

    public static final int CONTROLS = 0x0003;

    public static final int PRINTERS = 0x0004;

    public static final int PERSONAL = 0x0005;

    public static final int FAVORITES = 0x0006;

    public static final int STARTUP = 0x0007;

    public static final int RECENT = 0x0008;

    public static final int SENDTO = 0x0009;

    public static final int BITBUCKET = 0x000a;

    public static final int STARTMENU = 0x000b;

    public static final int DESKTOPDIRECTORY = 0x0010;

    public static final int DRIVES = 0x0011;

    public static final int NETWORK = 0x0012;

    public static final int NETHOOD = 0x0013;

    public static final int FONTS = 0x0014;

    public static final int TEMPLATES = 0x0015;

    public static final int COMMON_STARTMENU = 0x0016;

    public static final int COMMON_PROGRAMS = 0X0017;

    public static final int COMMON_STARTUP = 0x0018;

    public static final int COMMON_DESKTOPDIRECTORY = 0x0019;

    public static final int APPDATA = 0x001a;

    public static final int PRINTHOOD = 0x001b;

    public static final int ALTSTARTUP = 0x001d;

    public static final int COMMON_ALTSTARTUP = 0x001e;

    public static final int COMMON_FAVORITES = 0x001f;

    public static final int INTERNET_CACHE = 0x0020;

    public static final int COOKIES = 0x0021;

    public static final int HISTORY = 0x0022;

    // Win32 shell folder attributes

    public static final int ATTRIB_CANCOPY          = 0x00000001;

    public static final int ATTRIB_CANMOVE          = 0x00000002;

    public static final int ATTRIB_CANLINK          = 0x00000004;

    public static final int ATTRIB_CANRENAME        = 0x00000010;

    public static final int ATTRIB_CANDELETE        = 0x00000020;

    public static final int ATTRIB_HASPROPSHEET     = 0x00000040;

    public static final int ATTRIB_DROPTARGET       = 0x00000100;

    public static final int ATTRIB_LINK             = 0x00010000;

    public static final int ATTRIB_SHARE            = 0x00020000;

    public static final int ATTRIB_READONLY         = 0x00040000;

    public static final int ATTRIB_GHOSTED          = 0x00080000;

    public static final int ATTRIB_HIDDEN           = 0x00080000;

    public static final int ATTRIB_FILESYSANCESTOR  = 0x10000000;

    public static final int ATTRIB_FOLDER           = 0x20000000;

    public static final int ATTRIB_FILESYSTEM       = 0x40000000;

    public static final int ATTRIB_HASSUBFOLDER     = 0x80000000;

    public static final int ATTRIB_VALIDATE         = 0x01000000;

    public static final int ATTRIB_REMOVABLE        = 0x02000000;

    public static final int ATTRIB_COMPRESSED       = 0x04000000;

    public static final int ATTRIB_BROWSABLE        = 0x08000000;

    public static final int ATTRIB_NONENUMERATED    = 0x00100000;

    public static final int ATTRIB_NEWCONTENT       = 0x00200000;

    // IShellFolder::GetDisplayNameOf constants

    public static final int SHGDN_NORMAL            = 0;

    public static final int SHGDN_INFOLDER          = 1;

    public static final int SHGDN_INCLUDE_NONFILESYS= 0x2000;

    public static final int SHGDN_FORADDRESSBAR     = 0x4000;

    public static final int SHGDN_FORPARSING        = 0x8000;

    // Values for system call LoadIcon()

    public enum SystemIcon {

        IDI_APPLICATION(32512),

        IDI_HAND(32513),

        IDI_ERROR(32513),

        IDI_QUESTION(32514),

        IDI_EXCLAMATION(32515),

        IDI_WARNING(32515),

        IDI_ASTERISK(32516),

        IDI_INFORMATION(32516),

        IDI_WINLOGO(32517);

        private final int iconID;

        SystemIcon(int iconID) {

            this.iconID = iconID;

        }

        public int getIconID() {

            return iconID;

        }

    }

    static class FolderDisposer implements sun.java2d.DisposerRecord {

        /*

         * This is cached as a concession to getFolderType(), which needs

         * an absolute PIDL.

         */

        long absolutePIDL;

        /*

         * We keep track of shell folders through the IShellFolder

         * interface of their parents plus their relative PIDL.

         */

        long pIShellFolder;

        long relativePIDL;

        boolean disposed;

        public void dispose() {

            if (disposed) return;

            if (relativePIDL != 0) {

                releasePIDL(relativePIDL);

            }

            if (absolutePIDL != 0) {

                releasePIDL(absolutePIDL);

            }

            if (pIShellFolder != 0) {

                releaseIShellFolder(pIShellFolder);

            }

            disposed = true;

        }

    }

    FolderDisposer disposer = new FolderDisposer();

    private void setIShellFolder(long pIShellFolder) {

        disposer.pIShellFolder = pIShellFolder;

    }

    private void setRelativePIDL(long relativePIDL) {

        disposer.relativePIDL = relativePIDL;

    }

    /*

     * The following are for caching various shell folder properties.

     */

    private long pIShellIcon = -1L;

    private String folderType = null;

    private String displayName = null;

    private Image smallIcon = null;

    private Image largeIcon = null;

    private Boolean isDir = null;

    /*

     * The following is to identify the My Documents folder as being special

     */

    private boolean isPersonal;

    /**

     * Create a system special shell folder, such as the

     * desktop or Network Neighborhood.

     */

    Win32ShellFolder2(int csidl) throws IOException {

        // Desktop is parent of DRIVES and NETWORK, not necessarily

        // other special shell folders.

        super(null,

              (getFileSystemPath(csidl) == null)

                ? ("ShellFolder: 0x"+Integer.toHexString(csidl)) : getFileSystemPath(csidl));

        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;

                }

            }

        }

        sun.java2d.Disposer.addRecord(this, disposer);

    }

    /**

     * Create a system shell folder

     */

    Win32ShellFolder2(Win32ShellFolder2 parent, long pIShellFolder, long relativePIDL, String path) {

        super(parent, (path != null) ? path : "ShellFolder: ");

        this.disposer.pIShellFolder = pIShellFolder;

        this.disposer.relativePIDL = relativePIDL;

        sun.java2d.Disposer.addRecord(this, disposer);

    }

    /**

     * Creates a shell folder with a parent and relative PIDL

     */

    Win32ShellFolder2(Win32ShellFolder2 parent, long relativePIDL) {

        super(parent, getFileSystemPath(parent.getIShellFolder(), relativePIDL));

        this.disposer.relativePIDL = relativePIDL;

        getAbsolutePath();

        sun.java2d.Disposer.addRecord(this, disposer);

    }

    // Initializes the desktop shell folder

    private native void initDesktop();

    // Initializes a special, non-file system shell folder

    // from one of the above constants

    private native void initSpecial(long desktopIShellFolder, int csidl);

    /** Marks this folder as being the My Documents (Personal) folder */

    public void setIsPersonal() {

        isPersonal = true;

    }

    /**

     * This method is implemented to make sure that no instances

     * of <code>ShellFolder</code> are ever serialized. If <code>isFileSystem()</code> returns

     * <code>true</code>, then the object is representable with an instance of

     * <code>java.io.File</code> instead. If not, then the object depends

     * on native PIDL state and should not be serialized.

     *

     * @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 new File(getPath());

        } else {

            Win32ShellFolder2 drives = Win32ShellFolderManager2.getDrives();

            if (drives != null) {

                File[] driveRoots = drives.listFiles();

                if (driveRoots != null) {

                    for (int i = 0; i < driveRoots.length; i++) {

                        if (driveRoots[i] instanceof Win32ShellFolder2) {

                            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:\\");

        }

    }

    /**

     * Finalizer to clean up any COM objects or PIDLs used by this object.

     */

    protected void dispose() {

        disposer.dispose();

    }

    // Given a (possibly multi-level) relative PIDL (with respect to

    // the desktop, at least in all of the usage cases in this code),

    // return a pointer to the next entry. Does not mutate the PIDL in

    // any way. Returns 0 if the null terminator is reached.

    // Needs to be accessible to Win32ShellFolderManager2

    static native long getNextPIDLEntry(long pIDL);

    // Given a (possibly multi-level) relative PIDL (with respect to

    // the desktop, at least in all of the usage cases in this code),

    // copy the first entry into a newly-allocated PIDL. Returns 0 if

    // the PIDL is at the end of the list.

    // Needs to be accessible to Win32ShellFolderManager2

    static native long copyFirstPIDLEntry(long pIDL);

    // Given a parent's absolute PIDL and our relative PIDL, build an absolute PIDL

    private static native long combinePIDLs(long ppIDL, long pIDL);

    // Release a PIDL object

    // Needs to be accessible to Win32ShellFolderManager2

    static native void releasePIDL(long pIDL);

    // Release an IShellFolder object

    private static native void releaseIShellFolder(long pIShellFolder);

    /**

     * Accessor for IShellFolder

     */

    public long getIShellFolder() {

        if (disposer.pIShellFolder == 0) {

            assert(isDirectory());

            assert(parent != null);

            long parentIShellFolder = getParentIShellFolder();

            if (parentIShellFolder == 0) {

                throw new InternalError("Parent IShellFolder was null for " + getAbsolutePath());

            }

            // 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.

            disposer.pIShellFolder = bindToObject(parentIShellFolder, disposer.relativePIDL);

            if (disposer.pIShellFolder == 0) {

                throw new InternalError("Unable to bind " + getAbsolutePath() + " to parent");

            }

        }

        return disposer.pIShellFolder;

    }

    /**

     * Get the parent ShellFolder's IShellFolder interface

     */

    public long getParentIShellFolder() {

        Win32ShellFolder2 parent = (Win32ShellFolder2)getParentFile();

        if (parent == null) {

            // Parent should only be null if this is the desktop, whose

            // relativePIDL is relative to its own IShellFolder.

            return getIShellFolder();

        }

        return parent.getIShellFolder();

    }

    /**

     * Accessor for relative PIDL

     */

    public long getRelativePIDL() {

        if (disposer.relativePIDL == 0) {

            throw new InternalError("Should always have a relative PIDL");

        }

        return disposer.relativePIDL;

    }

    private long getAbsolutePIDL() {

        if (parent == null) {

            // This is the desktop

            return getRelativePIDL();

        } else {

            if (disposer.absolutePIDL == 0) {

                disposer.absolutePIDL = combinePIDLs(((Win32ShellFolder2)parent).getAbsolutePIDL(), getRelativePIDL());

            }

            return disposer.absolutePIDL;

        }

    }

    /**

     * Helper function to return the desktop

     */

    public Win32ShellFolder2 getDesktop() {

        return Win32ShellFolderManager2.getDesktop();

    }

    /**

     * Helper function to return the desktop IShellFolder interface

     */

    public long getDesktopIShellFolder() {

        return getDesktop().getIShellFolder();

    }

    private static boolean pathsEqual(String path1, String path2) {

        // Same effective implementation as Win32FileSystem

        return path1.equalsIgnoreCase(path2);

    }

    /**

     * Check to see if two ShellFolder objects are the same

     */

    public boolean equals(Object o) {

        if (o == null || !(o instanceof Win32ShellFolder2)) {

            // Short-circuit circuitous delegation path

            if (!(o instanceof File)) {

                return super.equals(o);

            }

            return pathsEqual(getPath(), ((File) o).getPath());

        }

        Win32ShellFolder2 rhs = (Win32ShellFolder2) o;

        if ((parent == null && rhs.parent != null) ||

            (parent != null && rhs.parent == null)) {

            return false;

        }

        if (isFileSystem() && rhs.isFileSystem()) {

            // Only folders with identical parents can be equal

            return (pathsEqual(getPath(), rhs.getPath()) &&

                    (parent == rhs.parent || parent.equals(rhs.parent)));

        }

        if (parent == rhs.parent || parent.equals(rhs.parent)) {

            return pidlsEqual(getParentIShellFolder(), disposer.relativePIDL, rhs.disposer.relativePIDL);

        }

        return false;

    }

    private static boolean pidlsEqual(long pIShellFolder, long pidl1, long pidl2) {

        return (compareIDs(pIShellFolder, pidl1, pidl2) == 0);

    }

    private static native int compareIDs(long pParentIShellFolder, long pidl1, long pidl2);

    /**

     * @return Whether this is a file system shell folder

     */

    public boolean isFileSystem() {

        return hasAttribute(ATTRIB_FILESYSTEM);

    }

    /**

     * Return whether the given attribute flag is set for this object

     */

    public boolean hasAttribute(int attribute) {

        // 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

     */

    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) {

        int linkedFolder = ATTRIB_LINK | ATTRIB_FOLDER;

        if (parentIShellFolder == Win32ShellFolderManager2.getNetwork().getIShellFolder() &&

            getAttributes0(parentIShellFolder, relativePIDL, linkedFolder) == linkedFolder) {

            String s =

                getFileSystemPath(Win32ShellFolderManager2.getDesktop().getIShellFolder(),

                                  getLinkLocation(parentIShellFolder, relativePIDL, false));

            if (s != null && s.startsWith("\\\\")) {

                return s;

            }

        }

        return getDisplayNameOf(parentIShellFolder, relativePIDL, SHGDN_NORMAL | SHGDN_FORPARSING);

    }

    // Needs to be accessible to Win32ShellFolderManager2

    static native String getFileSystemPath(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("/"));

    }

    /**