using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
namespace GMap.NET.ObjectModel{
public delegate void NotifyCollectionChangedEventHandler(object sender, NotifyCollectionChangedEventArgs e);
public interface INotifyCollectionChanged
{
// Events
event NotifyCollectionChangedEventHandler CollectionChanged;
}
public interface INotifyPropertyChanged
{
// Events
event PropertyChangedEventHandler PropertyChanged;
}
public enum NotifyCollectionChangedAction
{
Add,
Remove,
Replace,
Move,
Reset
}
public class NotifyCollectionChangedEventArgs : EventArgs
{
// Fields
private NotifyCollectionChangedAction _action;
private IList _newItems;
private int _newStartingIndex;
private IList _oldItems;
private int _oldStartingIndex;
// Methods
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Reset)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
this.InitializeAdd(action, null, -1);
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)) && (action != NotifyCollectionChangedAction.Reset))
{
throw new ArgumentException("MustBeResetAddOrRemoveActionForCtor", "action");
}
if(action == NotifyCollectionChangedAction.Reset)
{
if(changedItems != null)
{
throw new ArgumentException("ResetActionRequiresNullItem", "action");
}
this.InitializeAdd(action, null, -1);
}
else
{
if(changedItems == null)
{
throw new ArgumentNullException("changedItems");
}
this.InitializeAddOrRemove(action, changedItems, -1);
}
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)) && (action != NotifyCollectionChangedAction.Reset))
{
throw new ArgumentException("MustBeResetAddOrRemoveActionForCtor", "action");
}
if(action == NotifyCollectionChangedAction.Reset)
{
if(changedItem != null)
{
throw new ArgumentException("ResetActionRequiresNullItem", "action");
}
this.InitializeAdd(action, null, -1);
}
else
{
this.InitializeAddOrRemove(action, new object[] { changedItem }, -1);
}
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList newItems, IList oldItems)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Replace)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
if(newItems == null)
{
throw new ArgumentNullException("newItems");
}
if(oldItems == null)
{
throw new ArgumentNullException("oldItems");
}
this.InitializeMoveOrReplace(action, newItems, oldItems, -1, -1);
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int startingIndex)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)) && (action != NotifyCollectionChangedAction.Reset))
{
throw new ArgumentException("MustBeResetAddOrRemoveActionForCtor", "action");
}
if(action == NotifyCollectionChangedAction.Reset)
{
if(changedItems != null)
{
throw new ArgumentException("ResetActionRequiresNullItem", "action");
}
if(startingIndex != -1)
{
throw new ArgumentException("ResetActionRequiresIndexMinus1", "action");
}
this.InitializeAdd(action, null, -1);
}
else
{
if(changedItems == null)
{
throw new ArgumentNullException("changedItems");
}
if(startingIndex < -1)
{
throw new ArgumentException("IndexCannotBeNegative", "startingIndex");
}
this.InitializeAddOrRemove(action, changedItems, startingIndex);
}
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)) && (action != NotifyCollectionChangedAction.Reset))
{
throw new ArgumentException("MustBeResetAddOrRemoveActionForCtor", "action");
}
if(action == NotifyCollectionChangedAction.Reset)
{
if(changedItem != null)
{
throw new ArgumentException("ResetActionRequiresNullItem", "action");
}
if(index != -1)
{
throw new ArgumentException("ResetActionRequiresIndexMinus1", "action");
}
this.InitializeAdd(action, null, -1);
}
else
{
this.InitializeAddOrRemove(action, new object[] { changedItem }, index);
}
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Replace)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
this.InitializeMoveOrReplace(action, new object[] { newItem }, new object[] { oldItem }, -1, -1);
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList newItems, IList oldItems, int startingIndex)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Replace)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
if(newItems == null)
{
throw new ArgumentNullException("newItems");
}
if(oldItems == null)
{
throw new ArgumentNullException("oldItems");
}
this.InitializeMoveOrReplace(action, newItems, oldItems, startingIndex, startingIndex);
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int index, int oldIndex)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Move)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
if(index < 0)
{
throw new ArgumentException("IndexCannotBeNegative", "index");
}
this.InitializeMoveOrReplace(action, changedItems, changedItems, index, oldIndex);
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index, int oldIndex)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Move)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
if(index < 0)
{
throw new ArgumentException("IndexCannotBeNegative", "index");
}
object[] newItems = new object[] { changedItem };
this.InitializeMoveOrReplace(action, newItems, newItems, index, oldIndex);
}
public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem, int index)
{
this._newStartingIndex = -1;
this._oldStartingIndex = -1;
if(action != NotifyCollectionChangedAction.Replace)
{
throw new ArgumentException("WrongActionForCtor", "action");
}
this.InitializeMoveOrReplace(action, new object[] { newItem }, new object[] { oldItem }, index, index);
}
private void InitializeAdd(NotifyCollectionChangedAction action, IList newItems, int newStartingIndex)
{
this._action = action;
#if !PocketPC
this._newItems = (newItems == null) ? null : ArrayList.ReadOnly(newItems);
#else
this._newItems = (newItems == null) ? null : newItems;
#endif
this._newStartingIndex = newStartingIndex;
}
private void InitializeAddOrRemove(NotifyCollectionChangedAction action, IList changedItems, int startingIndex)
{
if(action == NotifyCollectionChangedAction.Add)
{
this.InitializeAdd(action, changedItems, startingIndex);
}
else if(action == NotifyCollectionChangedAction.Remove)
{
this.InitializeRemove(action, changedItems, startingIndex);
}
else
{
throw new ArgumentException(string.Format("InvariantFailure, Unsupported action: {0}", action.ToString()));
}
}
private void InitializeMoveOrReplace(NotifyCollectionChangedAction action, IList newItems, IList oldItems, int startingIndex, int oldStartingIndex)
{
this.InitializeAdd(action, newItems, startingIndex);
this.InitializeRemove(action, oldItems, oldStartingIndex);
}
private void InitializeRemove(NotifyCollectionChangedAction action, IList oldItems, int oldStartingIndex)
{
this._action = action;
#if !PocketPC
this._oldItems = (oldItems == null) ? null : ArrayList.ReadOnly(oldItems);
#else
this._oldItems = (oldItems == null) ? null : oldItems;
#endif
this._oldStartingIndex = oldStartingIndex;
}
// Properties
public NotifyCollectionChangedAction Action
{
get
{
return this._action;
}
}
public IList NewItems
{
get
{
return this._newItems;
}
}
public int NewStartingIndex
{
get
{
return this._newStartingIndex;
}
}
public IList OldItems
{
get
{
return this._oldItems;
}
}
public int OldStartingIndex
{
get
{
return this._oldStartingIndex;
}
}
}
[Serializable]
public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged
{
// Fields
private SimpleMonitor _monitor;
private const string CountString = "Count";
private const string IndexerName = "Item[]";
// Events
[field: NonSerialized]
public virtual event NotifyCollectionChangedEventHandler CollectionChanged;
[field: NonSerialized]
protected event PropertyChangedEventHandler PropertyChanged;
event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
{
add
{
PropertyChanged += value;
}
remove
{
PropertyChanged -= value;
}
}
// Methods
public ObservableCollection()
{
this._monitor = new SimpleMonitor();
}
public ObservableCollection(IEnumerable<T> collection)
{
this._monitor = new SimpleMonitor();
if(collection == null)
{
throw new ArgumentNullException("collection");
}
this.CopyFrom(collection);
}
public ObservableCollection(List<T> list)
: base((list != null) ? new List<T>(list.Count) : list)
{
this._monitor = new SimpleMonitor();
this.CopyFrom(list);
}
protected IDisposable BlockReentrancy()
{
this._monitor.Enter();
return this._monitor;
}
protected void CheckReentrancy()
{
if((this._monitor.Busy && (this.CollectionChanged != null)) && (this.CollectionChanged.GetInvocationList().Length > 1))
{
throw new InvalidOperationException("ObservableCollectionReentrancyNotAllowed");
}
}
protected override void ClearItems()
{
this.CheckReentrancy();
base.ClearItems();
this.OnPropertyChanged(CountString);
this.OnPropertyChanged(IndexerName);
this.OnCollectionReset();
}
private void CopyFrom(IEnumerable<T> collection)
{
IList<T> items = base.Items;
if((collection != null) && (items != null))
{
using(IEnumerator<T> enumerator = collection.GetEnumerator())
{
while(enumerator.MoveNext())
{
items.Add(enumerator.Current);
}
}
}
}
protected override void InsertItem(int index, T item)
{
this.CheckReentrancy();
base.InsertItem(index, item);
this.OnPropertyChanged(CountString);
this.OnPropertyChanged(IndexerName);
this.OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
}
public void Move(int oldIndex, int newIndex)
{
this.MoveItem(oldIndex, newIndex);
}
protected virtual void MoveItem(int oldIndex, int newIndex)
{
this.CheckReentrancy();
T item = base[oldIndex];
base.RemoveItem(oldIndex);
base.InsertItem(newIndex, item);
this.OnPropertyChanged(IndexerName);
this.OnCollectionChanged(NotifyCollectionChangedAction.Move, item, newIndex, oldIndex);
}
protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
if(this.CollectionChanged != null)
{
using(this.BlockReentrancy())
{
this.CollectionChanged(this, e);
}
}
}
private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index)
{
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index));
}
private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index, int oldIndex)
{
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index, oldIndex));
}
private void OnCollectionChanged(NotifyCollectionChangedAction action, object oldItem, object newItem, int index)
{
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index));
}
private void OnCollectionReset()
{
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
if(this.PropertyChanged != null)
{
this.PropertyChanged(this, e);
}
}
private void OnPropertyChanged(string propertyName)
{
this.OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
protected override void RemoveItem(int index)
{
this.CheckReentrancy();
T item = base[index];
base.RemoveItem(index);
this.OnPropertyChanged(CountString);
this.OnPropertyChanged(IndexerName);
this.OnCollectionChanged(NotifyCollectionChangedAction.Remove, item, index);
}
protected override void SetItem(int index, T item)
{
this.CheckReentrancy();
T oldItem = base[index];
base.SetItem(index, item);
this.OnPropertyChanged(IndexerName);
this.OnCollectionChanged(NotifyCollectionChangedAction.Replace, oldItem, item, index);
}
// Nested Types
[Serializable]
private class SimpleMonitor : IDisposable
{
// Fields
private int _busyCount;
// Methods
public void Dispose()
{
this._busyCount--;
}
public void Enter()
{
this._busyCount++;
}
// Properties
public bool Busy
{
get
{
return (this._busyCount > 0);
}
}
}
}
}
|