shellitem.cs

C#界面编程

                    Browser.OnShellItemUpdate(this, new ShellItemUpdateEventArgs(null, item, ShellItemUpdateType.Created));
                }
                catch (Exception) { }
            }
        }

        internal void Update(IntPtr newPidlFull, ShellItemUpdateType changeType)
        {
            browser.UpdateCondition.ContinueUpdate = false;

            lock (browser)
            {
                #region Change Pidl and ShellFolder

                if (newPidlFull != IntPtr.Zero)
                {
                    IntPtr tempPidl = PIDL.ILClone(PIDL.ILFindLastID(newPidlFull)), newPidlRel, newShellFolderPtr;
                    ShellAPI.SHGetRealIDL(ParentItem.ShellFolder, tempPidl, out newPidlRel);

                    if (IsFolder && ParentItem.ShellFolder.BindToObject(
                                        newPidlRel,
                                        IntPtr.Zero,
                                        ref ShellAPI.IID_IShellFolder,
                                        out newShellFolderPtr) == ShellAPI.S_OK)
                    {
                        Marshal.ReleaseComObject(shellFolder);
                        Marshal.Release(shellFolderPtr);
                        pidlRel.Free();

                        shellFolderPtr = newShellFolderPtr;
                        shellFolder = (IShellFolder)Marshal.GetTypedObjectForIUnknown(shellFolderPtr, typeof(IShellFolder));
                        pidlRel = new PIDL(newPidlRel, false);

                        foreach (ShellItem child in SubFolders)
                            UpdateShellFolders(child);
                    }
                    else
                    {
                        pidlRel.Free();
                        pidlRel = new PIDL(newPidlRel, false);
                    }

                    Marshal.FreeCoTaskMem(tempPidl);
                    Marshal.FreeCoTaskMem(newPidlFull);
                }

                #endregion

                #region Make Other Changes

                switch (changeType)
                {
                    case ShellItemUpdateType.Renamed:
                        SetText(this);
                        SetPath(this);
                        break;

                    case ShellItemUpdateType.Updated:
                        if (IsFolder)
                            SetAttributesFolder(this);
                        else
                            SetAttributesFile(this);
                        break;

                    case ShellItemUpdateType.MediaChange:
                        SetInfo(this);
                        Clear(true, true);
                        break;

                    case ShellItemUpdateType.IconChange:
                        SetInfo(this);
                        break;
                }

                #endregion
            }

            Browser.OnShellItemUpdate(ParentItem, new ShellItemUpdateEventArgs(this, this, changeType));
        }

        internal void RemoveItem(ShellItem item)
        {
            browser.UpdateCondition.ContinueUpdate = false;

            lock (browser)
            {
                try
                {
                    if (item.IsFolder)
                        SubFolders.Remove(item);
                    else
                        SubFiles.Remove(item);

                    Browser.OnShellItemUpdate(this, new ShellItemUpdateEventArgs(item, null, ShellItemUpdateType.Deleted));
                    ((IDisposable)item).Dispose();
                }
                catch (Exception) { }
            }
        }

        #endregion

        #endregion

        #region Static Methods

        public static string GetRealPath(ShellItem item)
        {
            if (item.Equals(item.browser.DesktopItem))
            {
                return "::{450d8fba-ad25-11d0-98a8-0800361b1103}";
            }
            else if (item.Type == item.Browser.SystemFolderName)
            {
                IntPtr strr = Marshal.AllocCoTaskMem(ShellAPI.MAX_PATH * 2 + 4);
                Marshal.WriteInt32(strr, 0, 0);
                StringBuilder buf = new StringBuilder(ShellAPI.MAX_PATH);

                if (item.ParentItem.ShellFolder.GetDisplayNameOf(
                                item.PIDLRel.Ptr,
                                ShellAPI.SHGNO.FORPARSING,
                                strr) == ShellAPI.S_OK)
                {
                    ShellAPI.StrRetToBuf(strr, item.PIDLRel.Ptr, buf, ShellAPI.MAX_PATH);
                }

                Marshal.FreeCoTaskMem(strr);

                return buf.ToString();
            }
            else
                return item.Path;
        }

        public static void UpdateShellFolders(ShellItem item)
        {
            item.UpdateShellFolder = true;

            foreach (ShellItem child in item.SubFolders)
                ShellItem.UpdateShellFolders(child);
        }

        #endregion

        #region Properties

        internal ShellBrowser Browser { get { return browser; } }

        internal ShellItem ParentItem { get { return parentItem; } }
        internal ShellItemCollection SubFiles { get { return subFiles; } }
        internal ShellItemCollection SubFolders { get { return subFolders; } }

        internal IShellFolder ShellFolder
        {
            get
            {
                if (updateShellFolder)
                {
                    Marshal.ReleaseComObject(shellFolder);
                    Marshal.Release(shellFolderPtr);

                    if (ParentItem.ShellFolder.BindToObject(
                                pidlRel.Ptr,
                                IntPtr.Zero,
                                ref ShellAPI.IID_IShellFolder,
                                out shellFolderPtr) == ShellAPI.S_OK)
                    {
                        shellFolder = (IShellFolder)Marshal.GetTypedObjectForIUnknown(shellFolderPtr, typeof(IShellFolder));
                    }

                    updateShellFolder = false;
                }

                return shellFolder;
            }
        }

        internal int ImageIndex
        {
            get { return imageIndex; }
            set { imageIndex = value; }
        }
        internal int SelectedImageIndex
        {
            get { return selectedImageIndex; }
            set { selectedImageIndex = value; }
        }

        internal PIDL PIDLRel { get { return pidlRel; } }
        internal PIDL PIDLFull
        {
            get
            {
                PIDL pidlFull = new PIDL(pidlRel.Ptr, true);
                ShellItem current = ParentItem;
                while (current != null)
                {
                    pidlFull.Insert(current.PIDLRel.Ptr);
                    current = current.ParentItem;
                }
                return pidlFull;
            }
        }

        public string Text { get { return text; } }
        public string Path { get { return path; } }

        public string Type { get { return type; } }
        internal short SortFlag { get { return sortFlag; } }

        public bool FilesExpanded { get { return filesExpanded; } }
        public bool FoldersExpanded { get { return foldersExpanded; } }

        public bool IsSystemFolder { get { return type == browser.SystemFolderName; } }

        public bool IsHidden { get { return isHidden; } }
        public bool IsFolder { get { return isFolder; } }
        public bool IsLink { get { return isLink; } }
        public bool IsShared { get { return isShared; } }
        public bool IsFileSystem { get { return isFileSystem; } }
        public bool IsBrowsable { get { return isBrowsable; } }
        public bool HasSubfolder { get { return hasSubfolder; } }
        public bool IsDisk { get { return isDisk; } }
        public bool CanRename { get { return canRename; } }
        public bool CanRead { get { return canRead; } }

        internal bool UpdateShellFolder
        {
            get { return updateShellFolder; }
            set { updateShellFolder = value; }
        }

        #endregion

        #region IEnumerable Members

        public System.Collections.IEnumerator GetEnumerator()
        {
            return new ShellItemEnumerator(this);
        }

        #endregion

        #region IDisposable

        void IDisposable.Dispose()
        {
            if (!disposed)
            {
                DisposeShellItem();
                GC.SuppressFinalize(this);
            }
        }

        private void DisposeShellItem()
        {
            disposed = true;

            if (ShellFolder != null)
            {
                Marshal.ReleaseComObject(ShellFolder);
                shellFolder = null;
            }

            if (shellFolderPtr != IntPtr.Zero)
            {
                try
                {
                    Marshal.Release(shellFolderPtr);
                }
                catch (Exception) { }
                finally
                {
                    shellFolderPtr = IntPtr.Zero;
                }
            }

            PIDLRel.Free();
        }

        #endregion

        #region IComparable

        private static short MakeSortFlag(ShellItem item)
        {
            if (item.IsFolder)
            {
                if (item.IsDisk)
                    return 1;
                if (item.Text == item.browser.MyDocumentsName &&
                    item.Type == item.Browser.SystemFolderName)
                    return 2;
                else if (item.Text == item.browser.MyComputerName)
                    return 3;
                else if (item.Type == item.Browser.SystemFolderName)
                {
                    if (!item.IsBrowsable)
                        return 4;
                    else
                        return 5;
                }
                else if (item.IsFolder && !item.IsBrowsable)
                    return 6;
                else
                    return 7;
            }
            else
                return 8;
        }

        public int CompareTo(object obj)
        {
            ShellItem other = (ShellItem)obj;

            if (SortFlag != other.SortFlag)
                return ((SortFlag > other.SortFlag) ? 1 : -1);
            else if (IsDisk)
                return string.Compare(Path, other.Path);
            else
                return string.Compare(Text, other.Text);
        }

        #endregion
        
        #region IList Members

        internal bool Contains(ShellItem value)
        {
            return (SubFolders.Contains(value) || SubFiles.Contains(value));
        }

        internal bool Contains(string name)
        {
            return (SubFolders.Contains(name) || SubFiles.Contains(name));
        }

        internal bool Contains(IntPtr pidl)
        {
            return (SubFolders.Contains(pidl) || SubFiles.Contains(pidl));
        }

        internal int IndexOf(ShellItem value)
        {
            int index;
            index = SubFolders.IndexOf(value);

            if (index > -1)
                return index;

            index = SubFiles.IndexOf(value);

            if (index > -1)
                return SubFolders.Count + index;

            return -1;
        }

        internal int IndexOf(string name)
        {
            int index;
            index = SubFolders.IndexOf(name);

            if (index > -1)
                return index;