init

Backup/Common/ObservableCollectionWrapper.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Collections.Specialized;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Research.DynamicDataDisplay.Common
+{
+	public class ObservableCollectionWrapper<T> : INotifyCollectionChanged, IList<T>
+	{
+		public ObservableCollectionWrapper() : this(new ObservableCollection<T>()) { }
+
+		private readonly ObservableCollection<T> collection;
+		public ObservableCollectionWrapper(ObservableCollection<T> collection)
+		{
+			if (collection == null)
+				throw new ArgumentNullException("collection");
+
+			this.collection = collection;
+			collection.CollectionChanged += new NotifyCollectionChangedEventHandler(collection_CollectionChanged);
+		}
+
+		private int attemptsToRaiseChanged = 0;
+		private bool raiseEvents = true;
+
+		public bool RaisingEvents
+		{
+			get { return raiseEvents; }
+		}
+
+		private void collection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+		{
+			attemptsToRaiseChanged++;
+			if (raiseEvents)
+			{
+				CollectionChanged.Raise(this, e);
+			}
+		}
+
+		#region Update methods
+
+		public void BeginUpdate()
+		{
+			attemptsToRaiseChanged = 0;
+			raiseEvents = false;
+		}
+		public void EndUpdate()
+		{
+			raiseEvents = true;
+			if (attemptsToRaiseChanged > 0)
+				CollectionChanged.Raise(this);
+		}
+
+		public IDisposable BlockEvents()
+		{
+			return new EventBlocker<T>(this);
+		}
+
+		private sealed class EventBlocker<TT> : IDisposable
+		{
+			private readonly ObservableCollectionWrapper<TT> collection;
+			public EventBlocker(ObservableCollectionWrapper<TT> collection)
+			{
+				this.collection = collection;
+				collection.BeginUpdate();
+			}
+
+			#region IDisposable Members
+
+			public void Dispose()
+			{
+				collection.EndUpdate();
+			}
+
+			#endregion
+		}
+
+		#endregion // end of Update methods
+
+		#region IList<T> Members
+
+		public int IndexOf(T item)
+		{
+			return collection.IndexOf(item);
+		}
+
+		public void Insert(int index, T item)
+		{
+			collection.Insert(index, item);
+		}
+
+		public void RemoveAt(int index)
+		{
+			collection.RemoveAt(index);
+		}
+
+		public T this[int index]
+		{
+			get
+			{
+				return collection[index];
+			}
+			set
+			{
+				collection[index] = value;
+			}
+		}
+
+		#endregion
+
+		#region ICollection<T> Members
+
+		public void Add(T item)
+		{
+			collection.Add(item);
+		}
+
+		public void Clear()
+		{
+			collection.Clear();
+		}
+
+		public bool Contains(T item)
+		{
+			return collection.Contains(item);
+		}
+
+		public void CopyTo(T[] array, int arrayIndex)
+		{
+			collection.CopyTo(array, arrayIndex);
+		}
+
+		public int Count
+		{
+			get { return collection.Count; }
+		}
+
+		public bool IsReadOnly
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		public bool Remove(T item)
+		{
+			return collection.Remove(item);
+		}
+
+		#endregion
+
+		#region IEnumerable<T> Members
+
+		public IEnumerator<T> GetEnumerator()
+		{
+			return collection.GetEnumerator();
+		}
+
+		#endregion
+
+		#region IEnumerable Members
+
+		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+
+		#endregion
+
+		#region INotifyCollectionChanged Members
+
+		public event NotifyCollectionChangedEventHandler CollectionChanged;
+
+		#endregion
+	}
+}