Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/UI/WebControls/MenuItemCollection.cs

@@ -0,0 +1,407 @@
+namespace System.Web.UI.WebControls {
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Text;
+    using System.Web.UI;
+
+    public sealed class MenuItemCollection : ICollection, IStateManager {
+        private List<MenuItem> _list;
+        private MenuItem _owner;
+        private int _version;
+
+        private bool _isTrackingViewState;
+
+        private List<LogItem> _log;
+
+
+        public MenuItemCollection() : this(null) {
+        }
+
+
+        public MenuItemCollection(MenuItem owner) {
+            _owner = owner;
+            _list = new List<MenuItem>();
+        }
+
+
+        public int Count {
+            get {
+                return _list.Count;
+            }
+        }
+
+
+        public bool IsSynchronized {
+            get {
+                return ((ICollection)_list).IsSynchronized;
+            }
+        }
+
+        private List<LogItem> Log {
+            get {
+                if (_log == null) {
+                    _log = new List<LogItem>();
+                }
+                return _log;
+            }
+        }
+
+
+        public object SyncRoot {
+            get {
+                return ((ICollection)_list).SyncRoot;
+            }
+        }
+
+
+        public MenuItem this[int index] {
+            get {
+                return _list[index];
+            }
+        }
+
+
+        public void Add(MenuItem child) {
+            AddAt(_list.Count, child);
+        }
+
+
+        public void AddAt(int index, MenuItem child) {
+            if (child == null) {
+                throw new ArgumentNullException("child");
+            }
+
+            if (child.Owner != null && child.Parent == null) {
+                child.Owner.Items.Remove(child);
+            }
+            if (child.Parent != null) {
+                child.Parent.ChildItems.Remove(child);
+            }
+
+            if (_owner != null) {
+                child.SetParent(_owner);
+                child.SetOwner(_owner.Owner);
+            }
+
+            _list.Insert(index, child);
+            _version++;
+
+            if (_isTrackingViewState) {
+                ((IStateManager)child).TrackViewState();
+                child.SetDirty();
+            }
+            Log.Add(new LogItem(LogItemType.Insert, index, _isTrackingViewState));
+        }
+
+
+        public void Clear() {
+            if (this.Count == 0) return;
+            if (_owner != null) {
+                Menu owner = _owner.Owner;
+                if (owner != null) {
+                    MenuItem current = owner.SelectedItem;
+                    // Check if the selected item is under this collection
+                    while (current != null) {
+                        if (this.Contains(current)) {
+                            owner.SetSelectedItem(null);
+                            break;
+                        }
+                        current = current.Parent;
+                    }
+                }
+            }
+            foreach (MenuItem item in _list) {
+                item.SetParent(null);
+            }
+            _list.Clear();
+            _version++;
+            if (_isTrackingViewState) {
+                // Clearing invalidates all previous log entries, so we can just clear them out and save some space
+                Log.Clear();
+            }
+            Log.Add(new LogItem(LogItemType.Clear, 0, _isTrackingViewState));
+        }
+
+
+        public void CopyTo(Array array, int index) {
+            if (!(array is MenuItem[])) {
+                throw new ArgumentException(SR.GetString(SR.MenuItemCollection_InvalidArrayType), "array");
+            }
+            _list.CopyTo((MenuItem[])array, index);
+        }
+
+
+        public void CopyTo(MenuItem[] array, int index) {
+            _list.CopyTo(array, index);
+        }
+
+
+        public bool Contains(MenuItem c) {
+            return _list.Contains(c);
+        }
+
+        internal MenuItem FindItem(string[] path, int pos) {
+            if (pos == path.Length) {
+                return _owner;
+            }
+
+            string pathPart = TreeView.UnEscape(path[pos]);
+            for (int i = 0; i < Count; i++) {
+                MenuItem node = _list[i];
+                if (node.Value == pathPart) {
+                    return node.ChildItems.FindItem(path, pos + 1);
+                }
+            }
+
+            return null;
+        }
+
+
+        public IEnumerator GetEnumerator() {
+            return new MenuItemCollectionEnumerator(this);
+        }
+
+
+        public int IndexOf(MenuItem value) {
+            return _list.IndexOf(value);
+        }
+
+
+        public void Remove(MenuItem value) {
+            if (value == null) {
+                throw new ArgumentNullException("value");
+            }
+
+            int index = _list.IndexOf(value);
+            if (index != -1) {
+                RemoveAt(index);
+            }
+        }
+
+
+        public void RemoveAt(int index) {
+            MenuItem item = _list[index];
+            Menu owner = item.Owner;
+            if (owner != null) {
+                MenuItem current = owner.SelectedItem;
+                // Check if the selected item is under this item
+                while (current != null) {
+                    if (current == item) {
+                        owner.SetSelectedItem(null);
+                        break;
+                    }
+                    current = current.Parent;
+                }
+            }
+            item.SetParent(null);
+
+            _list.RemoveAt(index);
+            _version++;
+            Log.Add(new LogItem(LogItemType.Remove, index, _isTrackingViewState));
+        }
+
+        internal void SetDirty() {
+            foreach (LogItem item in Log) {
+                item.Tracked = true;
+            }
+            for (int i = 0; i < Count; i++) {
+                this[i].SetDirty();
+            }
+        }
+
+        #region IStateManager implementation
+
+        /// <internalonly/>
+        bool IStateManager.IsTrackingViewState {
+            get {
+                return _isTrackingViewState;
+            }
+        }
+
+
+        /// <internalonly/>
+        void IStateManager.LoadViewState(object state) {
+            object[] nodeState = (object[])state;
+            if (nodeState != null) {
+                if (nodeState[0] != null) {
+                    string logString = (string)nodeState[0];
+                    // Process each log entry
+                    string[] items = logString.Split(',');
+                    for (int i = 0; i < items.Length; i++) {
+                        string[] parts = items[i].Split(':');
+                        LogItemType type = (LogItemType)Int32.Parse(parts[0], CultureInfo.InvariantCulture);
+                        int index = Int32.Parse(parts[1], CultureInfo.InvariantCulture);
+
+                        if (type == LogItemType.Insert) {
+                            AddAt(index, new MenuItem());
+                        }
+                        else if (type == LogItemType.Remove) {
+                            RemoveAt(index);
+                        }
+                        else if (type == LogItemType.Clear) {
+                            Clear();
+                        }
+                    }
+                }
+
+                for (int i = 0; i < nodeState.Length - 1; i++) {
+                    if ((nodeState[i + 1] != null) && (this[i] != null)) {
+                        ((IStateManager)this[i]).LoadViewState(nodeState[i + 1]);
+                    }
+                }
+            }
+        }
+
+
+        /// <internalonly/>
+        object IStateManager.SaveViewState() {
+            object[] nodes = new object[Count + 1];
+
+            bool hasViewState = false;
+
+            if ((_log != null) && (_log.Count > 0)) {
+                // Construct a string representation of the log, delimiting entries with commas
+                // and seperator command and index with a colon
+                StringBuilder builder = new StringBuilder();
+                int realLogCount = 0;
+                for (int i = 0; i < _log.Count; i++) {
+                    LogItem item = (LogItem)_log[i];
+                    if (item.Tracked) {
+                        builder.Append((int)item.Type);
+                        builder.Append(":");
+                        builder.Append(item.Index);
+                        if (i < (_log.Count - 1)) {
+                            builder.Append(",");
+                        }
+
+                        realLogCount++;
+                    }
+                }
+
+                if (realLogCount > 0) {
+                    nodes[0] = builder.ToString();
+                    hasViewState = true;
+                }
+            }
+
+            for (int i = 0; i < Count; i++) {
+                nodes[i + 1] = ((IStateManager)this[i]).SaveViewState();
+                if (nodes[i + 1] != null) {
+                    hasViewState = true;
+                }
+            }
+
+            return (hasViewState ? nodes : null);
+        }
+
+
+        /// <internalonly/>
+        void IStateManager.TrackViewState() {
+            _isTrackingViewState = true;
+            for (int i = 0; i < Count; i++) {
+                ((IStateManager)this[i]).TrackViewState();
+            }
+        }
+        #endregion
+
+        /// <devdoc>
+        ///     Convenience class for storing and using log entries.
+        /// </devdoc>
+        private class LogItem {
+            private LogItemType _type;
+            private int _index;
+            private bool _tracked;
+
+            public LogItem(LogItemType type, int index, bool tracked) {
+                _type = type;
+                _index = index;
+                _tracked = tracked;
+            }
+
+            public int Index {
+                get {
+                    return _index;
+                }
+            }
+
+            public bool Tracked {
+                get {
+                    return _tracked;
+                }
+                set {
+                    _tracked = value;
+                }
+            }
+
+            public LogItemType Type {
+                get {
+                    return _type;
+                }
+            }
+
+        }
+
+        /// <devdoc>
+        ///     Convenience enumeration for identifying log commands
+        /// </devdoc>
+        private enum LogItemType {
+            Insert = 0,
+            Remove = 1,
+            Clear = 2
+        }
+
+        // This is a copy of the ArrayListEnumeratorSimple in ArrayList.cs
+        private class MenuItemCollectionEnumerator : IEnumerator {
+            private MenuItemCollection list;
+            private int index;
+            private int version;
+            private MenuItem currentElement;
+
+            internal MenuItemCollectionEnumerator(MenuItemCollection list) {
+                this.list = list;
+                this.index = -1;
+                version = list._version;
+            }
+
+            public bool MoveNext() {
+                if (version != list._version)
+                    throw new InvalidOperationException(SR.GetString(SR.ListEnumVersionMismatch));
+
+                if (index < (list.Count - 1)) {
+                    index++;
+                    currentElement = list[index];
+                    return true;
+                }
+                else
+                    index = list.Count;
+                return false;
+            }
+
+            object IEnumerator.Current {
+                get {
+                    return Current;
+                }
+            }
+
+            public MenuItem Current {
+                get {
+                    if (index == -1)
+                        throw new InvalidOperationException(SR.GetString(SR.ListEnumCurrentOutOfRange));
+                    if (index >= list.Count)
+                        throw new InvalidOperationException(SR.GetString(SR.ListEnumCurrentOutOfRange));
+                    return currentElement;
+                }
+            }
+
+            public void Reset() {
+                if (version != list._version)
+                    throw new InvalidOperationException(SR.GetString(SR.ListEnumVersionMismatch));
+                currentElement = null;
+                index = -1;
+            }
+        }
+    }
+}