Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

408 lines
12 KiB
C#

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;
}
}
}
}