SortedBindingList.cs

Go to the documentation of this file.

#if !NETFX_CORE
//-----------------------------------------------------------------------
// <copyright file="SortedBindingList.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Provides a sorted view into an existing IList(Of T).</summary>
//-----------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Collections;
using Csla.Properties;
 
namespace Csla
{
 
  public class SortedBindingList<T> :
    IList<T>, IBindingList, IEnumerable<T>, ICancelAddNew
  {
 
    #region ListItem class
 
    private class ListItem : IComparable<ListItem>
    {
 
      private object _key;
      private int _baseIndex;
 
      public object Key
      {
        get { return _key; }
      }
 
      public int BaseIndex
      {
        get { return _baseIndex; }
        set { _baseIndex = value; }
      }
 
      public ListItem(object key, int baseIndex)
      {
        _key = key;
        _baseIndex = baseIndex;
      }
 
      public int CompareTo(ListItem other)
      {
        object target = other.Key;
 
        if (Key is IComparable)
          return ((IComparable)Key).CompareTo(target);
 
        else
        {
          if (Key == null)
          {
            if (target == null)
              return 0;
            else
              return 1;
          }
          else if (Key.Equals(target))
            return 0;
 
          else if (target == null)
            return 1;
 
          return Key.ToString().CompareTo(target.ToString());
        }
      }
 
      public override string ToString()
      {
        return Key.ToString();
      }
 
    }
 
    #endregion
 
    #region Sorted enumerator
 
    private class SortedEnumerator : IEnumerator<T>
    {
      private IList<T> _list;
      private List<ListItem> _sortIndex;
      private ListSortDirection _sortOrder;
      private int _index;
 
      public SortedEnumerator(
        IList<T> list,
        List<ListItem> sortIndex,
        ListSortDirection direction)
      {
        _list = list;
        _sortIndex = sortIndex;
        _sortOrder = direction;
        Reset();
      }
 
      public T Current
      {
        get { return _list[_sortIndex[_index].BaseIndex]; }
      }
 
      Object System.Collections.IEnumerator.Current
      {
        get { return _list[_sortIndex[_index].BaseIndex]; }
      }
 
      public bool MoveNext()
      {
        if (_sortOrder == ListSortDirection.Ascending)
        {
          if (_index < _sortIndex.Count - 1)
          {
            _index++;
            return true;
          }
          else
            return false;
        }
        else
        {
          if (_index > 0)
          {
            _index--;
            return true;
          }
          else
            return false;
        }
      }
 
      public void Reset()
      {
        if (_sortOrder == ListSortDirection.Ascending)
          _index = -1;
        else
          _index = _sortIndex.Count;
      }
 
      #region IDisposable Support
 
      private bool _disposedValue = false; // To detect redundant calls.
 
      // IDisposable
      protected virtual void Dispose(bool disposing)
      {
        if (!_disposedValue)
        {
          if (disposing)
          {
            // free unmanaged resources when explicitly called
          }
          // free shared unmanaged resources
        }
        _disposedValue = true;
      }
 
      // this code added to correctly implement the disposable pattern.
      public void Dispose()
      {
        // Do not change this code.  Put cleanup code in Dispose(bool disposing) above.
        Dispose(true);
        GC.SuppressFinalize(this);
      }
 
      ~SortedEnumerator()
      {
        Dispose(false);
      }
 
      #endregion
 
    }
 
    #endregion
 
    #region Sort/Unsort
 
    private void DoSort()
    {
      int index = 0;
      _sortIndex.Clear();
 
      if (_sortBy == null)
      {
        foreach (T obj in _list)
        {
          _sortIndex.Add(new ListItem(obj, index));
          index++;
        }
      }
      else
      {
        foreach (T obj in _list)
        {
          _sortIndex.Add(new ListItem(_sortBy.GetValue(obj), index));
          index++;
        }
      }
 
      _sortIndex.Sort();
      _sorted = true;
 
      OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, 0));
 
    }
 
    private void UndoSort()
    {
      _sortIndex.Clear();
      _sortBy = null;
      _sortOrder = ListSortDirection.Ascending;
      _sorted = false;
 
      OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, 0));
 
    }
 
    #endregion
 
    #region IEnumerable<T>
 
    public IEnumerator<T> GetEnumerator()
    {
      if (_sorted)
        return new SortedEnumerator(_list, _sortIndex, _sortOrder);
      else
        return _list.GetEnumerator();
    }
 
    #endregion
 
    #region IBindingList, IList<T>
 
    public void AddIndex(PropertyDescriptor property)
    {
      if (_supportsBinding)
        _bindingList.AddIndex(property);
    }
 
    public object AddNew()
    {
      object result;
      if (_supportsBinding)
      {
        _initiatedLocally = true;
        result = _bindingList.AddNew();
        _initiatedLocally = false;
        OnListChanged(
          new ListChangedEventArgs(
          ListChangedType.ItemAdded, _bindingList.Count - 1));
      }
      else
        result = null;
 
      return result;
    }
 
    public bool AllowEdit
    {
      get
      {
        if (_supportsBinding)
          return _bindingList.AllowEdit;
        else
          return false;
      }
    }
 
    public bool AllowNew
    {
      get
      {
        if (_supportsBinding)
          return _bindingList.AllowNew;
        else
          return false;
      }
    }
 
    public bool AllowRemove
    {
      get
      {
        if (_supportsBinding)
          return _bindingList.AllowRemove;
        else
          return false;
      }
    }
 
    public void ApplySort(string propertyName, ListSortDirection direction)
    {
      _sortBy = GetPropertyDescriptor(propertyName);
 
      ApplySort(_sortBy, direction);
    }
 
    public void ApplySort(
      PropertyDescriptor property, ListSortDirection direction)
    {
      _sortBy = property;
      _sortOrder = direction;
      DoSort();
    }
 
    public int Find(string propertyName, object key)
    {
      PropertyDescriptor findProperty = GetPropertyDescriptor(propertyName);
 
      return Find(findProperty, key);
 
    }
 
    private static PropertyDescriptor GetPropertyDescriptor(string propertyName)
    {
      PropertyDescriptor property = null;
 
      if (!String.IsNullOrEmpty(propertyName))
      {
        Type itemType = typeof(T);
        foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(itemType))
        {
          if (prop.Name == propertyName)
          {
            property = prop;
            break;
          }
        }
 
        // throw exception if propertyDescriptor could not be found
        if (property == null)
          throw new ArgumentException(string.Format(Resources.SortedBindingListPropertyNameNotFound, propertyName), propertyName);
      }
 
      return property;
    }
 
    public int Find(PropertyDescriptor property, object key)
    {
      if (_supportsBinding)
      {
        var originalIndex = _bindingList.Find(property, key);
        return originalIndex > -1 ? SortedIndex(originalIndex) : -1;
      }
      else
        return -1;
    }
 
    public bool IsSorted
    {
      get { return _sorted; }
    }
 
    public event ListChangedEventHandler ListChanged;
 
    protected void OnListChanged(ListChangedEventArgs e)
    {
      if (ListChanged != null)
        ListChanged(this, e);
    }
 
    public void RemoveIndex(PropertyDescriptor property)
    {
      if (_supportsBinding)
        _bindingList.RemoveIndex(property);
    }
 
    public void RemoveSort()
    {
      UndoSort();
    }
 
    public ListSortDirection SortDirection
    {
      get { return _sortOrder; }
    }
 
    public PropertyDescriptor SortProperty
    {
      get { return _sortBy; }
    }
 
    public bool SupportsChangeNotification
    {
      get { return true; }
    }
 
    public bool SupportsSearching
    {
      get
      {
        if (_supportsBinding)
          return _bindingList.SupportsSearching;
        else
          return false;
      }
    }
 
    public bool SupportsSorting
    {
      get { return true; }
    }
 
    public void CopyTo(T[] array, int arrayIndex)
    {
      int pos = arrayIndex;
      foreach (T child in this)
      {
        array[pos] = child;
        pos++;
      }
    }
 
    void System.Collections.ICollection.CopyTo(System.Array array, int index)
    {
      T[] tmp = new T[array.Length];
      CopyTo(tmp, index);
      Array.Copy(tmp, 0, array, index, array.Length);
    }
 
    public int Count
    {
      get { return _list.Count; }
    }
 
    bool System.Collections.ICollection.IsSynchronized
    {
      get { return false; }
    }
 
    object System.Collections.ICollection.SyncRoot
    {
      get { return _list; }
    }
 
    IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
      return GetEnumerator();
    }
 
    public void Add(T item)
    {
      _list.Add(item);
    }
 
    int System.Collections.IList.Add(object value)
    {
      Add((T)value);
      return SortedIndex(_list.Count - 1);
    }
 
    public void Clear()
    {
      _list.Clear();
    }
 
    public bool Contains(T item)
    {
      return _list.Contains(item);
    }
 
    bool System.Collections.IList.Contains(object value)
    {
      return Contains((T)value);
    }
 
    public int IndexOf(T item)
    {
      return SortedIndex(_list.IndexOf(item));
    }
 
    int System.Collections.IList.IndexOf(object value)
    {
      return IndexOf((T)value);
    }
 
    public void Insert(int index, T item)
    {
      _list.Insert(index, item);
    }
 
    void System.Collections.IList.Insert(int index, object value)
    {
      Insert(index, (T)value);
    }
 
    bool System.Collections.IList.IsFixedSize
    {
      get { return false; }
    }
 
    public bool IsReadOnly
    {
      get { return _list.IsReadOnly; }
    }
 
    object System.Collections.IList.this[int index]
    {
      get
      {
        return this[index];
      }
      set
      {
        this[index] = (T)value;
      }
    }
 
    public bool Remove(T item)
    {
      return _list.Remove(item);
    }
 
    void System.Collections.IList.Remove(object value)
    {
      Remove((T)value);
    }
 
    public void RemoveAt(int index)
    {
      if (_sorted)
      {
        _initiatedLocally = true;
        int baseIndex = OriginalIndex(index);
 
        // remove the item from the source list
        _list.RemoveAt(baseIndex);
 
        _initiatedLocally = false;
      }
      else
        _list.RemoveAt(index);
    }
 
    public T this[int index]
    {
      get
      {
        if (_sorted)
          return _list[OriginalIndex(index)];
        else
          return _list[index];
      }
      set
      {
        if (_sorted)
          _list[OriginalIndex(index)] = value;
        else
          _list[index] = value;
      }
    }
 
    #endregion
 
    #region SourceList
 
    [EditorBrowsable(EditorBrowsableState.Advanced)]
    public IList<T> SourceList
    {
      get
      {
        return _list;
      }
    }
 
    #endregion
 
    private IList<T> _list;
    private bool _supportsBinding;
    private IBindingList _bindingList;
    private bool _sorted;
    private bool _initiatedLocally;
    private PropertyDescriptor _sortBy;
    private ListSortDirection _sortOrder =
      ListSortDirection.Ascending;
    private List<ListItem> _sortIndex =
      new List<ListItem>();
 
 
    public SortedBindingList(IList<T> list)
    {
      _list = list;
 
      if (_list is IBindingList)
      {
        _supportsBinding = true;
        _bindingList = (IBindingList)_list;
        _bindingList.ListChanged +=
          new ListChangedEventHandler(SourceChanged);
      }
    }
 
    private void SourceChanged(
      object sender, ListChangedEventArgs e)
    {
      if (_sorted)
      {
        switch (e.ListChangedType)
        {
          case ListChangedType.ItemAdded:
            T newItem = _list[e.NewIndex];
            if (e.NewIndex == _list.Count - 1)
            {
              object newKey;
              if (_sortBy != null)
                newKey = _sortBy.GetValue(newItem);
              else
                newKey = newItem;
 
              if (_sortOrder == ListSortDirection.Ascending)
                _sortIndex.Add(
                  new ListItem(newKey, e.NewIndex));
              else
                _sortIndex.Insert(0,
                  new ListItem(newKey, e.NewIndex));
              if (!_initiatedLocally)
                OnListChanged(
                  new ListChangedEventArgs(
                  ListChangedType.ItemAdded,
                  SortedIndex(e.NewIndex)));
            }
            else
              DoSort();
            break;
 
          case ListChangedType.ItemChanged:
            // an item changed - just relay the event with
            // a translated index value
            OnListChanged(
              new ListChangedEventArgs(
              ListChangedType.ItemChanged, SortedIndex(e.NewIndex), e.PropertyDescriptor));
            break;
 
          case ListChangedType.ItemDeleted:
            var internalIndex = InternalIndex(e.NewIndex);
            var sortedIndex = internalIndex;
            if ((_sorted) && (_sortOrder == ListSortDirection.Descending))
              sortedIndex = _sortIndex.Count - 1 - internalIndex;
 
            // remove from internal list 
            _sortIndex.RemoveAt(internalIndex);
 
            // now fix up all index pointers in the sort index
            foreach (ListItem item in _sortIndex)
              if (item.BaseIndex > e.NewIndex)
                item.BaseIndex -= 1;
 
            OnListChanged(
               new ListChangedEventArgs(
              ListChangedType.ItemDeleted, sortedIndex, e.PropertyDescriptor));
            break;
 
          default:
            // for anything other than add, delete or change
            // just re-sort the list
            if (!_initiatedLocally)
              DoSort();
            break;
        }
      }
      else
      {
        if (!_initiatedLocally)
          OnListChanged(e);
      }
    }
 
    private int OriginalIndex(int sortedIndex)
    {
      if (sortedIndex == -1) return -1;
 
      if (_sorted)
      {
        if (_sortOrder == ListSortDirection.Ascending)
          return _sortIndex[sortedIndex].BaseIndex;
        else
          return _sortIndex[_sortIndex.Count - 1 - sortedIndex].BaseIndex;
      }
      else
        return sortedIndex;
    }
 
    private int SortedIndex(int originalIndex)
    {
      if (originalIndex == -1) return -1;
 
      int result = 0;
      if (_sorted)
      {
        for (int index = 0; index < _sortIndex.Count; index++)
        {
          if (_sortIndex[index].BaseIndex == originalIndex)
          {
            result = index;
            break;
          }
        }
        if (_sortOrder == ListSortDirection.Descending)
          result = _sortIndex.Count - 1 - result;
      }
      else
        result = originalIndex;
      return result;
    }
 
    private int InternalIndex(int originalIndex)
    {
      int result = 0;
      if (_sorted)
      {
        for (int index = 0; index < _sortIndex.Count; index++)
        {
          if (_sortIndex[index].BaseIndex == originalIndex)
          {
            result = index;
            break;
          }
        }
      }
      else
        result = originalIndex;
      return result;
    }
 
 
    #region ICancelAddNew Members
 
    void ICancelAddNew.CancelNew(int itemIndex)
    {
      if (itemIndex <= -1) return;
 
      ICancelAddNew can = _list as ICancelAddNew;
      if (can != null)
        can.CancelNew(OriginalIndex(itemIndex));
      else
        _list.RemoveAt(OriginalIndex(itemIndex));
    }
 
    void ICancelAddNew.EndNew(int itemIndex)
    {
      ICancelAddNew can = _list as ICancelAddNew;
      if (can != null)
        can.EndNew(OriginalIndex(itemIndex));
    }
 
    #endregion
 
    #region ToArray
 
    public T[] ToArray()
    {
      List<T> result = new List<T>();
      foreach (T item in this)
        result.Add(item);
      return result.ToArray();
    }
 
    #endregion
 
  }
}
#endif