shellitem.cs

C#界面编程

            index = SubFiles.IndexOf(name);

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

            return -1;
        }

        internal int IndexOf(IntPtr pidl)
        {
            int index;
            index = SubFolders.IndexOf(pidl);

            if (index > -1)
                return index;

            index = SubFiles.IndexOf(pidl);

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

            return -1;
        }

        internal ShellItem this[int index]
        {
            get
            {
                if (index >= 0 && index < SubFolders.Count)
                    return SubFolders[index];
                else if (index >= 0 && index - SubFolders.Count < SubFiles.Count)
                    return SubFiles[index - SubFolders.Count];
                else
                    throw new IndexOutOfRangeException();
            }
            set
            {
                if (index >= 0 && index < SubFolders.Count)
                    SubFolders[index] = value;
                else if (index >= 0 && index - SubFolders.Count < SubFiles.Count)
                    SubFiles[index - SubFolders.Count] = value;
                else
                    throw new IndexOutOfRangeException();
            }
        }

        internal ShellItem this[string name]
        {
            get
            {
                ShellItem temp = SubFolders[name];

                if (temp != null)
                    return temp;
                else
                    return SubFiles[name];
            }
            set
            {
                ShellItem temp = SubFolders[name];

                if (temp != null)
                    SubFolders[name] = value;
                else
                    SubFiles[name] = value;
            }
        }

        internal ShellItem this[IntPtr pidl]
        {
            get
            {
                ShellItem temp = SubFolders[pidl];

                if (temp != null)
                    return temp;
                else
                    return SubFiles[pidl];
            }
            set
            {
                ShellItem temp = SubFolders[pidl];

                if (temp != null)
                    SubFolders[pidl] = value;
                else
                    SubFiles[pidl] = value;
            }
        }

        internal int Count
        {
            get { return SubFolders.Count + SubFiles.Count; }
        }

        #endregion        
        
        public override string ToString()
        {
            return text;
        }
    }

    #region ShellItem Utility Classes

    #region Update Helpers

    internal class ShellItemUpdateCondition
    {
        private bool continueUpdate;

        public ShellItemUpdateCondition()
        {
            continueUpdate = true;
        }

        public bool ContinueUpdate
        {
            get { return continueUpdate; }
            set { continueUpdate = value; }
        }
    }

    #endregion

    #region Item Enumeration

    public class ShellItemEnumerator : IEnumerator
    {
        private ShellItem parent;
        private int index;

        public ShellItemEnumerator(ShellItem parent)
        {
            this.parent = parent;
            index = -1;
        }

        #region IEnumerator Members

        public object Current
        {
            get
            {
                return parent[index];
            }
        }

        public bool MoveNext()
        {
            index++;
            return (index < parent.Count);
        }

        public void Reset()
        {
            index = -1;
        }

        #endregion
    }

    internal class ShellItemCollection : IEnumerable
    {
        private ArrayList items;
        private ShellItem shellItem;

        public ShellItemCollection(ShellItem shellItem)
        {
            this.shellItem = shellItem;
            items = new ArrayList();
        }

        public ShellItem ShellItem { get { return shellItem; } }

        #region ArrayList Members

        public int Count
        {
            get { return items.Count; }
        }

        public void Sort()
        {
            items.Sort();
        }

        internal int Capacity
        {
            get { return items.Capacity; }
            set { items.Capacity = value; }
        }

        #endregion

        #region IList Members

        internal int Add(ShellItem value)
        {
            return items.Add(value);
        }

        internal void Clear()
        {
            items.Clear();
        }

        public bool Contains(ShellItem value)
        {
            return items.Contains(value);
        }

        public bool Contains(string name)
        {
            foreach (ShellItem item in this)
            {
                if (string.Compare(item.Text, name, true) == 0)
                    return true;
            }

            return false;
        }

        public bool Contains(IntPtr pidl)
        {
            foreach (ShellItem item in this)
            {
                if (item.PIDLRel.Equals(pidl))
                    return true;
            }

            return false;
        }

        public int IndexOf(ShellItem value)
        {
            return items.IndexOf(value);
        }

        public int IndexOf(string name)
        {
            for (int i = 0; i < items.Count; i++)
            {
                if (string.Compare(this[i].Text, name, true) == 0)
                    return i;
            }

            return -1;
        }

        public int IndexOf(IntPtr pidl)
        {
            for (int i = 0; i < items.Count; i++)
            {
                if (this[i].PIDLRel.Equals(pidl))
                    return i;
            }

            return -1;
        }

        internal void Insert(int index, ShellItem value)
        {
            items.Insert(index, value);
        }

        public bool IsFixedSize
        {
            get { return items.IsFixedSize; }
        }

        public bool IsReadOnly
        {
            get { return items.IsReadOnly; }
        }

        internal void Remove(ShellItem value)
        {
            items.Remove(value);
        }

        internal void Remove(string name)
        {
            int index;

            if ((index = IndexOf(name)) > -1)
                RemoveAt(index);
        }

        internal void RemoveAt(int index)
        {
            items.RemoveAt(index);
        }

        public ShellItem this[int index]
        {
            get
            {
                try
                {
                    return (ShellItem)items[index];
                }
                catch (ArgumentOutOfRangeException) 
                {
                    return null;
                }
            }
            set
            {
                items[index] = value;
            }
        }

        public ShellItem this[string name]
        {
            get
            {
                int index;
                if ((index = IndexOf(name)) > -1)
                    return (ShellItem)items[index];
                else
                    return null;
            }
            set
            {
                int index;
                if ((index = IndexOf(name)) > -1)
                    items[index] = value;
            }
        }

        public ShellItem this[IntPtr pidl]
        {
            get
            {
                int index;
                if ((index = IndexOf(pidl)) > -1)
                    return (ShellItem)items[index];
                else
                    return null;
            }
            set
            {
                int index;
                if ((index = IndexOf(pidl)) > -1)
                    items[index] = value;
            }
        }

        #endregion

        #region IEnumerable Members

        public IEnumerator GetEnumerator()
        {
            return items.GetEnumerator();
        }

        #endregion
    }

    #endregion

    #endregion
}