source/csla10/CSLA.Core.Bindablebase/BindableCollectionBase.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Collections;
+using System.ComponentModel;
+
+namespace CSLA.Core 
+{
+  /// <summary>
+  /// This is a base class that exposes an implementation
+  /// of IBindableList that does nothing other than
+  /// create a nonserialized version of the listchanged
+  /// event.
+  /// </summary>
+  [Serializable]
+  public abstract class BindableCollectionBase : CollectionBase, IBindingList 
+  {
+
+		#region Protected control variables
+
+		/// <summary>
+		/// Set this to True to allow data binding to add new
+		/// child objects to the collection.
+		/// </summary>
+		/// <remarks>
+		/// If you set this to True, you must also override the OnAddNew
+		/// method. You must also set AllowEdit to True.
+		/// </remarks>
+    protected bool AllowNew = false;
+		/// <summary>
+		/// Set this to True to allow data binding to do in-place
+		/// editing of child objects in a grid control.
+		/// </summary>
+    protected bool AllowEdit = false;
+		/// <summary>
+		/// Set this to True to allow data binding to automatically
+		/// remove child objects from the collection.
+		/// </summary>
+    protected bool AllowRemove = false;
+		/// <summary>
+		/// Set this to True to allow this collection to be sorted.
+		/// </summary>
+		/// <remarks>
+		/// <para>
+		/// There is an overhead cost to enabling sorting. Specifically,
+		/// the collection must contain an internal collection containing
+		/// the original order of the items in the collection, so the order
+		/// can be reset if the sort is removed.
+		/// </para><para>
+		/// This overhead is only incurred if AllowSort is set to True, and is
+		/// only a major concern if you are using a remote DataPortal. The concern
+		/// there is that this extra collection must also be serialized, thus
+		/// increasing the overall amount of data sent across the wire.
+		/// </para>
+		/// </remarks>
+		protected bool AllowSort = false;
+		/// <summary>
+		/// Set this to True to allow this collection to be
+		/// searched.
+		/// </summary>
+		protected bool AllowFind = false;
+
+		#endregion
+
+		#region ListChanged event
+
+		/// <summary>
+		/// Declares a serialization-safe ListChanged event.
+		/// </summary>
+		[field: NonSerialized]
+		public event System.ComponentModel.ListChangedEventHandler ListChanged;
+    
+		/// <summary>
+		/// Call this method to raise the ListChanged event.
+		/// </summary>
+		virtual protected void OnListChanged(System.ComponentModel.ListChangedEventArgs e)
+		{
+			if (ListChanged != null)
+				ListChanged(this, e);
+		}
+
+		#endregion
+
+		#region Collection events
+
+		// *******************************************************************
+		/// <summary>
+		/// Ensures that the OnListChanged event is raised when a
+		/// new child is inserted.
+		/// </summary>
+		override protected void OnInsertComplete(int index, object value)
+		{
+			OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, index));
+		}
+
+		/// <summary>
+		/// Ensures that the OnListChanged event is raised when the
+		/// list is cleared.
+		/// </summary>
+		override protected void OnClearComplete()
+		{
+			OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, 0));
+		}
+
+		/// <summary>
+		/// Ensures that the OnListChanged event is raised when an
+		/// item is removed.
+		/// </summary>
+		override protected void OnRemoveComplete(int index, object value)
+		{
+			OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
+		}
+
+		/// <summary>
+		/// Ensures that the OnListChanged event is raised when an
+		/// item is changed.
+		/// </summary>
+		override protected void OnSetComplete(int index, object oldValue, object newValue)
+		{
+			OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
+		}
+
+		#endregion
+
+		#region IBindingList interface
+
+		// *******************************************************************
+		// This is most of the IBindingList interface.
+		// Notice that each of these implementations merely
+		// calls a virtual method, so subclasses can override those
+		// methods and provide the actual implementation of the interface
+
+		object IBindingList.AddNew() { return OnAddNew(); }
+
+		bool IBindingList.AllowEdit { get { return AllowEdit; } }
+		bool IBindingList.AllowNew { get { return AllowNew; } }
+		bool IBindingList.AllowRemove { get { return AllowRemove; } }
+		bool IBindingList.SupportsSearching { get { return AllowFind; } }
+		bool IBindingList.SupportsSorting { get { return AllowSort; } }
+
+		bool IBindingList.SupportsChangeNotification { get { return true; } }
+
+		int IBindingList.Find(System.ComponentModel.PropertyDescriptor property, object key) 
+		{ 
+			return IBindingList_Find(property, key);
+		}
+
+		void IBindingList.AddIndex(System.ComponentModel.PropertyDescriptor property) {}
+		void IBindingList.RemoveIndex(System.ComponentModel.PropertyDescriptor property) {}
+
+		void IBindingList.ApplySort(System.ComponentModel.PropertyDescriptor property, System.ComponentModel.ListSortDirection direction) 
+		{
+			IBindingList_ApplySort(property, direction);
+		}
+		void IBindingList.RemoveSort() 
+		{
+			IBindingList_RemoveSort();
+		}
+		bool IBindingList.IsSorted { get { return IBindingList_IsSorted; } }
+		System.ComponentModel.ListSortDirection IBindingList.SortDirection { get { return IBindingList_SortDirection; } }
+		System.ComponentModel.PropertyDescriptor IBindingList.SortProperty { get { return IBindingList_SortProperty; } }
+
+		#endregion
+
+		#region OnAddNew
+
+		// *******************************************************************
+		// The following methods allow a subclass to actually provide
+		// the implementation of adding a new child object
+
+		/// <summary>
+		/// Override this method to allow data binding to automatically
+		/// add new child objects to a collection.
+		/// </summary>
+		/// <returns></returns>
+		virtual protected object OnAddNew() { return null; }
+
+		#endregion
+
+		#region Search/Find
+
+		// *******************************************************************
+		// The following methods allow a subclass to actually provide
+		// the implementation of IBindingList searching
+
+		/// <summary>
+		/// Override this method to implement search/find functionality
+		/// for the collection.
+		/// </summary>
+		/// <param name="property">The property to search.</param>
+		/// <param name="key">The value to searched for.</param>
+		/// <returns></returns>
+		protected virtual int IBindingList_Find(PropertyDescriptor property, object key) 
+		{
+			return -1;
+		}
+
+		#endregion
+
+		#region Sorting
+
+		// *******************************************************************
+		// The following methods allow a subclass to actually provide
+		// the implementation of IBindingList sorting
+
+		/// <summary>
+		/// Override this method to indicate whether your collection
+		/// is currently sorted. This returns False by default.
+		/// </summary>
+		protected virtual bool IBindingList_IsSorted 
+		{	get{		return false;}}
+
+		/// <summary>
+		/// Override this method to return the property by which
+		/// the collection is sorted (if you implement sorting).
+		/// </summary>
+		protected virtual System.ComponentModel.PropertyDescriptor IBindingList_SortProperty 
+		{	get{		return null;}}
+
+		/// <summary>
+		/// Override this method to return the current sort direction
+		/// (if you implement sorting).
+		/// </summary>
+		protected virtual ListSortDirection IBindingList_SortDirection 
+		{	get{		return ListSortDirection.Ascending;}}
+
+		/// <summary>
+		/// Override this method to provide sorting functionality
+		/// (if you implement sorting).
+		/// </summary>
+		/// <param name="property">The property on which to sort.</param>
+		/// <param name="direction">The sort direction.</param>
+		protected virtual void IBindingList_ApplySort(PropertyDescriptor property, ListSortDirection direction) {}
+
+		/// <summary>
+		/// Override this method to remove any existing sort
+		/// (if you implement sorting).
+		/// </summary>
+		protected virtual void IBindingList_RemoveSort() {}
+
+		#endregion
+
+  }
+}