ListCollectionView.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Framework / System / Windows / Data / ListCollectionView.cs / 1 / ListCollectionView.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) 2003 by Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: ICollectionView for collections implementing IList 
//
// See spec at http://avalon/connecteddata/Specs/CollectionView.mht 
//
// History:
//  06/02/2003 : [....]   - Ported from DotNet tree
//  03/27/2004 : kenlai     - Implement IList 
//
//--------------------------------------------------------------------------- 
 
using System;
using System.Collections; 
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel; 
using System.Diagnostics;
using System.Reflection;        // ConstructorInfo 
 
using System.Windows;
 
using MS.Internal;
using MS.Internal.Data;
using MS.Utility;
 
namespace System.Windows.Data
{ 
    /// 
    ///  based on and associated to .
    /// 
    public class ListCollectionView : CollectionView, IComparer, IEditableCollectionView, IItemProperties
    {
        //-----------------------------------------------------
        // 
        //  Constructors
        // 
        //----------------------------------------------------- 

        #region Constructors 

        /// 
        /// Constructor
        ///  
        /// Underlying IList
        public ListCollectionView(IList list) 
            : base(list) 
        {
            _internalList = list; 

            if (InternalList.Count == 0)    // don't call virtual IsEmpty in ctor
            {
                SetCurrent(null, -1, 0); 
            }
            else 
            { 
                SetCurrent(InternalList[0], 0, 1);
            } 

            _group = new CollectionViewGroupRoot(this);
            _group.GroupDescriptionChanged += new EventHandler(OnGroupDescriptionChanged);
            ((INotifyCollectionChanged)_group).CollectionChanged += new NotifyCollectionChangedEventHandler(OnGroupChanged); 
            ((INotifyCollectionChanged)_group.GroupDescriptions).CollectionChanged += new NotifyCollectionChangedEventHandler(OnGroupByChanged);
        } 
 
        #endregion Constructors
 
        //------------------------------------------------------
        //
        //  Public Methods
        // 
        //-----------------------------------------------------
 
        #region Public Methods 

        //------------------------------------------------------ 
        #region ICollectionView

        /// 
        /// Re-create the view over the associated IList 
        /// 
        ///  
        /// Any sorting and filtering will take effect during Refresh. 
        /// 
        protected override void RefreshOverride() 
        {
            lock(SyncRoot)
            {
                ClearChangeLog(); 
                if (UpdatedOutsideDispatcher)
                { 
                    ShadowCollection = new ArrayList((ICollection)SourceCollection); 
                }
            } 

            object oldCurrentItem = CurrentItem;
            int oldCurrentPosition = IsEmpty ? -1 : CurrentPosition;
            bool oldIsCurrentAfterLast = IsCurrentAfterLast; 
            bool oldIsCurrentBeforeFirst = IsCurrentBeforeFirst;
 
            // force currency off the collection (gives user a chance to save dirty information) 
            OnCurrentChanging();
 
            IList list = UpdatedOutsideDispatcher ? ShadowCollection : (SourceCollection as IList);
            PrepareSortAndFilter(list);

            // if there's no sort/filter, just use the collection's array 
            if (!UsesLocalArray)
            { 
                _internalList = list; 
            }
            else 
            {
                _internalList = PrepareLocalArray(list);
            }
 
            PrepareGroups();
 
            if (oldIsCurrentBeforeFirst || IsEmpty) 
            {
                SetCurrent(null, -1); 
            }
            else if (oldIsCurrentAfterLast)
            {
                SetCurrent(null, InternalCount); 
            }
            else // set currency back to old current item 
            { 
                // oldCurrentItem may be null
 
                // if there are duplicates, use the position of the first matching item
                int newPosition = InternalIndexOf(oldCurrentItem);

                if (newPosition < 0) 
                {
                    // oldCurrentItem not found: move to first item 
                    object newItem; 
                    newPosition = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ?
                                1 : 0; 
                    if (newPosition < InternalCount && (newItem = InternalItemAt(newPosition)) != NewItemPlaceholder)
                    {
                        SetCurrent(newItem, newPosition);
                    } 
                    else
                    { 
                        SetCurrent(null, -1); 
                    }
                } 
                else
                {
                    SetCurrent(oldCurrentItem, newPosition);
                } 
            }
 
            // tell listeners everything has changed 
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
 
            OnCurrentChanged();

            if (IsCurrentAfterLast != oldIsCurrentAfterLast)
                OnPropertyChanged(IsCurrentAfterLastPropertyName); 

            if (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst) 
                OnPropertyChanged(IsCurrentBeforeFirstPropertyName); 

            if (oldCurrentPosition != CurrentPosition) 
                OnPropertyChanged(CurrentPositionPropertyName);

            if (oldCurrentItem != CurrentItem)
                OnPropertyChanged(CurrentItemPropertyName); 

        } 
 
        /// 
        /// Return true if the item belongs to this view.  No assumptions are 
        /// made about the item. This method will behave similarly to IList.Contains()
        /// and will do an exhaustive search through all items in this view.
        /// If the caller knows that the item belongs to the
        /// underlying collection, it is more efficient to call PassesFilter. 
        /// 
        public override bool Contains(object item) 
        { 
            VerifyRefreshNotDeferred();
 
            return InternalContains(item);
        }

        ///  
        /// Move  to the item at the given index.
        ///  
        /// Move CurrentItem to this index 
        /// true if  points to an item within the view.
        public override bool MoveCurrentToPosition(int position) 
        {
            VerifyRefreshNotDeferred();

            if (position < -1 || position > InternalCount) 
                throw new ArgumentOutOfRangeException("position");
 
 
            if (position != CurrentPosition || !IsCurrentInSync)
            { 
                object proposedCurrentItem = (0 <= position && position < InternalCount) ? InternalItemAt(position) : null;

                // ignore moves to the placeholder
                if (proposedCurrentItem != NewItemPlaceholder) 
                {
                    if (OKToChangeCurrent()) 
                    { 
                        bool oldIsCurrentAfterLast = IsCurrentAfterLast;
                        bool oldIsCurrentBeforeFirst = IsCurrentBeforeFirst; 

                        SetCurrent(proposedCurrentItem, position);

                        OnCurrentChanged(); 

                        // notify that the properties have changed. 
                        if (IsCurrentAfterLast != oldIsCurrentAfterLast) 
                            OnPropertyChanged(IsCurrentAfterLastPropertyName);
 
                        if (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst)
                            OnPropertyChanged(IsCurrentBeforeFirstPropertyName);

                        OnPropertyChanged(CurrentPositionPropertyName); 
                        OnPropertyChanged(CurrentItemPropertyName);
                    } 
                } 
            }
 
            return IsCurrentInView;
        }

        ///  
        /// Returns true if this view really supports grouping.
        /// When this returns false, the rest of the interface is ignored. 
        ///  
        public override bool CanGroup
        { 
            get { return true; }
        }

        ///  
        /// The description of grouping, indexed by level.
        ///  
        public override ObservableCollection GroupDescriptions 
        {
            get { return _group.GroupDescriptions; } 
        }

        /// 
        /// The top-level groups, constructed according to the descriptions 
        /// given in GroupDescriptions and/or GroupBySelector.
        ///  
        public override ReadOnlyObservableCollection Groups 
        {
            get { return (IsGrouping) ? _group.Items : null; } 
        }

        #endregion ICollectionView
 

        ///  
        /// Return true if the item belongs to this view.  The item is assumed to belong to the 
        /// underlying DataCollection;  this method merely takes filters into account.
        /// It is commonly used during collection-changed notifications to determine if the added/removed 
        /// item requires processing.
        /// Returns true if no filter is set on collection view.
        /// 
        public override bool PassesFilter(object item) 
        {
            return ActiveFilter == null || ActiveFilter(item); 
        } 

        ///  Return the index where the given item belongs, or -1 if this index is unknown. 
        /// 
        /// 
        /// If this method returns an index other than -1, it must always be true that
        /// view[index-1] < item <= view[index], where the comparisons are done via 
        /// the view's IComparer.Compare method (if any).
        /// (This method is used by a listener's (e.g. System.Windows.Controls.ItemsControl) 
        /// CollectionChanged event handler to speed up its reaction to insertion and deletion of items. 
        /// If IndexOf is  not implemented, a listener does a binary search using IComparer.Compare.)
        ///  
        /// data item
        public override int IndexOf(object item)
        {
            VerifyRefreshNotDeferred(); 

            return InternalIndexOf(item); 
        } 

        ///  
        /// Retrieve item at the given zero-based index in this CollectionView.
        /// 
        /// 
        /// 
The index is evaluated with any SortDescriptions or Filter being set on this CollectionView.
 
        /// 
        ///  
        /// Thrown if index is out of range 
        /// 
        public override object GetItemAt(int index) 
        {
            VerifyRefreshNotDeferred();

            return InternalItemAt(index); 
        }
 
 
        //------------------------------------------------------
        #region IComparer 

        ///  Return -, 0, or +, according to whether o1 occurs before, at, or after o2 (respectively)
        /// 
        /// first object 
        /// second object
        ///  
        /// Compares items by their resp. index in the IList. 
        /// 
        int IComparer.Compare(object o1, object o2) 
        {
            return Compare(o1, o2);
        }
 
        ///  Return -, 0, or +, according to whether o1 occurs before, at, or after o2 (respectively)
        ///  
        /// first object 
        /// second object
        ///  
        /// Compares items by their resp. index in the IList.
        /// 
        protected virtual int Compare(object o1, object o2)
        { 
            if (!IsGrouping)
            { 
                if (ActiveComparer != null) 
                    return ActiveComparer.Compare(o1, o2);
 
                int i1 = InternalList.IndexOf(o1);
                int i2 = InternalList.IndexOf(o2);
                return (i1 - i2);
            } 
            else
            { 
                int i1 = InternalIndexOf(o1); 
                int i2 = InternalIndexOf(o2);
                return (i1 - i2); 
            }
        }

        #endregion IComparer 

        ///  
        /// Implementation of IEnumerable.GetEnumerator(). 
        /// This provides a way to enumerate the members of the collection
        /// without changing the currency. 
        /// 
        protected override IEnumerator GetEnumerator()
        {
            VerifyRefreshNotDeferred(); 

            return InternalGetEnumerator(); 
        } 

        #endregion Public Methods 


        //-----------------------------------------------------
        // 
        //  Public Properties
        // 
        //------------------------------------------------------ 

        #region Public Properties 

        //-----------------------------------------------------
        #region ICollectionView
 
        /// 
        /// Collection of Sort criteria to sort items in this view over the SourceCollection. 
        ///  
        /// 
        /// 
 
        /// One or more sort criteria in form of 
        /// can be added, each specifying a property and direction to sort by.
        /// 

        ///  
        public override SortDescriptionCollection SortDescriptions
        { 
            get 
            {
                if (_sort == null) 
                    SetSortDescriptions(new SortDescriptionCollection());
                return _sort;
            }
        } 

        ///  
        /// Test if this ICollectionView supports sorting before adding 
        /// to .
        ///  
        /// 
        /// ListCollectionView does implement an IComparer based sorting.
        /// 
        public override bool CanSort 
        {
            get { return true; } 
        } 

        ///  
        /// Test if this ICollectionView supports filtering before assigning
        /// a filter callback to .
        /// 
        public override bool CanFilter 
        {
            get { return true; } 
        } 

        ///  
        /// Filter is a callback set by the consumer of the ICollectionView
        /// and used by the implementation of the ICollectionView to determine if an
        /// item is suitable for inclusion in the view.
        ///  
        /// 
        /// Simpler implementations do not support filtering and will throw a NotSupportedException. 
        /// Use  property to test if filtering is supported before 
        /// assigning a non-null value.
        ///  
        public override Predicate Filter
        {
            get
            { 
                return base.Filter;
            } 
            set 
            {
                if (IsAddingNew || IsEditingItem) 
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Filter"));
                base.Filter = value;
            }
        } 

        #endregion ICollectionView 
 
        /// 
        /// Set a custom comparer to sort items using an object that implements IComparer. 
        /// 
        /// 
        /// Setting the Sort criteria has no immediate effect,
        /// an explicit  call by the app is required. 
        /// Note: Setting the custom comparer object will clear previously set .
        ///  
        public IComparer CustomSort 
        {
            get { return _customSort; } 
            set
            {
                if (IsAddingNew || IsEditingItem)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "CustomSort")); 
                _customSort = value;
                SetSortDescriptions(null); 
 
                RefreshOrDefer();
            } 
        }

        /// 
        /// A delegate to select the group description as a function of the 
        /// parent group and its level.
        ///  
        [DefaultValue(null)] 
        public virtual GroupDescriptionSelectorCallback GroupBySelector
        { 
            get { return _group.GroupBySelector; }
            set
            {
                if (!CanGroup) 
                    throw new NotSupportedException();
                if (IsAddingNew || IsEditingItem) 
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Grouping")); 

                _group.GroupBySelector = value; 

                RefreshOrDefer();
            }
        } 

        ///  
        /// Return the estimated number of records (or -1, meaning "don't know"). 
        /// 
        public override int Count 
        {
            get
            {
                VerifyRefreshNotDeferred(); 

                return InternalCount; 
            } 
        }
 
        /// 
        /// Returns true if the resulting (filtered) view is emtpy.
        /// 
        public override bool IsEmpty 
        {
            get { return (InternalCount == 0); } 
        } 

        ///  
        /// Setting this to true informs the view that the list of items
        /// (after applying the sort and filter, if any) is already in the
        /// correct order for grouping.  This allows the view to use a more
        /// efficient algorithm to build the groups. 
        /// 
        public bool IsDataInGroupOrder 
        { 
            get { return _group.IsDataInGroupOrder; }
            set { _group.IsDataInGroupOrder = value; } 
        }

        #endregion Public Properties
 
        #region IEditableCollectionView
 
        #region Adding new items 

        ///  
        /// Indicates whether to include a placeholder for a new item, and if so,
        /// where to put it.
        /// 
        public NewItemPlaceholderPosition NewItemPlaceholderPosition 
        {
            get { return _newItemPlaceholderPosition; } 
            set 
            {
                VerifyRefreshNotDeferred(); 

                if (value != _newItemPlaceholderPosition && IsAddingNew)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "NewItemPlaceholderPosition", "AddNew"));
 
                NotifyCollectionChangedEventArgs args = null;
                int oldIndex=-1, newIndex=-1; 
 
                // we're adding, removing, or moving the placeholder.
                // Determine the appropriate events. 
                switch (value)
                {
                    case NewItemPlaceholderPosition.None:
                        switch (_newItemPlaceholderPosition) 
                        {
                            case NewItemPlaceholderPosition.None: 
                                break; 
                            case NewItemPlaceholderPosition.AtBeginning:
                                oldIndex = 0; 
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Remove,
                                                NewItemPlaceholder,
                                                oldIndex); 
                                break;
                            case NewItemPlaceholderPosition.AtEnd: 
                                oldIndex = InternalCount - 1; 
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Remove, 
                                                NewItemPlaceholder,
                                                oldIndex);
                                break;
                        } 
                        break;
 
                    case NewItemPlaceholderPosition.AtBeginning: 
                        switch (_newItemPlaceholderPosition)
                        { 
                            case NewItemPlaceholderPosition.None:
                                newIndex = 0;
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Add, 
                                                NewItemPlaceholder,
                                                newIndex); 
                                break; 
                            case NewItemPlaceholderPosition.AtBeginning:
                                break; 
                            case NewItemPlaceholderPosition.AtEnd:
                                oldIndex = InternalCount - 1;
                                newIndex = 0;
                                args = new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Move,
                                                NewItemPlaceholder, 
                                                newIndex, 
                                                oldIndex);
                                break; 
                        }
                        break;

                    case NewItemPlaceholderPosition.AtEnd: 
                        switch (_newItemPlaceholderPosition)
                        { 
                            case NewItemPlaceholderPosition.None: 
                                newIndex = InternalCount;
                                args = new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Add,
                                                NewItemPlaceholder,
                                                newIndex);
                                break; 
                            case NewItemPlaceholderPosition.AtBeginning:
                                oldIndex = 0; 
                                newIndex = InternalCount - 1; 
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Move, 
                                                NewItemPlaceholder,
                                                newIndex,
                                                oldIndex);
                                break; 
                            case NewItemPlaceholderPosition.AtEnd:
                                break; 
                        } 
                        break;
                } 

                // now make the change and raise the events
                if (args != null)
                { 
                    _newItemPlaceholderPosition = value;
 
                    if (!IsGrouping) 
                    {
                        ProcessCollectionChangedWithAdjustedIndex(args, oldIndex, newIndex); 
                    }
                    else
                    {
                        if (oldIndex >= 0) 
                        {
                            int index = (oldIndex == 0) ? 0 : _group.Items.Count - 1; 
                            _group.RemoveSpecialItem(index, NewItemPlaceholder, false /*loading*/); 
                        }
                        if (newIndex >= 0) 
                        {
                            int index = (newIndex == 0) ? 0 : _group.Items.Count;
                            _group.InsertSpecialItem(index, NewItemPlaceholder, false /*loading*/);
                        } 
                    }
 
                    OnPropertyChanged("NewItemPlaceholderPosition"); 
                }
            } 
        }

        /// 
        /// Return true if the view supports . 
        /// 
        public bool CanAddNew 
        { 
            get { return !IsEditingItem && !SourceList.IsFixedSize && CanConstructItem; }
        } 

        bool CanConstructItem
        {
            get 
            {
                if (!_isItemConstructorValid) 
                { 
                    EnsureItemConstructor();
                } 

                return (_itemConstructor != null);
            }
        } 

        void EnsureItemConstructor() 
        { 
            if (!_isItemConstructorValid)
            { 
                Type itemType = GetItemType(true);
                if (itemType != null)
                {
                    _itemConstructor = itemType.GetConstructor(Type.EmptyTypes); 
                    _isItemConstructorValid = true;
                } 
            } 
        }
 
        /// 
        /// Add a new item to the underlying collection.  Returns the new item.
        /// After calling AddNew and changing the new item as desired, either
        ///  or  should be 
        /// called to complete the transaction.
        ///  
        public object AddNew() 
        {
            VerifyRefreshNotDeferred(); 

            if (IsEditingItem)
            {
                CommitEdit();   // implicitly close a previous EditItem 
            }
 
            CommitNew();        // implicitly close a previous AddNew 

            if (!CanAddNew) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedForView, "AddNew"));

            object newItem = _itemConstructor.Invoke(null);
            _newItemIndex = -2; // this is a signal that the next Add event comes from AddNew 
            int index = SourceList.Add(newItem);
 
            // if the source doesn't raise collection change events, fake one 
            if (!(SourceList is INotifyCollectionChanged))
            { 
                // the index returned by IList.Add isn't always reliable
                if (!Object.Equals(newItem, SourceList[index]))
                {
                    index = SourceList.IndexOf(newItem); 
                }
 
                BeginAddNew(newItem, index); 
            }
 
            Debug.Assert(_newItemIndex != -2 && Object.Equals(newItem, _newItem), "AddNew did not raise expected events");

            MoveCurrentTo(newItem);
 
            ISupportInitialize isi = newItem as ISupportInitialize;
            if (isi != null) 
            { 
                isi.BeginInit();
            } 

            IEditableObject ieo = newItem as IEditableObject;
            if (ieo != null)
            { 
                ieo.BeginEdit();
            } 
 
            return newItem;
        } 

        // Calling IList.Add() will raise an ItemAdded event.  We handle this specially
        // to adjust the position of the new item in the view (it should be adjacent
        // to the placeholder), and cache the new item for use by the other APIs 
        // related to AddNew.  This method is called from ProcessCollectionChanged.
        void BeginAddNew(object newItem, int index) 
        { 
            Debug.Assert(_newItemIndex == -2 && _newItem == null, "unexpected call to BeginAddNew");
 
            // remember the new item and its position in the underlying list
            _newItem = newItem;
            _newItemIndex = index;
 
            // adjust the position of the new item
            int position = -1; 
            switch (NewItemPlaceholderPosition) 
            {
                case NewItemPlaceholderPosition.None: 
                    position = UsesLocalArray ? InternalCount - 1 : _newItemIndex;
                    break;
                case NewItemPlaceholderPosition.AtBeginning:
                    position = 1; 
                    break;
                case NewItemPlaceholderPosition.AtEnd: 
                    position = InternalCount - 2; 
                    break;
            } 

            // raise events as if the new item appeared in the adjusted position
            ProcessCollectionChangedWithAdjustedIndex(
                                        new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Add,
                                                newItem, 
                                                position), 
                                        -1, position);
        } 

        /// 
        /// Complete the transaction started by .  The new
        /// item remains in the collection, and the view's sort, filter, and grouping 
        /// specifications (if any) are applied to the new item.
        ///  
        public void CommitNew() 
        {
            if (IsEditingItem) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CommitNew", "EditItem"));
            VerifyRefreshNotDeferred();

            if (_newItem == null) 
                return;
 
            // grouping works differently 
            if (IsGrouping)
            { 
                CommitNewForGrouping();
                return;
            }
 
            // from the POV of view clients, the new item is moving from its
            // position adjacent to the placeholder to its real position. 
            // Remember its current position (have to do this before calling EndNew, 
            // because InternalCount depends on "adding-new" mode).
            int fromIndex = 0; 
            switch (NewItemPlaceholderPosition)
            {
                case NewItemPlaceholderPosition.None:
                    fromIndex = UsesLocalArray ? InternalCount - 1 : _newItemIndex; 
                    break;
                case NewItemPlaceholderPosition.AtBeginning: 
                    fromIndex = 1; 
                    break;
                case NewItemPlaceholderPosition.AtEnd: 
                    fromIndex = InternalCount - 2;
                    break;
            }
 
            // End the AddNew transaction
            object newItem = EndAddNew(false); 
 
            // Tell the view clients what happened to the new item
            int toIndex = AdjustBefore(NotifyCollectionChangedAction.Add, newItem, _newItemIndex); 

            if (toIndex < 0)
            {
                // item is effectively removed (due to filter), raise a Remove event 
                ProcessCollectionChangedWithAdjustedIndex(
                            new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Remove, 
                                                newItem,
                                                fromIndex), 
                            fromIndex, -1);
            }
            else if (fromIndex == toIndex)
            { 
                // item isn't moving, so no events are needed.  But the item does need
                // to be added to the local array. 
                if (UsesLocalArray) 
                {
                    if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) 
                    {
                        --toIndex;
                    }
                    InternalList.Insert(toIndex, newItem); 
                }
            } 
            else 
            {
                // item is moving 
                ProcessCollectionChangedWithAdjustedIndex(
                            new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Move,
                                                newItem, 
                                                toIndex, fromIndex),
                            fromIndex, toIndex); 
            } 
        }
 
        void CommitNewForGrouping()
        {
            // for grouping we cannot pretend that the new item moves to a different position,
            // since it may actually appear in several new positions (belonging to several groups). 
            // Instead, we remove the item from its temporary position, then add it to the groups
            // as if it had just been added to the underlying collection. 
            int index; 
            switch (NewItemPlaceholderPosition)
            { 
                case NewItemPlaceholderPosition.None:
                default:
                    index = _group.Items.Count - 1;
                    break; 
                case NewItemPlaceholderPosition.AtBeginning:
                    index = 1; 
                    break; 
                case NewItemPlaceholderPosition.AtEnd:
                    index = _group.Items.Count - 2; 
                    break;
            }

            // End the AddNew transaction 
            int newItemIndex = _newItemIndex;
            object newItem = EndAddNew(false); 
 
            // remove item from its temporary position
            _group.RemoveSpecialItem(index, newItem, false /*loading*/); 

            // now pretend it just got added to the collection.  This will add it
            // to the internal list with sort/filter, and to the groups
            ProcessCollectionChanged( 
                    new NotifyCollectionChangedEventArgs(
                                NotifyCollectionChangedAction.Add, 
                                newItem, 
                                newItemIndex));
        } 

        /// 
        /// Complete the transaction started by .  The new
        /// item is removed from the collection. 
        /// 
        public void CancelNew() 
        { 
            if (IsEditingItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CancelNew", "EditItem")); 
            VerifyRefreshNotDeferred();

            if (_newItem == null)
                return; 

            // remove the new item from the underlying collection.  Normally the 
            // collection will raise a Remove event, which we'll handle by calling 
            // EndNew to leave AddNew mode.
            SourceList.RemoveAt(_newItemIndex); 

            // if the collection doesn't raise events, do the work explicitly on its behalf
            if (_newItem != null)
            { 
                int index = AdjustBefore(NotifyCollectionChangedAction.Remove, _newItem, _newItemIndex);
                object newItem = EndAddNew(true); 
 
                ProcessCollectionChangedWithAdjustedIndex(
                            new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Remove,
                                                newItem,
                                                index),
                            index, -1); 
            }
        } 
 
        // Common functionality used by CommitNew, CancelNew, and when the
        // new item is removed by Remove or Refresh. 
        object EndAddNew(bool cancel)
        {
            object newItem = _newItem;
 
            _newItem = null;    // leave "adding-new" mode
 
            IEditableObject ieo = newItem as IEditableObject; 
            if (ieo != null)
            { 
                if (cancel)
                {
                    ieo.CancelEdit();
                } 
                else
                { 
                    ieo.EndEdit(); 
                }
            } 

            ISupportInitialize isi = newItem as ISupportInitialize;
            if (isi != null)
            { 
                isi.EndInit();
            } 
 
            return newItem;
        } 

        /// 
        /// Returns true if an  transaction is in progress.
        ///  
        public bool IsAddingNew
        { 
            get { return (_newItem != null); } 
        }
 
        /// 
        /// When an  transaction is in progress, this property
        /// returns the new item.  Otherwise it returns null.
        ///  
        public object CurrentAddItem
        { 
            get { return _newItem; } 
        }
 
        #endregion Adding new items

        #region Removing items
 
        /// 
        /// Return true if the view supports  and 
        /// . 
        /// 
        public bool CanRemove 
        {
            get { return !IsEditingItem && !IsAddingNew && !SourceList.IsFixedSize; }
        }
 
        /// 
        /// Remove the item at the given index from the underlying collection. 
        /// The index is interpreted with respect to the view (not with respect to 
        /// the underlying collection).
        ///  
        public void RemoveAt(int index)
        {
            if (IsEditingItem || IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "RemoveAt")); 
            VerifyRefreshNotDeferred();
 
            // convert the index from "view-relative" to "list-relative" 
            int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ? 1 : 0;
            object item = GetItemAt(index); 
            if (item == CollectionView.NewItemPlaceholder)
                throw new InvalidOperationException(SR.Get(SRID.RemovingPlaceholder));

            int listIndex = index - delta; 
            bool raiseEvent = !(SourceList is INotifyCollectionChanged);
 
            // remove the item from the list 
            if (UsesLocalArray || IsGrouping)
            { 
                if (raiseEvent)
                {
                    listIndex = SourceList.IndexOf(item);
                    SourceList.RemoveAt(listIndex); 
                }
                else 
                { 
                    SourceList.Remove(item);
                } 
            }
            else
            {
                SourceList.RemoveAt(listIndex); 
            }
 
            // if the list doesn't raise CollectionChanged events, fake one 
            if (raiseEvent)
            { 
                ProcessCollectionChanged(new NotifyCollectionChangedEventArgs(
                                            NotifyCollectionChangedAction.Remove,
                                            item,
                                            listIndex)); 
            }
        } 
 
        /// 
        /// Remove the given item from the underlying collection. 
        /// 
        public void Remove(object item)
        {
            int index = InternalIndexOf(item); 
            if (index >= 0)
            { 
                RemoveAt(index); 
            }
        } 

        #endregion Removing items

        #region Transactional editing of an item 

        ///  
        /// Begins an editing transaction on the given item.  The transaction is 
        /// completed by calling either  or
        /// .  Any changes made to the item during 
        /// the transaction are considered "pending", provided that the view supports
        /// the notion of "pending changes" for the given item.
        /// 
        public void EditItem(object item) 
        {
            VerifyRefreshNotDeferred(); 
 
            if (item == NewItemPlaceholder)
                throw new ArgumentException(SR.Get(SRID.CannotEditPlaceholder), "item"); 

            if (IsAddingNew)
            {
                if (Object.Equals(item, _newItem)) 
                    return;     // EditItem(newItem) is a no-op
 
                CommitNew();    // implicitly close a previous AddNew 
            }
 
            CommitEdit();   // implicitly close a previous EditItem transaction

            _editItem = item;
 
            IEditableObject ieo = item as IEditableObject;
            if (ieo != null) 
            { 
                ieo.BeginEdit();
            } 
        }

        /// 
        /// Complete the transaction started by . 
        /// The pending changes (if any) to the item are committed.
        ///  
        public void CommitEdit() 
        {
            if (IsAddingNew) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CommitEdit", "AddNew"));
            VerifyRefreshNotDeferred();

            if (_editItem == null) 
                return;
 
            object editItem = _editItem; 
            IEditableObject ieo = _editItem as IEditableObject;
            _editItem = null; 

            if (ieo != null)
            {
                ieo.EndEdit(); 
            }
 
            // editing may change the item's group names (and we can't tell whether 
            // it really did).  The best we can do is remove the item and re-insert
            // it. 
            if (IsGrouping)
            {
                RemoveItemFromGroups(editItem);
                AddItemToGroups(editItem); 
                return;
            } 
 
            // the edit may cause the item to move.  If so, report it.
            if (UsesLocalArray) 
            {
                int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ? 1 : 0;
                int fromIndex = InternalIndexOf(editItem);
 
                if (!PassesFilter(editItem))
                { 
                    // the item has been effectively removed 
                    ProcessCollectionChangedWithAdjustedIndex(
                                new NotifyCollectionChangedEventArgs( 
                                                    NotifyCollectionChangedAction.Remove,
                                                    editItem,
                                                    fromIndex),
                                fromIndex, -1); 
                }
                else if (ActiveComparer != null) 
                { 
                    ArrayList list = (ArrayList)InternalList;
                    int localIndex = fromIndex - delta; 
                    int toIndex = -1;
                    if (localIndex > 0 && ActiveComparer.Compare(list[localIndex-1], editItem) > 0)
                    {
                        // the item has moved toward the front of the list 
                        toIndex = list.BinarySearch(0, localIndex, editItem, ActiveComparer);
                        if (toIndex < 0) 
                            toIndex = ~toIndex; 
                    }
                    else if (localIndex < list.Count - 1 && ActiveComparer.Compare(editItem, list[localIndex+1]) > 0) 
                    {
                        // the item has moved toward the back of the list
                        toIndex = list.BinarySearch(localIndex+1, list.Count-localIndex-1, editItem, ActiveComparer);
                        if (toIndex < 0) 
                            toIndex = ~toIndex;
                        --toIndex;      // because the item is leaving its old position 
                    } 

                    if (toIndex >= 0) 
                    {
                        // the item has effectively moved
                        ProcessCollectionChangedWithAdjustedIndex(
                                    new NotifyCollectionChangedEventArgs( 
                                                        NotifyCollectionChangedAction.Move,
                                                        editItem, 
                                                        toIndex+delta, fromIndex), 
                                    fromIndex, toIndex+delta);
                    } 
                }
            }
        }
 
        /// 
        /// Complete the transaction started by . 
        /// The pending changes (if any) to the item are discarded. 
        /// 
        public void CancelEdit() 
        {
            if (IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CancelEdit", "AddNew"));
            VerifyRefreshNotDeferred(); 

            if (_editItem == null) 
                return; 

            IEditableObject ieo = _editItem as IEditableObject; 
            _editItem = null;

            if (ieo != null)
            { 
                ieo.CancelEdit();
            } 
            else 
                throw new InvalidOperationException(SR.Get(SRID.CancelEditNotSupported));
        } 

        private void ImplicitlyCancelEdit()
        {
            IEditableObject ieo = _editItem as IEditableObject; 
            _editItem = null;
 
            if (ieo != null) 
            {
                ieo.CancelEdit(); 
            }
        }

        ///  
        /// Returns true if the view supports the notion of "pending changes" on the
        /// current edit item.  This may vary, depending on the view and the particular 
        /// item.  For example, a view might return true if the current edit item 
        /// implements , or if the view has special
        /// knowledge about the item that it can use to support rollback of pending 
        /// changes.
        /// 
        public bool CanCancelEdit
        { 
            get { return (_editItem is IEditableObject); }
        } 
 
        /// 
        /// Returns true if an  transaction is in progress. 
        /// 
        public bool IsEditingItem
        {
            get { return (_editItem != null); } 
        }
 
        ///  
        /// When an  transaction is in progress, this property
        /// returns the affected item.  Otherwise it returns null. 
        /// 
        public object CurrentEditItem
        {
            get { return _editItem; } 
        }
 
        #endregion Transactional editing of an item 

        #endregion IEditableCollectionView 

        #region IItemProperties

        ///  
        /// Returns information about the properties available on items in the
        /// underlying collection.  This information may come from a schema, from 
        /// a type descriptor, from a representative item, or from some other source 
        /// known to the view.
        ///  
        public ReadOnlyCollection ItemProperties
        {
            get { return GetItemProperties(); }
        } 

        #endregion IItemProperties 
 

 
        //-----------------------------------------------------
        //
        //  Protected Methods
        // 
        //-----------------------------------------------------
        #region Protected Methods 
 

        ///  
        ///     Called by the the base class to notify derived class that
        ///     a CollectionChange has been posted to the message queue.
        ///     The purpose of this notification is to allow CollectionViews to
        ///     take a snapshot of whatever information is needed at the time 
        ///     of the Post (most likely the state of the Data Collection).
        ///  
        ///  
        ///     The NotifyCollectionChangedEventArgs that is added to the change log
        ///  
        protected override void OnBeginChangeLogging(NotifyCollectionChangedEventArgs args)
        {
            if (args == null)
                throw new ArgumentNullException("args"); 

            if (ShadowCollection == null || args.Action == NotifyCollectionChangedAction.Reset) 
            { 
                ShadowCollection = new ArrayList((ICollection)SourceCollection);
 
                if (!UsesLocalArray)
                {
                    _internalList = ShadowCollection;
                } 

                // the first change processed in ProcessChangeLog does 
                // not need to be applied to the ShadowCollection in 
                // ProcessChangeLog because the change will already be
                // reflected as a result of copying the Collection. 
                _applyChangeToShadow = false;
            }
        }
 
        /// 
        /// Handle CollectionChange events 
        ///  
        protected override void ProcessCollectionChanged(NotifyCollectionChangedEventArgs args)
        { 
            if (args == null)
                throw new ArgumentNullException("args");

            ValidateCollectionChangedEventArgs(args); 

            int adjustedOldIndex = -1; 
            int adjustedNewIndex = -1; 

            // apply the change to the shadow copy 
            if (UpdatedOutsideDispatcher)
            {
                if (_applyChangeToShadow)
                { 
                    if (args.Action != NotifyCollectionChangedAction.Reset)
                    { 
                        if (args.Action != NotifyCollectionChangedAction.Remove && args.NewStartingIndex < 0 
                            || args.Action != NotifyCollectionChangedAction.Add && args.OldStartingIndex < 0)
                        { 
                            Debug.Assert(false, "Cannot update collection view from outside UIContext without index in event args");
                            return;     //
                        }
                        else 
                        {
                            AdjustShadowCopy(args); 
                        } 
                    }
                } 
                _applyChangeToShadow = true;
            }

            // If the Action is Reset then we do a Refresh. 
            if (args.Action == NotifyCollectionChangedAction.Reset)
            { 
                // implicitly cancel EditItem transactions 
                if (IsEditingItem)
                { 
                    ImplicitlyCancelEdit();
                }

                // adjust AddNew transactions, depending on whether the new item 
                // survived the Reset
                if (IsAddingNew) 
                { 
                    _newItemIndex = SourceList.IndexOf(_newItem);
                    if (_newItemIndex < 0) 
                    {
                        EndAddNew(true);
                    }
                } 

                RefreshOrDefer(); 
                return; // the Refresh raises collection change event, so there's nothing left to do 
            }
 
            if (args.Action == NotifyCollectionChangedAction.Add && _newItemIndex == -2)
            {
                // The Add event came from AddNew.
                BeginAddNew(args.NewItems[0], args.NewStartingIndex); 
                return;
            } 
 
            // If the Action is one that can be expected to have a valid NewItems[0] and NewStartingIndex then
            // adjust the index for filtering and sorting. 
            if (args.Action != NotifyCollectionChangedAction.Remove)
            {
                adjustedNewIndex = AdjustBefore(NotifyCollectionChangedAction.Add, args.NewItems[0], args.NewStartingIndex);
            } 

            // If the Action is one that can be expected to have a valid OldItems[0] and OldStartingIndex then 
            // adjust the index for filtering and sorting. 
            if (args.Action != NotifyCollectionChangedAction.Add)
            { 
                adjustedOldIndex = AdjustBefore(NotifyCollectionChangedAction.Remove, args.OldItems[0], args.OldStartingIndex);

                // the new index needs further adjustment if the action removes (or moves)
                // something before it 
                if (UsesLocalArray && adjustedOldIndex >= 0 && adjustedOldIndex < adjustedNewIndex)
                { 
                    -- adjustedNewIndex; 
                }
            } 

            // handle interaction with AddNew and EditItem
            switch (args.Action)
            { 
                case NotifyCollectionChangedAction.Add:
                    if (args.NewStartingIndex <= _newItemIndex) 
                    { 
                        ++ _newItemIndex;
                    } 
                    break;

                case NotifyCollectionChangedAction.Remove:
                    if (args.OldStartingIndex < _newItemIndex) 
                    {
                        -- _newItemIndex; 
                    } 

                    // implicitly cancel AddNew and/or EditItem transactions if the relevant item is removed 
                    object item = args.OldItems[0];

                    if (item == CurrentEditItem)
                    { 
                        ImplicitlyCancelEdit();
                    } 
                    else if (item == CurrentAddItem) 
                    {
                        EndAddNew(true); 
                    }
                    break;

                case NotifyCollectionChangedAction.Move: 
                    if (args.OldStartingIndex < _newItemIndex && _newItemIndex < args.NewStartingIndex)
                    { 
                        -- _newItemIndex; 
                    }
                    else if (args.NewStartingIndex <= _newItemIndex && _newItemIndex < args.OldStartingIndex) 
                    {
                        ++ _newItemIndex;
                    }
                    break; 
            }
 
            ProcessCollectionChangedWithAdjustedIndex(args, adjustedOldIndex, adjustedNewIndex); 
        }
 
        void ProcessCollectionChangedWithAdjustedIndex(NotifyCollectionChangedEventArgs args, int adjustedOldIndex, int adjustedNewIndex)
        {
            // Finding out the effective Action after filtering and sorting.
            // 
            NotifyCollectionChangedAction effectiveAction = args.Action;
            if (adjustedOldIndex == adjustedNewIndex && adjustedOldIndex >= 0) 
            { 
                effectiveAction = NotifyCollectionChangedAction.Replace;
            } 
            else if (adjustedOldIndex == -1) // old index is unknown
            {
                // we weren't told the old index, but it may have been in the view.
                if (adjustedNewIndex < 0) 
                {
                    // The new item will not be in the filtered view, 
                    // so an Add is a no-op and anything else is a Remove. 
                    if (args.Action == NotifyCollectionChangedAction.Add)
                        return; 
                    effectiveAction = NotifyCollectionChangedAction.Remove;
                }
            }
            else if (adjustedOldIndex < -1) // old item is known to be NOT in filtered view 
            {
                if (adjustedNewIndex < 0) 
                { 
                    // since the old item wasn't in the filtered view, and the new
                    // item would not be in the filtered view, this is a no-op. 
                    return;
                }
                else
                { 
                    effectiveAction = NotifyCollectionChangedAction.Add;
                } 
            } 
            else // old item was in view
            { 
                if (adjustedNewIndex < 0)
                {
                    effectiveAction = NotifyCollectionChangedAction.Remove;
                } 
                else
                { 
                    effectiveAction = NotifyCollectionChangedAction.Move; 
                }
            } 

            int delta = IsGrouping ? 0 :
                        (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ?
                        (IsAddingNew ? 2 : 1) : 0; 

            int originalCurrentPosition = CurrentPosition; 
            int oldCurrentPosition = CurrentPosition; 
            object oldCurrentItem = CurrentItem;
            bool oldIsCurrentAfterLast = IsCurrentAfterLast; 
            bool oldIsCurrentBeforeFirst = IsCurrentBeforeFirst;

            // in the case of a replace that has a new adjustedPosition
            // (likely caused by sorting), the only way to effectively communicate 
            // this change is through raising Remove followed by Insert.
            NotifyCollectionChangedEventArgs args2 = null; 
 
            switch (effectiveAction)
            { 
                case NotifyCollectionChangedAction.Add:
                    // insert into private view
                    // (unless it's a special item - placeholder or new item)
                    if (UsesLocalArray && NewItemPlaceholder != args.NewItems[0] && 
                            (!IsAddingNew || !Object.Equals(_newItem, args.NewItems[0])))
                    { 
                        InternalList.Insert(adjustedNewIndex - delta, args.NewItems[0]); 
                    }
 
                    if (!IsGrouping)
                    {
                        AdjustCurrencyForAdd(adjustedNewIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.NewItems[0], adjustedNewIndex); 
                    }
                    else 
                    { 
                        AddItemToGroups(args.NewItems[0]);
                    } 

                    break;

                case NotifyCollectionChangedAction.Remove: 
                    // remove from private view, unless it's not there to start with
                    // (e.g. when CommitNew is applied to an item that fails the filter) 
                    if (UsesLocalArray) 
                    {
                        int localOldIndex = adjustedOldIndex - delta; 

                        if (localOldIndex < InternalList.Count &&
                            Object.Equals(InternalList[localOldIndex], args.OldItems[0]))
                        { 
                            InternalList.RemoveAt(localOldIndex);
                        } 
                    } 

                    if (!IsGrouping) 
                    {
                        AdjustCurrencyForRemove(adjustedOldIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.OldItems[0], adjustedOldIndex);
                    } 
                    else
                    { 
                        RemoveItemFromGroups(args.OldItems[0]); 
                    }
 
                    break;
                case NotifyCollectionChangedAction.Replace:
                    // replace item in private view
                    if (UsesLocalArray) 
                    {
                        InternalList[adjustedOldIndex - delta] = args.NewItems[0]; 
                    } 

                    if (!IsGrouping) 
                    {
                        AdjustCurrencyForReplace(adjustedOldIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.NewItems[0], args.OldItems[0], adjustedOldIndex);
                    } 
                    else
                    { 
                        RemoveItemFromGroups(args.OldItems[0]); 
                        AddItemToGroups(args.NewItems[0]);
                    } 

                    break;

                case NotifyCollectionChangedAction.Move: 
                    // remove from private view
 
                    bool simpleMove = args.OldItems[0] == args.NewItems[0]; 

                    if (UsesLocalArray) 
                    {
                        int localOldIndex = adjustedOldIndex - delta;
                        int localNewIndex = adjustedNewIndex - delta;
 
                        // remove the item from its old position, unless it's not there
                        // (which happens when the item is the object of CommitNew) 
                        if (localOldIndex < InternalList.Count && 
                            Object.Equals(InternalList[localOldIndex], args.OldItems[0]))
                        { 
                            InternalList.RemoveAt(localOldIndex);
                        }

                        // put the item into its new position, unless it's special 
                        if (NewItemPlaceholder != args.NewItems[0])
                        { 
                            InternalList.Insert(localNewIndex, args.NewItems[0]); 
                        }
                    } 

                    if (!IsGrouping)
                    {
                        AdjustCurrencyForMove(adjustedOldIndex, adjustedNewIndex); 

                        if (simpleMove) 
                        { 
                            // simple move
                            args = new NotifyCollectionChangedEventArgs(effectiveAction, args.OldItems[0], adjustedNewIndex, adjustedOldIndex); 
                        }
                        else
                        {
                            // move/replace 
                            args2 = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, args.NewItems, adjustedNewIndex);
                            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, args.OldItems, adjustedOldIndex); 
                        } 
                    }
                    else 
                    {
                        if (!simpleMove)
                        {
                            RemoveItemFromGroups(args.OldItems[0]); 
                            AddItemToGroups(args.NewItems[0]);
                        } 
                    } 
                    break;
                default: 
                    Invariant.Assert(false, SR.Get(SRID.UnexpectedCollectionChangeAction, effectiveAction));
                    break;
            }
 
            // remember whether scalar properties of the view have changed.
            // They may change again during the collection change event, so we 
            // need to do the test before raising that event. 
            bool afterLastHasChanged = (IsCurrentAfterLast != oldIsCurrentAfterLast);
            bool beforeFirstHasChanged = (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst); 
            bool currentPositionHasChanged = (CurrentPosition != oldCurrentPosition);
            bool currentItemHasChanged = (CurrentItem != oldCurrentItem);

            // take a new snapshot of the scalar properties, so that we can detect 
            // changes made during the collection change event
            oldIsCurrentAfterLast = IsCurrentAfterLast; 
            oldIsCurrentBeforeFirst = IsCurrentBeforeFirst; 
            oldCurrentPosition = CurrentPosition;
            oldCurrentItem = CurrentItem; 

            // base class will raise an event to our listeners
            if (!IsGrouping)
            { 
                // we've already returned if (args.Action == NotifyCollectionChangedAction.Reset) above
                OnCollectionChanged(args); 
                if (args2 != null) 
                    OnCollectionChanged(args2);
 
                // Any scalar properties that changed don't need a further notification,
                // but do need a new snapshot
                if (IsCurrentAfterLast != oldIsCurrentAfterLast)
                { 
                    afterLastHasChanged = false;
                    oldIsCurrentAfterLast = IsCurrentAfterLast; 
                } 
                if (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst)
                { 
                    beforeFirstHasChanged = false;
                    oldIsCurrentBeforeFirst = IsCurrentBeforeFirst;
                }
                if (CurrentPosition != oldCurrentPosition) 
                {
                    currentPositionHasChanged = false; 
                    oldCurrentPosition = CurrentPosition; 
                }
                if (CurrentItem != oldCurrentItem) 
                {
                    currentItemHasChanged = false;
                    oldCurrentItem = CurrentItem;
                } 

            } 
 
            // currency has to change after firing the deletion event,
            // so event handlers have the right picture 
            if (_currentElementWasRemoved)
            {
                MoveCurrencyOffDeletedElement(originalCurrentPosition);
 
                // changes to the scalar properties need notification
                afterLastHasChanged = afterLastHasChanged || (IsCurrentAfterLast != oldIsCurrentAfterLast); 
                beforeFirstHasChanged = beforeFirstHasChanged || (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst); 
                currentPositionHasChanged = currentPositionHasChanged || (CurrentPosition != oldCurrentPosition);
                currentItemHasChanged = currentItemHasChanged || (CurrentItem != oldCurrentItem); 
            }

            // notify that the properties have changed.  We may end up doing
            // double notification for properties that change during the collection 
            // change event, but that's not harmful.  Detecting the double change
            // is more trouble than it's worth. 
            if (afterLastHasChanged) 
                OnPropertyChanged(IsCurrentAfterLastPropertyName);
 
            if (beforeFirstHasChanged)
                OnPropertyChanged(IsCurrentBeforeFirstPropertyName);

            if (currentPositionHasChanged) 
                OnPropertyChanged(CurrentPositionPropertyName);
 
            if (currentItemHasChanged) 
                OnPropertyChanged(CurrentItemPropertyName);
 
        }

        /// 
        /// Return index of item in the internal list. 
        /// 
        protected int InternalIndexOf(object item) 
        { 
            if (IsGrouping)
            { 
                return _group.LeafIndexOf(item);
            }

            if (item == NewItemPlaceholder) 
            {
                switch (NewItemPlaceholderPosition) 
                { 
                    case NewItemPlaceholderPosition.None:
                        return -1; 

                    case NewItemPlaceholderPosition.AtBeginning:
                        return 0;
 
                    case NewItemPlaceholderPosition.AtEnd:
                        return InternalCount - 1; 
                } 
            }
            else if (IsAddingNew && Object.Equals(item, _newItem)) 
            {
                switch (NewItemPlaceholderPosition)
                {
                    case NewItemPlaceholderPosition.None: 
                        if (UsesLocalArray)
                        { 
                            return InternalCount - 1; 
                        }
                        break; 

                    case NewItemPlaceholderPosition.AtBeginning:
                        return 1;
 
                    case NewItemPlaceholderPosition.AtEnd:
                        return InternalCount - 2; 
                } 
            }
 
            int index = InternalList.IndexOf(item);

            if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning && index >= 0)
            { 
                index += IsAddingNew ? 2 : 1;
            } 
 
            return index;
        } 

        /// 
        /// Return item at the given index in the internal list.
        ///  
        protected object InternalItemAt(int index)
        { 
            if (IsGrouping) 
            {
                return _group.LeafAt(index); 
            }

            switch (NewItemPlaceholderPosition)
            { 
                case NewItemPlaceholderPosition.None:
                    if (IsAddingNew && UsesLocalArray) 
                    { 
                        if (index == InternalCount - 1)
                            return _newItem; 
                    }
                    break;

                case NewItemPlaceholderPosition.AtBeginning: 
                    if (index == 0)
                        return NewItemPlaceholder; 
                    --index; 

                    if (IsAddingNew) 
                    {
                        if (index == 0)
                            return _newItem;
 
                        if (UsesLocalArray || index <= _newItemIndex)
                        { 
                            --index; 
                        }
                    } 
                    break;

                case NewItemPlaceholderPosition.AtEnd:
                    if (index == InternalCount - 1) 
                        return NewItemPlaceholder;
                    if (IsAddingNew) 
                    { 
                        if (index == InternalCount-2)
                            return _newItem; 
                        if (!UsesLocalArray && index >= _newItemIndex)
                            ++index;
                    }
                    break; 
            }
 
            return InternalList[index]; 
        }
 
        /// 
        /// Return true if internal list contains the item.
        /// 
        protected bool InternalContains(object item) 
        {
            if (item == NewItemPlaceholder) 
                return (NewItemPlaceholderPosition != NewItemPlaceholderPosition.None); 

            return (!IsGrouping) ? InternalList.Contains(item) : (_group.LeafIndexOf(item) >= 0); 
        }

        /// 
        /// Return an enumerator for the internal list. 
        /// 
        protected IEnumerator InternalGetEnumerator() 
        { 
            if (!IsGrouping)
            { 
                return new PlaceholderAwareEnumerator(this, InternalList.GetEnumerator(), NewItemPlaceholderPosition, _newItem);
            }
            else
            { 
                return _group.GetLeafEnumerator();
            } 
        } 

        ///  
        /// True if a private copy of the data is needed for sorting and filtering
        /// 
        protected bool UsesLocalArray
        { 
            get { return ActiveComparer != null || ActiveFilter != null; }
        } 
 
        /// 
        /// Protected accessor to private _internalList field. 
        /// 
        protected IList InternalList
        {
            get { return _internalList; } 
        }
 
        ///  
        /// Protected accessor to private _activeComparer field.
        ///  
        protected IComparer ActiveComparer
        {
            get { return _activeComparer; }
            set 
            {
                _activeComparer = value; 
                _group.ActiveComparer = value; 
            }
        } 

        /// 
        /// Protected accessor to private _activeFilter field.
        ///  
        protected Predicate ActiveFilter
        { 
            get { return _activeFilter; } 
            set { _activeFilter = value; }
        } 

        /// 
        /// Protected accessor to _isGrouping field.
        ///  
        protected bool IsGrouping
        { 
            get { return _isGrouping; } 
        }
 
        /// 
        /// Protected accessor to private count.
        /// 
        protected int InternalCount 
        {
            get 
            { 
                if (IsGrouping)
                    return _group.ItemCount; 

                int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.None) ? 0 : 1;
                if (UsesLocalArray && IsAddingNew)
                    ++delta; 

                return delta + InternalList.Count; 
            } 
        }
 
        #endregion Protected Methods

        //------------------------------------------------------
        // 
        //  Internal Methods
        // 
        //----------------------------------------------------- 

        #region Internal Methods 

        /// 
        ///     Contains a snapshot of the ICollectionView.SourceCollection
        ///     at the time that a change notification is posted. 
        ///     This is done in OnBeginChangeLogging.
        ///  
        internal ArrayList ShadowCollection 
        {
            get { return _shadowCollection; } 
            set { _shadowCollection = value; }
        }

        // 

 
        internal void AdjustShadowCopy(NotifyCollectionChangedEventArgs e) 
        {
            int tempIndex; 

            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add: 
                    if (e.NewStartingIndex > _unknownIndex)
                    { 
                        ShadowCollection.Insert(e.NewStartingIndex, e.NewItems[0]); 
                    }
                    else 
                    {
                        ShadowCollection.Add(e.NewItems[0]);
                    }
                    break; 
                case NotifyCollectionChangedAction.Remove:
                    if (e.OldStartingIndex > _unknownIndex) 
                    { 
                        ShadowCollection.RemoveAt(e.OldStartingIndex);
                    } 
                    else
                    {
                        ShadowCollection.Remove(e.OldItems[0]);
                    } 
                    break;
                case NotifyCollectionChangedAction.Replace: 
                    if (e.OldStartingIndex > _unknownIndex) 
                    {
                        ShadowCollection[e.OldStartingIndex] = e.NewItems[0]; 
                    }
                    else
                    {
                        // allow the ShadowCollection to throw the IndexOutOfRangeException 
                        // if the item is not found.
                        tempIndex = ShadowCollection.IndexOf(e.OldItems[0]); 
                        ShadowCollection[e.OldStartingIndex] = e.NewItems[0]; 
                    }
                    break; 
                case NotifyCollectionChangedAction.Move:
                    if (e.OldStartingIndex > _unknownIndex)
                    {
                        ShadowCollection.RemoveAt(e.OldStartingIndex); 
                    }
                    else 
                    { 
                        ShadowCollection.Remove(e.OldItems[0]);
                        ShadowCollection.Insert(e.NewStartingIndex, e.NewItems[0]); 
                    }
                    break;

                default: 
                    throw new NotSupportedException(SR.Get(SRID.UnexpectedCollectionChangeAction, e.Action));
 
            } 
        }
 
        // returns true if this ListCollectionView has sort descriptions,
        // without tripping off lazy creation of .SortDescriptions collection
        internal bool HasSortDescriptions
        { 
            get { return ((_sort != null) && (_sort.Count > 0)); }
        } 
 
        #endregion Internal Methods
 

        #region Private Properties

        //------------------------------------------------------ 
        //
        //  Private Properties 
        // 
        //------------------------------------------------------
 
        // true if CurrentPosition points to item within view
        private bool IsCurrentInView
        {
            get { return (0 <= CurrentPosition && CurrentPosition < InternalCount); } 
        }
 
        // can the group name(s) for an item change after we've grouped the item? 
        private bool CanGroupNamesChange
        { 
            // There's no way we can deduce this - the app has to tell us.
            // If this is true, removing a grouped item is quite difficult.
            // We cannot rely on its group names to tell us which group we inserted
            // it into (they may have been different at insertion time), so we 
            // have to do a linear search.
            get { return true; } 
        } 

        private IList SourceList 
        {
            get { return SourceCollection as IList; }
        }
 
        #endregion Private Properties
 
 
        //-----------------------------------------------------
        // 
        //  Private Methods
        //
        //------------------------------------------------------
 
        #region Private Methods
 
        private void ValidateCollectionChangedEventArgs(NotifyCollectionChangedEventArgs e) 
        {
 
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    if (e.NewItems.Count != 1) 
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported));
                    break; 
 
                case NotifyCollectionChangedAction.Remove:
                    if (e.OldItems.Count != 1) 
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported));
                    break;

                case NotifyCollectionChangedAction.Replace: 
                    if (e.NewItems.Count != 1 || e.OldItems.Count != 1)
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported)); 
                    break; 

                case NotifyCollectionChangedAction.Move: 
                    if (e.NewItems.Count != 1)
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported));
                    if (e.NewStartingIndex < 0)
                        throw new InvalidOperationException(SR.Get(SRID.CannotMoveToUnknownPosition)); 
                    break;
 
                case NotifyCollectionChangedAction.Reset: 
                    break;
 
                default:
                    throw new NotSupportedException(SR.Get(SRID.UnexpectedCollectionChangeAction, e.Action));
            }
        } 

 
        ///  
        /// Create, filter and sort the local index array.
        /// called from Refresh(), override in derived classes as needed. 
        /// 
        /// new ILIst to associate this view with
        /// new local array to use for this view
        private IList PrepareLocalArray(IList list) 
        {
            if (list == null) 
                throw new ArgumentNullException("list"); 

            // filter the collection's array into the local array 
            ArrayList al;

            if (ActiveFilter == null)
            { 
                al = new ArrayList(list);
 
                if (IsAddingNew) 
                {
                    al.RemoveAt(_newItemIndex); 
                }
            }
            else
            { 
                al = new ArrayList(list.Count);       //
                for (int k = 0; k < list.Count; ++k) 
                { 
                    if (ActiveFilter(list[k]) && !(IsAddingNew && k == _newItemIndex))
                        al.Add(list[k]); 
                }
            }

            // sort the local array 
            if (ActiveComparer != null)
            { 
                al.Sort(ActiveComparer); 
            }
 
            return al;
        }

        private void MoveCurrencyOffDeletedElement(int oldCurrentPosition) 
        {
            int lastPosition = InternalCount - 1;   // OK if last is -1 
            // if position falls beyond last position, move back to last position 
            int newPosition = (oldCurrentPosition < lastPosition) ? oldCurrentPosition : lastPosition;
 
            // reset this to false before raising events to avoid problems in re-entrancy
            _currentElementWasRemoved = false;

            OnCurrentChanging(); 

            if (newPosition < 0) 
                SetCurrent(null, newPosition); 
            else
                SetCurrent(InternalItemAt(newPosition), newPosition); 

            OnCurrentChanged();
        }
 
        // Convert the collection's index to an index into the view.
        // Return -1 if the index is unknown or moot (Reset events). 
        // Return -2 if the event doesn't apply to this view. 
        private int AdjustBefore (NotifyCollectionChangedAction action, object item, int index)
        { 
            // index is not relevant to Reset events
            if (action == NotifyCollectionChangedAction.Reset)
                return -1;
 
            if (item == NewItemPlaceholder)
            { 
                return (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) 
                        ? 0 : InternalCount - 1;
            } 
            else if (IsAddingNew && NewItemPlaceholderPosition != NewItemPlaceholderPosition.None &&
                        Object.Equals(item, _newItem))
            {
                // we should only get here when removing the AddNew item - i.e. from CancelNew - 
                // and only when the placeholder is active.
                // In that case the item's index in the view is 1 when the placeholder 
                // is AtBeginning, and just before the placeholder when it's AtEnd. 
                // The numerical value for the latter case dependds on whether there's
                // a sort/filter or not, i.e. whether we're using a local array.  That's 
                // because the item has already been removed from the collection, but
                // not from the local array.  (DDB 201860)
                return (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning)
                        ? 1 : UsesLocalArray ? InternalCount - 2 : index; 
            }
 
            int delta = IsGrouping ? 0 : 
                        (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning)
                        ? (IsAddingNew ? 2 : 1) : 0; 
            IList ilFull = (UpdatedOutsideDispatcher ? ShadowCollection : SourceCollection) as IList;

            // validate input
            if (index < -1 || index > ilFull.Count) 
                throw new InvalidOperationException(SR.Get(SRID.CollectionChangeIndexOutOfRange, index, ilFull.Count));
 
            if (action == NotifyCollectionChangedAction.Add) 
            {
                if (index >= 0) 
                {
                    if (!Object.Equals(item, ilFull[index]))
                        throw new InvalidOperationException(SR.Get(SRID.AddedItemNotAtIndex, index));
                } 
                else
                { 
                    // event didn't specify index - determine it the hard way 
                    index = ilFull.IndexOf(item);
                    if (index < 0) 
                        throw new InvalidOperationException(SR.Get(SRID.AddedItemNotInCollection));
                }
            }
 
            // if there's no sort or filter, use the index into the full array
            if (!UsesLocalArray) 
            { 
                if (IsAddingNew)
                { 
                    if (index > _newItemIndex)
                    {
                        --index;        // the new item has been artificially moved elsewhere
                    } 
                }
 
                return index + delta; 
            }
 
            if (action == NotifyCollectionChangedAction.Add)
            {
                // if the item isn't in the filter, return -2
                if (!this.PassesFilter(item)) 
                    return -2;
 
                // search the local array.  If there's no sort order, use the index 
                // in the full array as the sort key.
                IComparer comparer = (ActiveComparer != null) ? ActiveComparer 
                                        : new ListOrdinalComparer(ilFull, item, index);
                ArrayList al = InternalList as ArrayList;
                if (al != null)
                { 
                    index = al.BinarySearch(item, comparer);
                    if (index < 0) 
                        index = ~index; 
                }
                else 
                {
                    index = -1;
                }
            } 
            else if (action == NotifyCollectionChangedAction.Remove)
            { 
                if (!IsAddingNew || item != _newItem) 
                {
                    // a deleted item should already be in the local array 
                    index = InternalList.IndexOf(item);

                    // but may not be, if it was already filtered out (can't use
                    // PassesFilter here, because the item could have changed 
                    // while it was out of our sight)
                    if (index < 0) 
                        return -2; 
                }
                else 
                {
                    // the new item is in a special position
                    switch (NewItemPlaceholderPosition)
                    { 
                        case NewItemPlaceholderPosition.None:
                            return InternalCount - 1; 
                        case NewItemPlaceholderPosition.AtBeginning: 
                            return 1;
                        case NewItemPlaceholderPosition.AtEnd: 
                            return InternalCount - 2;
                    }
                }
            } 
            else
            { 
                index = -1; 
            }
 
            return (index < 0 ) ? index : index + delta;
        }

        // fix up CurrentPosition and CurrentItem after a collection change 
        private void AdjustCurrencyForAdd(int index)
        { 
            if (InternalCount == 1) 
            {
                // added first item; set current at BeforeFirst 
                SetCurrent(null, -1);
            }
            else if (index <= CurrentPosition)  // adjust current index if insertion is earlier
            { 
                int newPosition = CurrentPosition + 1;
                if (newPosition < InternalCount) 
                { 
                    // CurrentItem might be out of [....] if underlying list is not INCC
                    // or if this Add is the result of a Replace (Rem + Add) 
                    SetCurrent(GetItemAt(newPosition), newPosition);
                }
                else
                { 
                    SetCurrent(null, InternalCount);
                } 
            } 
        }
 
        // fix up CurrentPosition and CurrentItem after a collection change
        private void AdjustCurrencyForRemove(int index)
        {
            // adjust current index if deletion is earlier 
            if (index < CurrentPosition)
            { 
                SetCurrent(CurrentItem, CurrentPosition - 1); 
            }
            // remember to move currency off the deleted element 
            else if (index == CurrentPosition)
            {
                _currentElementWasRemoved = true;
            } 
        }
 
        // fix up CurrentPosition and CurrentItem after a collection change 
        private void AdjustCurrencyForMove(int oldIndex, int newIndex)
        { 
            if (oldIndex == CurrentPosition)
            {
                // moving the current item - currency moves with the item (bug 1942184)
                SetCurrent(GetItemAt(newIndex), newIndex); 
            }
            else if (oldIndex < CurrentPosition && CurrentPosition <= newIndex) 
            { 
                // moving an item from before current position to after -
                // current item shifts back one position 
                SetCurrent(CurrentItem, CurrentPosition - 1);
            }
            else if (newIndex <= CurrentPosition && CurrentPosition < oldIndex)
            { 
                // moving an item from after current position to before -
                // current item shifts ahead one position 
                SetCurrent(CurrentItem, CurrentPosition + 1); 
            }
            // else no change necessary 
        }

        // fix up CurrentPosition and CurrentItem after a collection change
        private void AdjustCurrencyForReplace(int index) 
        {
            // remember to move currency off the deleted element 
            if (index == CurrentPosition) 
            {
                _currentElementWasRemoved = true; 
            }
        }

        // build the sort and filter information from the relevant properties 
        private void PrepareSortAndFilter(IList list)
        { 
            // sort:  prepare the comparer 
            if (_customSort != null)
            { 
                ActiveComparer = _customSort;
            }
            else if (_sort != null && _sort.Count > 0)
            { 
                // test for Xml in a way that doesn't load System.Xml unless we really need it
                string name = SourceCollection.GetType().Name; 
                if (name == "XmlDataCollection") 
                {
                    PrepareXmlComparer(); 
                }
                else
                {
                    ActiveComparer = new SortFieldComparer(_sort, Culture); 
                }
            } 
            else 
            {
                ActiveComparer = null; 
            }

            // filter:  prepare the Predicate filter
            ActiveFilter = Filter; 
        }
 
        // set up the Xml comparer - code is isolated here to avoid loading System.Xml 
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private void PrepareXmlComparer() 
        {
            XmlDataCollection xdc = SourceCollection as XmlDataCollection;
            Invariant.Assert(_sort != null);
            ActiveComparer = new XmlNodeComparer(_sort, xdc.XmlNamespaceManager, Culture); 
        }
 
        // set new SortDescription collection; rehook collection change notification handler 
        private void SetSortDescriptions(SortDescriptionCollection descriptions)
        { 
            if (_sort != null)
            {
                ((INotifyCollectionChanged)_sort).CollectionChanged -= new NotifyCollectionChangedEventHandler(SortDescriptionsChanged);
            } 

            _sort = descriptions; 
 
            if (_sort != null)
            { 
                Invariant.Assert(_sort.Count == 0, "must be empty SortDescription collection");
                ((INotifyCollectionChanged)_sort).CollectionChanged += new NotifyCollectionChangedEventHandler(SortDescriptionsChanged);
            }
        } 

        // SortDescription was added/removed, refresh CollectionView 
        private void SortDescriptionsChanged(object sender, NotifyCollectionChangedEventArgs e) 
        {
            if (IsAddingNew || IsEditingItem) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Sorting"));

            // adding to SortDescriptions overrides custom sort
            if (_sort.Count > 0) 
            {
                _customSort = null; 
            } 

            RefreshOrDefer(); 
        }

        #region Grouping
 
        // divide the data items into groups
        void PrepareGroups() 
        { 
            // discard old groups
            _group.Clear(); 

            // initialize the synthetic top level group
            _group.Initialize();
 
            // if there's no grouping, there's nothing to do
            _isGrouping = (_group.GroupBy != null); 
            if (!_isGrouping) 
                return;
 
            // loop through the sorted/filtered list of items, dividing them
            // into groups (with special cases for placeholder and new item)
            if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning)
            { 
                _group.InsertSpecialItem(0, NewItemPlaceholder, true /*loading*/);
                if (IsAddingNew) 
                { 
                    _group.InsertSpecialItem(1, _newItem, true /*loading*/);
                } 
            }

            for (int k=0, n=InternalList.Count;  k 
        /// Helper to raise a PropertyChanged event  />).
        ///  
        private void OnPropertyChanged(string propertyName)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        } 

        //----------------------------------------------------- 
        private class ListOrdinalComparer : IComparer 
        {
            IList _ilFull; 
            object _item;
            int _index;

            internal ListOrdinalComparer(IList ilFull, object item, int index) 
            {
                _ilFull = ilFull; 
                _item = item; 
                _index = index;
            } 

            // IComparer
            public int Compare(object o1, object o2)
            { 
                int i1 = Object.Equals(o1, _item) ? _index : _ilFull.IndexOf(o1);
                int i2 = Object.Equals(o2, _item) ? _index : _ilFull.IndexOf(o2); 
                return (i1 - i2); 
            }
        } 

        #endregion Private Methods

 

        //----------------------------------------------------- 
        // 
        //  Private Fields
        // 
        //-----------------------------------------------------

        #region Private Fields
 
        private IList               _internalList;
        private CollectionViewGroupRoot _group; 
        private bool                _isGrouping; 
        private IComparer           _activeComparer;
        private Predicate   _activeFilter; 
        private SortDescriptionCollection  _sort;
        private IComparer           _customSort;
        private ArrayList           _shadowCollection;
        private bool                _applyChangeToShadow = false; 
        private bool                _currentElementWasRemoved;  // true if we need to MoveCurrencyOffDeletedElement
        private object              _newItem; 
        private object              _editItem; 
        private int                 _newItemIndex;  // position _newItem in the source collection
        private NewItemPlaceholderPosition _newItemPlaceholderPosition; 
        private bool                _isItemConstructorValid;
        private ConstructorInfo     _itemConstructor;

        private const int           _unknownIndex = -1; 

        #endregion Private Fields 
    } 

    ///  
    /// A delegate to select the group description as a function of the
    /// parent group and its level.
    /// 
    public delegate GroupDescription GroupDescriptionSelectorCallback(CollectionViewGroup group, int level); 

} 
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) 2003 by Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: ICollectionView for collections implementing IList 
//
// See spec at http://avalon/connecteddata/Specs/CollectionView.mht 
//
// History:
//  06/02/2003 : [....]   - Ported from DotNet tree
//  03/27/2004 : kenlai     - Implement IList 
//
//--------------------------------------------------------------------------- 
 
using System;
using System.Collections; 
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel; 
using System.Diagnostics;
using System.Reflection;        // ConstructorInfo 
 
using System.Windows;
 
using MS.Internal;
using MS.Internal.Data;
using MS.Utility;
 
namespace System.Windows.Data
{ 
    /// 
    ///  based on and associated to .
    /// 
    public class ListCollectionView : CollectionView, IComparer, IEditableCollectionView, IItemProperties
    {
        //-----------------------------------------------------
        // 
        //  Constructors
        // 
        //----------------------------------------------------- 

        #region Constructors 

        /// 
        /// Constructor
        ///  
        /// Underlying IList
        public ListCollectionView(IList list) 
            : base(list) 
        {
            _internalList = list; 

            if (InternalList.Count == 0)    // don't call virtual IsEmpty in ctor
            {
                SetCurrent(null, -1, 0); 
            }
            else 
            { 
                SetCurrent(InternalList[0], 0, 1);
            } 

            _group = new CollectionViewGroupRoot(this);
            _group.GroupDescriptionChanged += new EventHandler(OnGroupDescriptionChanged);
            ((INotifyCollectionChanged)_group).CollectionChanged += new NotifyCollectionChangedEventHandler(OnGroupChanged); 
            ((INotifyCollectionChanged)_group.GroupDescriptions).CollectionChanged += new NotifyCollectionChangedEventHandler(OnGroupByChanged);
        } 
 
        #endregion Constructors
 
        //------------------------------------------------------
        //
        //  Public Methods
        // 
        //-----------------------------------------------------
 
        #region Public Methods 

        //------------------------------------------------------ 
        #region ICollectionView

        /// 
        /// Re-create the view over the associated IList 
        /// 
        ///  
        /// Any sorting and filtering will take effect during Refresh. 
        /// 
        protected override void RefreshOverride() 
        {
            lock(SyncRoot)
            {
                ClearChangeLog(); 
                if (UpdatedOutsideDispatcher)
                { 
                    ShadowCollection = new ArrayList((ICollection)SourceCollection); 
                }
            } 

            object oldCurrentItem = CurrentItem;
            int oldCurrentPosition = IsEmpty ? -1 : CurrentPosition;
            bool oldIsCurrentAfterLast = IsCurrentAfterLast; 
            bool oldIsCurrentBeforeFirst = IsCurrentBeforeFirst;
 
            // force currency off the collection (gives user a chance to save dirty information) 
            OnCurrentChanging();
 
            IList list = UpdatedOutsideDispatcher ? ShadowCollection : (SourceCollection as IList);
            PrepareSortAndFilter(list);

            // if there's no sort/filter, just use the collection's array 
            if (!UsesLocalArray)
            { 
                _internalList = list; 
            }
            else 
            {
                _internalList = PrepareLocalArray(list);
            }
 
            PrepareGroups();
 
            if (oldIsCurrentBeforeFirst || IsEmpty) 
            {
                SetCurrent(null, -1); 
            }
            else if (oldIsCurrentAfterLast)
            {
                SetCurrent(null, InternalCount); 
            }
            else // set currency back to old current item 
            { 
                // oldCurrentItem may be null
 
                // if there are duplicates, use the position of the first matching item
                int newPosition = InternalIndexOf(oldCurrentItem);

                if (newPosition < 0) 
                {
                    // oldCurrentItem not found: move to first item 
                    object newItem; 
                    newPosition = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ?
                                1 : 0; 
                    if (newPosition < InternalCount && (newItem = InternalItemAt(newPosition)) != NewItemPlaceholder)
                    {
                        SetCurrent(newItem, newPosition);
                    } 
                    else
                    { 
                        SetCurrent(null, -1); 
                    }
                } 
                else
                {
                    SetCurrent(oldCurrentItem, newPosition);
                } 
            }
 
            // tell listeners everything has changed 
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
 
            OnCurrentChanged();

            if (IsCurrentAfterLast != oldIsCurrentAfterLast)
                OnPropertyChanged(IsCurrentAfterLastPropertyName); 

            if (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst) 
                OnPropertyChanged(IsCurrentBeforeFirstPropertyName); 

            if (oldCurrentPosition != CurrentPosition) 
                OnPropertyChanged(CurrentPositionPropertyName);

            if (oldCurrentItem != CurrentItem)
                OnPropertyChanged(CurrentItemPropertyName); 

        } 
 
        /// 
        /// Return true if the item belongs to this view.  No assumptions are 
        /// made about the item. This method will behave similarly to IList.Contains()
        /// and will do an exhaustive search through all items in this view.
        /// If the caller knows that the item belongs to the
        /// underlying collection, it is more efficient to call PassesFilter. 
        /// 
        public override bool Contains(object item) 
        { 
            VerifyRefreshNotDeferred();
 
            return InternalContains(item);
        }

        ///  
        /// Move  to the item at the given index.
        ///  
        /// Move CurrentItem to this index 
        /// true if  points to an item within the view.
        public override bool MoveCurrentToPosition(int position) 
        {
            VerifyRefreshNotDeferred();

            if (position < -1 || position > InternalCount) 
                throw new ArgumentOutOfRangeException("position");
 
 
            if (position != CurrentPosition || !IsCurrentInSync)
            { 
                object proposedCurrentItem = (0 <= position && position < InternalCount) ? InternalItemAt(position) : null;

                // ignore moves to the placeholder
                if (proposedCurrentItem != NewItemPlaceholder) 
                {
                    if (OKToChangeCurrent()) 
                    { 
                        bool oldIsCurrentAfterLast = IsCurrentAfterLast;
                        bool oldIsCurrentBeforeFirst = IsCurrentBeforeFirst; 

                        SetCurrent(proposedCurrentItem, position);

                        OnCurrentChanged(); 

                        // notify that the properties have changed. 
                        if (IsCurrentAfterLast != oldIsCurrentAfterLast) 
                            OnPropertyChanged(IsCurrentAfterLastPropertyName);
 
                        if (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst)
                            OnPropertyChanged(IsCurrentBeforeFirstPropertyName);

                        OnPropertyChanged(CurrentPositionPropertyName); 
                        OnPropertyChanged(CurrentItemPropertyName);
                    } 
                } 
            }
 
            return IsCurrentInView;
        }

        ///  
        /// Returns true if this view really supports grouping.
        /// When this returns false, the rest of the interface is ignored. 
        ///  
        public override bool CanGroup
        { 
            get { return true; }
        }

        ///  
        /// The description of grouping, indexed by level.
        ///  
        public override ObservableCollection GroupDescriptions 
        {
            get { return _group.GroupDescriptions; } 
        }

        /// 
        /// The top-level groups, constructed according to the descriptions 
        /// given in GroupDescriptions and/or GroupBySelector.
        ///  
        public override ReadOnlyObservableCollection Groups 
        {
            get { return (IsGrouping) ? _group.Items : null; } 
        }

        #endregion ICollectionView
 

        ///  
        /// Return true if the item belongs to this view.  The item is assumed to belong to the 
        /// underlying DataCollection;  this method merely takes filters into account.
        /// It is commonly used during collection-changed notifications to determine if the added/removed 
        /// item requires processing.
        /// Returns true if no filter is set on collection view.
        /// 
        public override bool PassesFilter(object item) 
        {
            return ActiveFilter == null || ActiveFilter(item); 
        } 

        ///  Return the index where the given item belongs, or -1 if this index is unknown. 
        /// 
        /// 
        /// If this method returns an index other than -1, it must always be true that
        /// view[index-1] < item <= view[index], where the comparisons are done via 
        /// the view's IComparer.Compare method (if any).
        /// (This method is used by a listener's (e.g. System.Windows.Controls.ItemsControl) 
        /// CollectionChanged event handler to speed up its reaction to insertion and deletion of items. 
        /// If IndexOf is  not implemented, a listener does a binary search using IComparer.Compare.)
        ///  
        /// data item
        public override int IndexOf(object item)
        {
            VerifyRefreshNotDeferred(); 

            return InternalIndexOf(item); 
        } 

        ///  
        /// Retrieve item at the given zero-based index in this CollectionView.
        /// 
        /// 
        /// 
The index is evaluated with any SortDescriptions or Filter being set on this CollectionView.
 
        /// 
        ///  
        /// Thrown if index is out of range 
        /// 
        public override object GetItemAt(int index) 
        {
            VerifyRefreshNotDeferred();

            return InternalItemAt(index); 
        }
 
 
        //------------------------------------------------------
        #region IComparer 

        ///  Return -, 0, or +, according to whether o1 occurs before, at, or after o2 (respectively)
        /// 
        /// first object 
        /// second object
        ///  
        /// Compares items by their resp. index in the IList. 
        /// 
        int IComparer.Compare(object o1, object o2) 
        {
            return Compare(o1, o2);
        }
 
        ///  Return -, 0, or +, according to whether o1 occurs before, at, or after o2 (respectively)
        ///  
        /// first object 
        /// second object
        ///  
        /// Compares items by their resp. index in the IList.
        /// 
        protected virtual int Compare(object o1, object o2)
        { 
            if (!IsGrouping)
            { 
                if (ActiveComparer != null) 
                    return ActiveComparer.Compare(o1, o2);
 
                int i1 = InternalList.IndexOf(o1);
                int i2 = InternalList.IndexOf(o2);
                return (i1 - i2);
            } 
            else
            { 
                int i1 = InternalIndexOf(o1); 
                int i2 = InternalIndexOf(o2);
                return (i1 - i2); 
            }
        }

        #endregion IComparer 

        ///  
        /// Implementation of IEnumerable.GetEnumerator(). 
        /// This provides a way to enumerate the members of the collection
        /// without changing the currency. 
        /// 
        protected override IEnumerator GetEnumerator()
        {
            VerifyRefreshNotDeferred(); 

            return InternalGetEnumerator(); 
        } 

        #endregion Public Methods 


        //-----------------------------------------------------
        // 
        //  Public Properties
        // 
        //------------------------------------------------------ 

        #region Public Properties 

        //-----------------------------------------------------
        #region ICollectionView
 
        /// 
        /// Collection of Sort criteria to sort items in this view over the SourceCollection. 
        ///  
        /// 
        /// 
 
        /// One or more sort criteria in form of 
        /// can be added, each specifying a property and direction to sort by.
        /// 

        ///  
        public override SortDescriptionCollection SortDescriptions
        { 
            get 
            {
                if (_sort == null) 
                    SetSortDescriptions(new SortDescriptionCollection());
                return _sort;
            }
        } 

        ///  
        /// Test if this ICollectionView supports sorting before adding 
        /// to .
        ///  
        /// 
        /// ListCollectionView does implement an IComparer based sorting.
        /// 
        public override bool CanSort 
        {
            get { return true; } 
        } 

        ///  
        /// Test if this ICollectionView supports filtering before assigning
        /// a filter callback to .
        /// 
        public override bool CanFilter 
        {
            get { return true; } 
        } 

        ///  
        /// Filter is a callback set by the consumer of the ICollectionView
        /// and used by the implementation of the ICollectionView to determine if an
        /// item is suitable for inclusion in the view.
        ///  
        /// 
        /// Simpler implementations do not support filtering and will throw a NotSupportedException. 
        /// Use  property to test if filtering is supported before 
        /// assigning a non-null value.
        ///  
        public override Predicate Filter
        {
            get
            { 
                return base.Filter;
            } 
            set 
            {
                if (IsAddingNew || IsEditingItem) 
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Filter"));
                base.Filter = value;
            }
        } 

        #endregion ICollectionView 
 
        /// 
        /// Set a custom comparer to sort items using an object that implements IComparer. 
        /// 
        /// 
        /// Setting the Sort criteria has no immediate effect,
        /// an explicit  call by the app is required. 
        /// Note: Setting the custom comparer object will clear previously set .
        ///  
        public IComparer CustomSort 
        {
            get { return _customSort; } 
            set
            {
                if (IsAddingNew || IsEditingItem)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "CustomSort")); 
                _customSort = value;
                SetSortDescriptions(null); 
 
                RefreshOrDefer();
            } 
        }

        /// 
        /// A delegate to select the group description as a function of the 
        /// parent group and its level.
        ///  
        [DefaultValue(null)] 
        public virtual GroupDescriptionSelectorCallback GroupBySelector
        { 
            get { return _group.GroupBySelector; }
            set
            {
                if (!CanGroup) 
                    throw new NotSupportedException();
                if (IsAddingNew || IsEditingItem) 
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Grouping")); 

                _group.GroupBySelector = value; 

                RefreshOrDefer();
            }
        } 

        ///  
        /// Return the estimated number of records (or -1, meaning "don't know"). 
        /// 
        public override int Count 
        {
            get
            {
                VerifyRefreshNotDeferred(); 

                return InternalCount; 
            } 
        }
 
        /// 
        /// Returns true if the resulting (filtered) view is emtpy.
        /// 
        public override bool IsEmpty 
        {
            get { return (InternalCount == 0); } 
        } 

        ///  
        /// Setting this to true informs the view that the list of items
        /// (after applying the sort and filter, if any) is already in the
        /// correct order for grouping.  This allows the view to use a more
        /// efficient algorithm to build the groups. 
        /// 
        public bool IsDataInGroupOrder 
        { 
            get { return _group.IsDataInGroupOrder; }
            set { _group.IsDataInGroupOrder = value; } 
        }

        #endregion Public Properties
 
        #region IEditableCollectionView
 
        #region Adding new items 

        ///  
        /// Indicates whether to include a placeholder for a new item, and if so,
        /// where to put it.
        /// 
        public NewItemPlaceholderPosition NewItemPlaceholderPosition 
        {
            get { return _newItemPlaceholderPosition; } 
            set 
            {
                VerifyRefreshNotDeferred(); 

                if (value != _newItemPlaceholderPosition && IsAddingNew)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "NewItemPlaceholderPosition", "AddNew"));
 
                NotifyCollectionChangedEventArgs args = null;
                int oldIndex=-1, newIndex=-1; 
 
                // we're adding, removing, or moving the placeholder.
                // Determine the appropriate events. 
                switch (value)
                {
                    case NewItemPlaceholderPosition.None:
                        switch (_newItemPlaceholderPosition) 
                        {
                            case NewItemPlaceholderPosition.None: 
                                break; 
                            case NewItemPlaceholderPosition.AtBeginning:
                                oldIndex = 0; 
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Remove,
                                                NewItemPlaceholder,
                                                oldIndex); 
                                break;
                            case NewItemPlaceholderPosition.AtEnd: 
                                oldIndex = InternalCount - 1; 
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Remove, 
                                                NewItemPlaceholder,
                                                oldIndex);
                                break;
                        } 
                        break;
 
                    case NewItemPlaceholderPosition.AtBeginning: 
                        switch (_newItemPlaceholderPosition)
                        { 
                            case NewItemPlaceholderPosition.None:
                                newIndex = 0;
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Add, 
                                                NewItemPlaceholder,
                                                newIndex); 
                                break; 
                            case NewItemPlaceholderPosition.AtBeginning:
                                break; 
                            case NewItemPlaceholderPosition.AtEnd:
                                oldIndex = InternalCount - 1;
                                newIndex = 0;
                                args = new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Move,
                                                NewItemPlaceholder, 
                                                newIndex, 
                                                oldIndex);
                                break; 
                        }
                        break;

                    case NewItemPlaceholderPosition.AtEnd: 
                        switch (_newItemPlaceholderPosition)
                        { 
                            case NewItemPlaceholderPosition.None: 
                                newIndex = InternalCount;
                                args = new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Add,
                                                NewItemPlaceholder,
                                                newIndex);
                                break; 
                            case NewItemPlaceholderPosition.AtBeginning:
                                oldIndex = 0; 
                                newIndex = InternalCount - 1; 
                                args = new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Move, 
                                                NewItemPlaceholder,
                                                newIndex,
                                                oldIndex);
                                break; 
                            case NewItemPlaceholderPosition.AtEnd:
                                break; 
                        } 
                        break;
                } 

                // now make the change and raise the events
                if (args != null)
                { 
                    _newItemPlaceholderPosition = value;
 
                    if (!IsGrouping) 
                    {
                        ProcessCollectionChangedWithAdjustedIndex(args, oldIndex, newIndex); 
                    }
                    else
                    {
                        if (oldIndex >= 0) 
                        {
                            int index = (oldIndex == 0) ? 0 : _group.Items.Count - 1; 
                            _group.RemoveSpecialItem(index, NewItemPlaceholder, false /*loading*/); 
                        }
                        if (newIndex >= 0) 
                        {
                            int index = (newIndex == 0) ? 0 : _group.Items.Count;
                            _group.InsertSpecialItem(index, NewItemPlaceholder, false /*loading*/);
                        } 
                    }
 
                    OnPropertyChanged("NewItemPlaceholderPosition"); 
                }
            } 
        }

        /// 
        /// Return true if the view supports . 
        /// 
        public bool CanAddNew 
        { 
            get { return !IsEditingItem && !SourceList.IsFixedSize && CanConstructItem; }
        } 

        bool CanConstructItem
        {
            get 
            {
                if (!_isItemConstructorValid) 
                { 
                    EnsureItemConstructor();
                } 

                return (_itemConstructor != null);
            }
        } 

        void EnsureItemConstructor() 
        { 
            if (!_isItemConstructorValid)
            { 
                Type itemType = GetItemType(true);
                if (itemType != null)
                {
                    _itemConstructor = itemType.GetConstructor(Type.EmptyTypes); 
                    _isItemConstructorValid = true;
                } 
            } 
        }
 
        /// 
        /// Add a new item to the underlying collection.  Returns the new item.
        /// After calling AddNew and changing the new item as desired, either
        ///  or  should be 
        /// called to complete the transaction.
        ///  
        public object AddNew() 
        {
            VerifyRefreshNotDeferred(); 

            if (IsEditingItem)
            {
                CommitEdit();   // implicitly close a previous EditItem 
            }
 
            CommitNew();        // implicitly close a previous AddNew 

            if (!CanAddNew) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedForView, "AddNew"));

            object newItem = _itemConstructor.Invoke(null);
            _newItemIndex = -2; // this is a signal that the next Add event comes from AddNew 
            int index = SourceList.Add(newItem);
 
            // if the source doesn't raise collection change events, fake one 
            if (!(SourceList is INotifyCollectionChanged))
            { 
                // the index returned by IList.Add isn't always reliable
                if (!Object.Equals(newItem, SourceList[index]))
                {
                    index = SourceList.IndexOf(newItem); 
                }
 
                BeginAddNew(newItem, index); 
            }
 
            Debug.Assert(_newItemIndex != -2 && Object.Equals(newItem, _newItem), "AddNew did not raise expected events");

            MoveCurrentTo(newItem);
 
            ISupportInitialize isi = newItem as ISupportInitialize;
            if (isi != null) 
            { 
                isi.BeginInit();
            } 

            IEditableObject ieo = newItem as IEditableObject;
            if (ieo != null)
            { 
                ieo.BeginEdit();
            } 
 
            return newItem;
        } 

        // Calling IList.Add() will raise an ItemAdded event.  We handle this specially
        // to adjust the position of the new item in the view (it should be adjacent
        // to the placeholder), and cache the new item for use by the other APIs 
        // related to AddNew.  This method is called from ProcessCollectionChanged.
        void BeginAddNew(object newItem, int index) 
        { 
            Debug.Assert(_newItemIndex == -2 && _newItem == null, "unexpected call to BeginAddNew");
 
            // remember the new item and its position in the underlying list
            _newItem = newItem;
            _newItemIndex = index;
 
            // adjust the position of the new item
            int position = -1; 
            switch (NewItemPlaceholderPosition) 
            {
                case NewItemPlaceholderPosition.None: 
                    position = UsesLocalArray ? InternalCount - 1 : _newItemIndex;
                    break;
                case NewItemPlaceholderPosition.AtBeginning:
                    position = 1; 
                    break;
                case NewItemPlaceholderPosition.AtEnd: 
                    position = InternalCount - 2; 
                    break;
            } 

            // raise events as if the new item appeared in the adjusted position
            ProcessCollectionChangedWithAdjustedIndex(
                                        new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Add,
                                                newItem, 
                                                position), 
                                        -1, position);
        } 

        /// 
        /// Complete the transaction started by .  The new
        /// item remains in the collection, and the view's sort, filter, and grouping 
        /// specifications (if any) are applied to the new item.
        ///  
        public void CommitNew() 
        {
            if (IsEditingItem) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CommitNew", "EditItem"));
            VerifyRefreshNotDeferred();

            if (_newItem == null) 
                return;
 
            // grouping works differently 
            if (IsGrouping)
            { 
                CommitNewForGrouping();
                return;
            }
 
            // from the POV of view clients, the new item is moving from its
            // position adjacent to the placeholder to its real position. 
            // Remember its current position (have to do this before calling EndNew, 
            // because InternalCount depends on "adding-new" mode).
            int fromIndex = 0; 
            switch (NewItemPlaceholderPosition)
            {
                case NewItemPlaceholderPosition.None:
                    fromIndex = UsesLocalArray ? InternalCount - 1 : _newItemIndex; 
                    break;
                case NewItemPlaceholderPosition.AtBeginning: 
                    fromIndex = 1; 
                    break;
                case NewItemPlaceholderPosition.AtEnd: 
                    fromIndex = InternalCount - 2;
                    break;
            }
 
            // End the AddNew transaction
            object newItem = EndAddNew(false); 
 
            // Tell the view clients what happened to the new item
            int toIndex = AdjustBefore(NotifyCollectionChangedAction.Add, newItem, _newItemIndex); 

            if (toIndex < 0)
            {
                // item is effectively removed (due to filter), raise a Remove event 
                ProcessCollectionChangedWithAdjustedIndex(
                            new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Remove, 
                                                newItem,
                                                fromIndex), 
                            fromIndex, -1);
            }
            else if (fromIndex == toIndex)
            { 
                // item isn't moving, so no events are needed.  But the item does need
                // to be added to the local array. 
                if (UsesLocalArray) 
                {
                    if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) 
                    {
                        --toIndex;
                    }
                    InternalList.Insert(toIndex, newItem); 
                }
            } 
            else 
            {
                // item is moving 
                ProcessCollectionChangedWithAdjustedIndex(
                            new NotifyCollectionChangedEventArgs(
                                                NotifyCollectionChangedAction.Move,
                                                newItem, 
                                                toIndex, fromIndex),
                            fromIndex, toIndex); 
            } 
        }
 
        void CommitNewForGrouping()
        {
            // for grouping we cannot pretend that the new item moves to a different position,
            // since it may actually appear in several new positions (belonging to several groups). 
            // Instead, we remove the item from its temporary position, then add it to the groups
            // as if it had just been added to the underlying collection. 
            int index; 
            switch (NewItemPlaceholderPosition)
            { 
                case NewItemPlaceholderPosition.None:
                default:
                    index = _group.Items.Count - 1;
                    break; 
                case NewItemPlaceholderPosition.AtBeginning:
                    index = 1; 
                    break; 
                case NewItemPlaceholderPosition.AtEnd:
                    index = _group.Items.Count - 2; 
                    break;
            }

            // End the AddNew transaction 
            int newItemIndex = _newItemIndex;
            object newItem = EndAddNew(false); 
 
            // remove item from its temporary position
            _group.RemoveSpecialItem(index, newItem, false /*loading*/); 

            // now pretend it just got added to the collection.  This will add it
            // to the internal list with sort/filter, and to the groups
            ProcessCollectionChanged( 
                    new NotifyCollectionChangedEventArgs(
                                NotifyCollectionChangedAction.Add, 
                                newItem, 
                                newItemIndex));
        } 

        /// 
        /// Complete the transaction started by .  The new
        /// item is removed from the collection. 
        /// 
        public void CancelNew() 
        { 
            if (IsEditingItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CancelNew", "EditItem")); 
            VerifyRefreshNotDeferred();

            if (_newItem == null)
                return; 

            // remove the new item from the underlying collection.  Normally the 
            // collection will raise a Remove event, which we'll handle by calling 
            // EndNew to leave AddNew mode.
            SourceList.RemoveAt(_newItemIndex); 

            // if the collection doesn't raise events, do the work explicitly on its behalf
            if (_newItem != null)
            { 
                int index = AdjustBefore(NotifyCollectionChangedAction.Remove, _newItem, _newItemIndex);
                object newItem = EndAddNew(true); 
 
                ProcessCollectionChangedWithAdjustedIndex(
                            new NotifyCollectionChangedEventArgs( 
                                                NotifyCollectionChangedAction.Remove,
                                                newItem,
                                                index),
                            index, -1); 
            }
        } 
 
        // Common functionality used by CommitNew, CancelNew, and when the
        // new item is removed by Remove or Refresh. 
        object EndAddNew(bool cancel)
        {
            object newItem = _newItem;
 
            _newItem = null;    // leave "adding-new" mode
 
            IEditableObject ieo = newItem as IEditableObject; 
            if (ieo != null)
            { 
                if (cancel)
                {
                    ieo.CancelEdit();
                } 
                else
                { 
                    ieo.EndEdit(); 
                }
            } 

            ISupportInitialize isi = newItem as ISupportInitialize;
            if (isi != null)
            { 
                isi.EndInit();
            } 
 
            return newItem;
        } 

        /// 
        /// Returns true if an  transaction is in progress.
        ///  
        public bool IsAddingNew
        { 
            get { return (_newItem != null); } 
        }
 
        /// 
        /// When an  transaction is in progress, this property
        /// returns the new item.  Otherwise it returns null.
        ///  
        public object CurrentAddItem
        { 
            get { return _newItem; } 
        }
 
        #endregion Adding new items

        #region Removing items
 
        /// 
        /// Return true if the view supports  and 
        /// . 
        /// 
        public bool CanRemove 
        {
            get { return !IsEditingItem && !IsAddingNew && !SourceList.IsFixedSize; }
        }
 
        /// 
        /// Remove the item at the given index from the underlying collection. 
        /// The index is interpreted with respect to the view (not with respect to 
        /// the underlying collection).
        ///  
        public void RemoveAt(int index)
        {
            if (IsEditingItem || IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "RemoveAt")); 
            VerifyRefreshNotDeferred();
 
            // convert the index from "view-relative" to "list-relative" 
            int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ? 1 : 0;
            object item = GetItemAt(index); 
            if (item == CollectionView.NewItemPlaceholder)
                throw new InvalidOperationException(SR.Get(SRID.RemovingPlaceholder));

            int listIndex = index - delta; 
            bool raiseEvent = !(SourceList is INotifyCollectionChanged);
 
            // remove the item from the list 
            if (UsesLocalArray || IsGrouping)
            { 
                if (raiseEvent)
                {
                    listIndex = SourceList.IndexOf(item);
                    SourceList.RemoveAt(listIndex); 
                }
                else 
                { 
                    SourceList.Remove(item);
                } 
            }
            else
            {
                SourceList.RemoveAt(listIndex); 
            }
 
            // if the list doesn't raise CollectionChanged events, fake one 
            if (raiseEvent)
            { 
                ProcessCollectionChanged(new NotifyCollectionChangedEventArgs(
                                            NotifyCollectionChangedAction.Remove,
                                            item,
                                            listIndex)); 
            }
        } 
 
        /// 
        /// Remove the given item from the underlying collection. 
        /// 
        public void Remove(object item)
        {
            int index = InternalIndexOf(item); 
            if (index >= 0)
            { 
                RemoveAt(index); 
            }
        } 

        #endregion Removing items

        #region Transactional editing of an item 

        ///  
        /// Begins an editing transaction on the given item.  The transaction is 
        /// completed by calling either  or
        /// .  Any changes made to the item during 
        /// the transaction are considered "pending", provided that the view supports
        /// the notion of "pending changes" for the given item.
        /// 
        public void EditItem(object item) 
        {
            VerifyRefreshNotDeferred(); 
 
            if (item == NewItemPlaceholder)
                throw new ArgumentException(SR.Get(SRID.CannotEditPlaceholder), "item"); 

            if (IsAddingNew)
            {
                if (Object.Equals(item, _newItem)) 
                    return;     // EditItem(newItem) is a no-op
 
                CommitNew();    // implicitly close a previous AddNew 
            }
 
            CommitEdit();   // implicitly close a previous EditItem transaction

            _editItem = item;
 
            IEditableObject ieo = item as IEditableObject;
            if (ieo != null) 
            { 
                ieo.BeginEdit();
            } 
        }

        /// 
        /// Complete the transaction started by . 
        /// The pending changes (if any) to the item are committed.
        ///  
        public void CommitEdit() 
        {
            if (IsAddingNew) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CommitEdit", "AddNew"));
            VerifyRefreshNotDeferred();

            if (_editItem == null) 
                return;
 
            object editItem = _editItem; 
            IEditableObject ieo = _editItem as IEditableObject;
            _editItem = null; 

            if (ieo != null)
            {
                ieo.EndEdit(); 
            }
 
            // editing may change the item's group names (and we can't tell whether 
            // it really did).  The best we can do is remove the item and re-insert
            // it. 
            if (IsGrouping)
            {
                RemoveItemFromGroups(editItem);
                AddItemToGroups(editItem); 
                return;
            } 
 
            // the edit may cause the item to move.  If so, report it.
            if (UsesLocalArray) 
            {
                int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ? 1 : 0;
                int fromIndex = InternalIndexOf(editItem);
 
                if (!PassesFilter(editItem))
                { 
                    // the item has been effectively removed 
                    ProcessCollectionChangedWithAdjustedIndex(
                                new NotifyCollectionChangedEventArgs( 
                                                    NotifyCollectionChangedAction.Remove,
                                                    editItem,
                                                    fromIndex),
                                fromIndex, -1); 
                }
                else if (ActiveComparer != null) 
                { 
                    ArrayList list = (ArrayList)InternalList;
                    int localIndex = fromIndex - delta; 
                    int toIndex = -1;
                    if (localIndex > 0 && ActiveComparer.Compare(list[localIndex-1], editItem) > 0)
                    {
                        // the item has moved toward the front of the list 
                        toIndex = list.BinarySearch(0, localIndex, editItem, ActiveComparer);
                        if (toIndex < 0) 
                            toIndex = ~toIndex; 
                    }
                    else if (localIndex < list.Count - 1 && ActiveComparer.Compare(editItem, list[localIndex+1]) > 0) 
                    {
                        // the item has moved toward the back of the list
                        toIndex = list.BinarySearch(localIndex+1, list.Count-localIndex-1, editItem, ActiveComparer);
                        if (toIndex < 0) 
                            toIndex = ~toIndex;
                        --toIndex;      // because the item is leaving its old position 
                    } 

                    if (toIndex >= 0) 
                    {
                        // the item has effectively moved
                        ProcessCollectionChangedWithAdjustedIndex(
                                    new NotifyCollectionChangedEventArgs( 
                                                        NotifyCollectionChangedAction.Move,
                                                        editItem, 
                                                        toIndex+delta, fromIndex), 
                                    fromIndex, toIndex+delta);
                    } 
                }
            }
        }
 
        /// 
        /// Complete the transaction started by . 
        /// The pending changes (if any) to the item are discarded. 
        /// 
        public void CancelEdit() 
        {
            if (IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CancelEdit", "AddNew"));
            VerifyRefreshNotDeferred(); 

            if (_editItem == null) 
                return; 

            IEditableObject ieo = _editItem as IEditableObject; 
            _editItem = null;

            if (ieo != null)
            { 
                ieo.CancelEdit();
            } 
            else 
                throw new InvalidOperationException(SR.Get(SRID.CancelEditNotSupported));
        } 

        private void ImplicitlyCancelEdit()
        {
            IEditableObject ieo = _editItem as IEditableObject; 
            _editItem = null;
 
            if (ieo != null) 
            {
                ieo.CancelEdit(); 
            }
        }

        ///  
        /// Returns true if the view supports the notion of "pending changes" on the
        /// current edit item.  This may vary, depending on the view and the particular 
        /// item.  For example, a view might return true if the current edit item 
        /// implements , or if the view has special
        /// knowledge about the item that it can use to support rollback of pending 
        /// changes.
        /// 
        public bool CanCancelEdit
        { 
            get { return (_editItem is IEditableObject); }
        } 
 
        /// 
        /// Returns true if an  transaction is in progress. 
        /// 
        public bool IsEditingItem
        {
            get { return (_editItem != null); } 
        }
 
        ///  
        /// When an  transaction is in progress, this property
        /// returns the affected item.  Otherwise it returns null. 
        /// 
        public object CurrentEditItem
        {
            get { return _editItem; } 
        }
 
        #endregion Transactional editing of an item 

        #endregion IEditableCollectionView 

        #region IItemProperties

        ///  
        /// Returns information about the properties available on items in the
        /// underlying collection.  This information may come from a schema, from 
        /// a type descriptor, from a representative item, or from some other source 
        /// known to the view.
        ///  
        public ReadOnlyCollection ItemProperties
        {
            get { return GetItemProperties(); }
        } 

        #endregion IItemProperties 
 

 
        //-----------------------------------------------------
        //
        //  Protected Methods
        // 
        //-----------------------------------------------------
        #region Protected Methods 
 

        ///  
        ///     Called by the the base class to notify derived class that
        ///     a CollectionChange has been posted to the message queue.
        ///     The purpose of this notification is to allow CollectionViews to
        ///     take a snapshot of whatever information is needed at the time 
        ///     of the Post (most likely the state of the Data Collection).
        ///  
        ///  
        ///     The NotifyCollectionChangedEventArgs that is added to the change log
        ///  
        protected override void OnBeginChangeLogging(NotifyCollectionChangedEventArgs args)
        {
            if (args == null)
                throw new ArgumentNullException("args"); 

            if (ShadowCollection == null || args.Action == NotifyCollectionChangedAction.Reset) 
            { 
                ShadowCollection = new ArrayList((ICollection)SourceCollection);
 
                if (!UsesLocalArray)
                {
                    _internalList = ShadowCollection;
                } 

                // the first change processed in ProcessChangeLog does 
                // not need to be applied to the ShadowCollection in 
                // ProcessChangeLog because the change will already be
                // reflected as a result of copying the Collection. 
                _applyChangeToShadow = false;
            }
        }
 
        /// 
        /// Handle CollectionChange events 
        ///  
        protected override void ProcessCollectionChanged(NotifyCollectionChangedEventArgs args)
        { 
            if (args == null)
                throw new ArgumentNullException("args");

            ValidateCollectionChangedEventArgs(args); 

            int adjustedOldIndex = -1; 
            int adjustedNewIndex = -1; 

            // apply the change to the shadow copy 
            if (UpdatedOutsideDispatcher)
            {
                if (_applyChangeToShadow)
                { 
                    if (args.Action != NotifyCollectionChangedAction.Reset)
                    { 
                        if (args.Action != NotifyCollectionChangedAction.Remove && args.NewStartingIndex < 0 
                            || args.Action != NotifyCollectionChangedAction.Add && args.OldStartingIndex < 0)
                        { 
                            Debug.Assert(false, "Cannot update collection view from outside UIContext without index in event args");
                            return;     //
                        }
                        else 
                        {
                            AdjustShadowCopy(args); 
                        } 
                    }
                } 
                _applyChangeToShadow = true;
            }

            // If the Action is Reset then we do a Refresh. 
            if (args.Action == NotifyCollectionChangedAction.Reset)
            { 
                // implicitly cancel EditItem transactions 
                if (IsEditingItem)
                { 
                    ImplicitlyCancelEdit();
                }

                // adjust AddNew transactions, depending on whether the new item 
                // survived the Reset
                if (IsAddingNew) 
                { 
                    _newItemIndex = SourceList.IndexOf(_newItem);
                    if (_newItemIndex < 0) 
                    {
                        EndAddNew(true);
                    }
                } 

                RefreshOrDefer(); 
                return; // the Refresh raises collection change event, so there's nothing left to do 
            }
 
            if (args.Action == NotifyCollectionChangedAction.Add && _newItemIndex == -2)
            {
                // The Add event came from AddNew.
                BeginAddNew(args.NewItems[0], args.NewStartingIndex); 
                return;
            } 
 
            // If the Action is one that can be expected to have a valid NewItems[0] and NewStartingIndex then
            // adjust the index for filtering and sorting. 
            if (args.Action != NotifyCollectionChangedAction.Remove)
            {
                adjustedNewIndex = AdjustBefore(NotifyCollectionChangedAction.Add, args.NewItems[0], args.NewStartingIndex);
            } 

            // If the Action is one that can be expected to have a valid OldItems[0] and OldStartingIndex then 
            // adjust the index for filtering and sorting. 
            if (args.Action != NotifyCollectionChangedAction.Add)
            { 
                adjustedOldIndex = AdjustBefore(NotifyCollectionChangedAction.Remove, args.OldItems[0], args.OldStartingIndex);

                // the new index needs further adjustment if the action removes (or moves)
                // something before it 
                if (UsesLocalArray && adjustedOldIndex >= 0 && adjustedOldIndex < adjustedNewIndex)
                { 
                    -- adjustedNewIndex; 
                }
            } 

            // handle interaction with AddNew and EditItem
            switch (args.Action)
            { 
                case NotifyCollectionChangedAction.Add:
                    if (args.NewStartingIndex <= _newItemIndex) 
                    { 
                        ++ _newItemIndex;
                    } 
                    break;

                case NotifyCollectionChangedAction.Remove:
                    if (args.OldStartingIndex < _newItemIndex) 
                    {
                        -- _newItemIndex; 
                    } 

                    // implicitly cancel AddNew and/or EditItem transactions if the relevant item is removed 
                    object item = args.OldItems[0];

                    if (item == CurrentEditItem)
                    { 
                        ImplicitlyCancelEdit();
                    } 
                    else if (item == CurrentAddItem) 
                    {
                        EndAddNew(true); 
                    }
                    break;

                case NotifyCollectionChangedAction.Move: 
                    if (args.OldStartingIndex < _newItemIndex && _newItemIndex < args.NewStartingIndex)
                    { 
                        -- _newItemIndex; 
                    }
                    else if (args.NewStartingIndex <= _newItemIndex && _newItemIndex < args.OldStartingIndex) 
                    {
                        ++ _newItemIndex;
                    }
                    break; 
            }
 
            ProcessCollectionChangedWithAdjustedIndex(args, adjustedOldIndex, adjustedNewIndex); 
        }
 
        void ProcessCollectionChangedWithAdjustedIndex(NotifyCollectionChangedEventArgs args, int adjustedOldIndex, int adjustedNewIndex)
        {
            // Finding out the effective Action after filtering and sorting.
            // 
            NotifyCollectionChangedAction effectiveAction = args.Action;
            if (adjustedOldIndex == adjustedNewIndex && adjustedOldIndex >= 0) 
            { 
                effectiveAction = NotifyCollectionChangedAction.Replace;
            } 
            else if (adjustedOldIndex == -1) // old index is unknown
            {
                // we weren't told the old index, but it may have been in the view.
                if (adjustedNewIndex < 0) 
                {
                    // The new item will not be in the filtered view, 
                    // so an Add is a no-op and anything else is a Remove. 
                    if (args.Action == NotifyCollectionChangedAction.Add)
                        return; 
                    effectiveAction = NotifyCollectionChangedAction.Remove;
                }
            }
            else if (adjustedOldIndex < -1) // old item is known to be NOT in filtered view 
            {
                if (adjustedNewIndex < 0) 
                { 
                    // since the old item wasn't in the filtered view, and the new
                    // item would not be in the filtered view, this is a no-op. 
                    return;
                }
                else
                { 
                    effectiveAction = NotifyCollectionChangedAction.Add;
                } 
            } 
            else // old item was in view
            { 
                if (adjustedNewIndex < 0)
                {
                    effectiveAction = NotifyCollectionChangedAction.Remove;
                } 
                else
                { 
                    effectiveAction = NotifyCollectionChangedAction.Move; 
                }
            } 

            int delta = IsGrouping ? 0 :
                        (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ?
                        (IsAddingNew ? 2 : 1) : 0; 

            int originalCurrentPosition = CurrentPosition; 
            int oldCurrentPosition = CurrentPosition; 
            object oldCurrentItem = CurrentItem;
            bool oldIsCurrentAfterLast = IsCurrentAfterLast; 
            bool oldIsCurrentBeforeFirst = IsCurrentBeforeFirst;

            // in the case of a replace that has a new adjustedPosition
            // (likely caused by sorting), the only way to effectively communicate 
            // this change is through raising Remove followed by Insert.
            NotifyCollectionChangedEventArgs args2 = null; 
 
            switch (effectiveAction)
            { 
                case NotifyCollectionChangedAction.Add:
                    // insert into private view
                    // (unless it's a special item - placeholder or new item)
                    if (UsesLocalArray && NewItemPlaceholder != args.NewItems[0] && 
                            (!IsAddingNew || !Object.Equals(_newItem, args.NewItems[0])))
                    { 
                        InternalList.Insert(adjustedNewIndex - delta, args.NewItems[0]); 
                    }
 
                    if (!IsGrouping)
                    {
                        AdjustCurrencyForAdd(adjustedNewIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.NewItems[0], adjustedNewIndex); 
                    }
                    else 
                    { 
                        AddItemToGroups(args.NewItems[0]);
                    } 

                    break;

                case NotifyCollectionChangedAction.Remove: 
                    // remove from private view, unless it's not there to start with
                    // (e.g. when CommitNew is applied to an item that fails the filter) 
                    if (UsesLocalArray) 
                    {
                        int localOldIndex = adjustedOldIndex - delta; 

                        if (localOldIndex < InternalList.Count &&
                            Object.Equals(InternalList[localOldIndex], args.OldItems[0]))
                        { 
                            InternalList.RemoveAt(localOldIndex);
                        } 
                    } 

                    if (!IsGrouping) 
                    {
                        AdjustCurrencyForRemove(adjustedOldIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.OldItems[0], adjustedOldIndex);
                    } 
                    else
                    { 
                        RemoveItemFromGroups(args.OldItems[0]); 
                    }
 
                    break;
                case NotifyCollectionChangedAction.Replace:
                    // replace item in private view
                    if (UsesLocalArray) 
                    {
                        InternalList[adjustedOldIndex - delta] = args.NewItems[0]; 
                    } 

                    if (!IsGrouping) 
                    {
                        AdjustCurrencyForReplace(adjustedOldIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.NewItems[0], args.OldItems[0], adjustedOldIndex);
                    } 
                    else
                    { 
                        RemoveItemFromGroups(args.OldItems[0]); 
                        AddItemToGroups(args.NewItems[0]);
                    } 

                    break;

                case NotifyCollectionChangedAction.Move: 
                    // remove from private view
 
                    bool simpleMove = args.OldItems[0] == args.NewItems[0]; 

                    if (UsesLocalArray) 
                    {
                        int localOldIndex = adjustedOldIndex - delta;
                        int localNewIndex = adjustedNewIndex - delta;
 
                        // remove the item from its old position, unless it's not there
                        // (which happens when the item is the object of CommitNew) 
                        if (localOldIndex < InternalList.Count && 
                            Object.Equals(InternalList[localOldIndex], args.OldItems[0]))
                        { 
                            InternalList.RemoveAt(localOldIndex);
                        }

                        // put the item into its new position, unless it's special 
                        if (NewItemPlaceholder != args.NewItems[0])
                        { 
                            InternalList.Insert(localNewIndex, args.NewItems[0]); 
                        }
                    } 

                    if (!IsGrouping)
                    {
                        AdjustCurrencyForMove(adjustedOldIndex, adjustedNewIndex); 

                        if (simpleMove) 
                        { 
                            // simple move
                            args = new NotifyCollectionChangedEventArgs(effectiveAction, args.OldItems[0], adjustedNewIndex, adjustedOldIndex); 
                        }
                        else
                        {
                            // move/replace 
                            args2 = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, args.NewItems, adjustedNewIndex);
                            args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, args.OldItems, adjustedOldIndex); 
                        } 
                    }
                    else 
                    {
                        if (!simpleMove)
                        {
                            RemoveItemFromGroups(args.OldItems[0]); 
                            AddItemToGroups(args.NewItems[0]);
                        } 
                    } 
                    break;
                default: 
                    Invariant.Assert(false, SR.Get(SRID.UnexpectedCollectionChangeAction, effectiveAction));
                    break;
            }
 
            // remember whether scalar properties of the view have changed.
            // They may change again during the collection change event, so we 
            // need to do the test before raising that event. 
            bool afterLastHasChanged = (IsCurrentAfterLast != oldIsCurrentAfterLast);
            bool beforeFirstHasChanged = (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst); 
            bool currentPositionHasChanged = (CurrentPosition != oldCurrentPosition);
            bool currentItemHasChanged = (CurrentItem != oldCurrentItem);

            // take a new snapshot of the scalar properties, so that we can detect 
            // changes made during the collection change event
            oldIsCurrentAfterLast = IsCurrentAfterLast; 
            oldIsCurrentBeforeFirst = IsCurrentBeforeFirst; 
            oldCurrentPosition = CurrentPosition;
            oldCurrentItem = CurrentItem; 

            // base class will raise an event to our listeners
            if (!IsGrouping)
            { 
                // we've already returned if (args.Action == NotifyCollectionChangedAction.Reset) above
                OnCollectionChanged(args); 
                if (args2 != null) 
                    OnCollectionChanged(args2);
 
                // Any scalar properties that changed don't need a further notification,
                // but do need a new snapshot
                if (IsCurrentAfterLast != oldIsCurrentAfterLast)
                { 
                    afterLastHasChanged = false;
                    oldIsCurrentAfterLast = IsCurrentAfterLast; 
                } 
                if (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst)
                { 
                    beforeFirstHasChanged = false;
                    oldIsCurrentBeforeFirst = IsCurrentBeforeFirst;
                }
                if (CurrentPosition != oldCurrentPosition) 
                {
                    currentPositionHasChanged = false; 
                    oldCurrentPosition = CurrentPosition; 
                }
                if (CurrentItem != oldCurrentItem) 
                {
                    currentItemHasChanged = false;
                    oldCurrentItem = CurrentItem;
                } 

            } 
 
            // currency has to change after firing the deletion event,
            // so event handlers have the right picture 
            if (_currentElementWasRemoved)
            {
                MoveCurrencyOffDeletedElement(originalCurrentPosition);
 
                // changes to the scalar properties need notification
                afterLastHasChanged = afterLastHasChanged || (IsCurrentAfterLast != oldIsCurrentAfterLast); 
                beforeFirstHasChanged = beforeFirstHasChanged || (IsCurrentBeforeFirst != oldIsCurrentBeforeFirst); 
                currentPositionHasChanged = currentPositionHasChanged || (CurrentPosition != oldCurrentPosition);
                currentItemHasChanged = currentItemHasChanged || (CurrentItem != oldCurrentItem); 
            }

            // notify that the properties have changed.  We may end up doing
            // double notification for properties that change during the collection 
            // change event, but that's not harmful.  Detecting the double change
            // is more trouble than it's worth. 
            if (afterLastHasChanged) 
                OnPropertyChanged(IsCurrentAfterLastPropertyName);
 
            if (beforeFirstHasChanged)
                OnPropertyChanged(IsCurrentBeforeFirstPropertyName);

            if (currentPositionHasChanged) 
                OnPropertyChanged(CurrentPositionPropertyName);
 
            if (currentItemHasChanged) 
                OnPropertyChanged(CurrentItemPropertyName);
 
        }

        /// 
        /// Return index of item in the internal list. 
        /// 
        protected int InternalIndexOf(object item) 
        { 
            if (IsGrouping)
            { 
                return _group.LeafIndexOf(item);
            }

            if (item == NewItemPlaceholder) 
            {
                switch (NewItemPlaceholderPosition) 
                { 
                    case NewItemPlaceholderPosition.None:
                        return -1; 

                    case NewItemPlaceholderPosition.AtBeginning:
                        return 0;
 
                    case NewItemPlaceholderPosition.AtEnd:
                        return InternalCount - 1; 
                } 
            }
            else if (IsAddingNew && Object.Equals(item, _newItem)) 
            {
                switch (NewItemPlaceholderPosition)
                {
                    case NewItemPlaceholderPosition.None: 
                        if (UsesLocalArray)
                        { 
                            return InternalCount - 1; 
                        }
                        break; 

                    case NewItemPlaceholderPosition.AtBeginning:
                        return 1;
 
                    case NewItemPlaceholderPosition.AtEnd:
                        return InternalCount - 2; 
                } 
            }
 
            int index = InternalList.IndexOf(item);

            if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning && index >= 0)
            { 
                index += IsAddingNew ? 2 : 1;
            } 
 
            return index;
        } 

        /// 
        /// Return item at the given index in the internal list.
        ///  
        protected object InternalItemAt(int index)
        { 
            if (IsGrouping) 
            {
                return _group.LeafAt(index); 
            }

            switch (NewItemPlaceholderPosition)
            { 
                case NewItemPlaceholderPosition.None:
                    if (IsAddingNew && UsesLocalArray) 
                    { 
                        if (index == InternalCount - 1)
                            return _newItem; 
                    }
                    break;

                case NewItemPlaceholderPosition.AtBeginning: 
                    if (index == 0)
                        return NewItemPlaceholder; 
                    --index; 

                    if (IsAddingNew) 
                    {
                        if (index == 0)
                            return _newItem;
 
                        if (UsesLocalArray || index <= _newItemIndex)
                        { 
                            --index; 
                        }
                    } 
                    break;

                case NewItemPlaceholderPosition.AtEnd:
                    if (index == InternalCount - 1) 
                        return NewItemPlaceholder;
                    if (IsAddingNew) 
                    { 
                        if (index == InternalCount-2)
                            return _newItem; 
                        if (!UsesLocalArray && index >= _newItemIndex)
                            ++index;
                    }
                    break; 
            }
 
            return InternalList[index]; 
        }
 
        /// 
        /// Return true if internal list contains the item.
        /// 
        protected bool InternalContains(object item) 
        {
            if (item == NewItemPlaceholder) 
                return (NewItemPlaceholderPosition != NewItemPlaceholderPosition.None); 

            return (!IsGrouping) ? InternalList.Contains(item) : (_group.LeafIndexOf(item) >= 0); 
        }

        /// 
        /// Return an enumerator for the internal list. 
        /// 
        protected IEnumerator InternalGetEnumerator() 
        { 
            if (!IsGrouping)
            { 
                return new PlaceholderAwareEnumerator(this, InternalList.GetEnumerator(), NewItemPlaceholderPosition, _newItem);
            }
            else
            { 
                return _group.GetLeafEnumerator();
            } 
        } 

        ///  
        /// True if a private copy of the data is needed for sorting and filtering
        /// 
        protected bool UsesLocalArray
        { 
            get { return ActiveComparer != null || ActiveFilter != null; }
        } 
 
        /// 
        /// Protected accessor to private _internalList field. 
        /// 
        protected IList InternalList
        {
            get { return _internalList; } 
        }
 
        ///  
        /// Protected accessor to private _activeComparer field.
        ///  
        protected IComparer ActiveComparer
        {
            get { return _activeComparer; }
            set 
            {
                _activeComparer = value; 
                _group.ActiveComparer = value; 
            }
        } 

        /// 
        /// Protected accessor to private _activeFilter field.
        ///  
        protected Predicate ActiveFilter
        { 
            get { return _activeFilter; } 
            set { _activeFilter = value; }
        } 

        /// 
        /// Protected accessor to _isGrouping field.
        ///  
        protected bool IsGrouping
        { 
            get { return _isGrouping; } 
        }
 
        /// 
        /// Protected accessor to private count.
        /// 
        protected int InternalCount 
        {
            get 
            { 
                if (IsGrouping)
                    return _group.ItemCount; 

                int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.None) ? 0 : 1;
                if (UsesLocalArray && IsAddingNew)
                    ++delta; 

                return delta + InternalList.Count; 
            } 
        }
 
        #endregion Protected Methods

        //------------------------------------------------------
        // 
        //  Internal Methods
        // 
        //----------------------------------------------------- 

        #region Internal Methods 

        /// 
        ///     Contains a snapshot of the ICollectionView.SourceCollection
        ///     at the time that a change notification is posted. 
        ///     This is done in OnBeginChangeLogging.
        ///  
        internal ArrayList ShadowCollection 
        {
            get { return _shadowCollection; } 
            set { _shadowCollection = value; }
        }

        // 

 
        internal void AdjustShadowCopy(NotifyCollectionChangedEventArgs e) 
        {
            int tempIndex; 

            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add: 
                    if (e.NewStartingIndex > _unknownIndex)
                    { 
                        ShadowCollection.Insert(e.NewStartingIndex, e.NewItems[0]); 
                    }
                    else 
                    {
                        ShadowCollection.Add(e.NewItems[0]);
                    }
                    break; 
                case NotifyCollectionChangedAction.Remove:
                    if (e.OldStartingIndex > _unknownIndex) 
                    { 
                        ShadowCollection.RemoveAt(e.OldStartingIndex);
                    } 
                    else
                    {
                        ShadowCollection.Remove(e.OldItems[0]);
                    } 
                    break;
                case NotifyCollectionChangedAction.Replace: 
                    if (e.OldStartingIndex > _unknownIndex) 
                    {
                        ShadowCollection[e.OldStartingIndex] = e.NewItems[0]; 
                    }
                    else
                    {
                        // allow the ShadowCollection to throw the IndexOutOfRangeException 
                        // if the item is not found.
                        tempIndex = ShadowCollection.IndexOf(e.OldItems[0]); 
                        ShadowCollection[e.OldStartingIndex] = e.NewItems[0]; 
                    }
                    break; 
                case NotifyCollectionChangedAction.Move:
                    if (e.OldStartingIndex > _unknownIndex)
                    {
                        ShadowCollection.RemoveAt(e.OldStartingIndex); 
                    }
                    else 
                    { 
                        ShadowCollection.Remove(e.OldItems[0]);
                        ShadowCollection.Insert(e.NewStartingIndex, e.NewItems[0]); 
                    }
                    break;

                default: 
                    throw new NotSupportedException(SR.Get(SRID.UnexpectedCollectionChangeAction, e.Action));
 
            } 
        }
 
        // returns true if this ListCollectionView has sort descriptions,
        // without tripping off lazy creation of .SortDescriptions collection
        internal bool HasSortDescriptions
        { 
            get { return ((_sort != null) && (_sort.Count > 0)); }
        } 
 
        #endregion Internal Methods
 

        #region Private Properties

        //------------------------------------------------------ 
        //
        //  Private Properties 
        // 
        //------------------------------------------------------
 
        // true if CurrentPosition points to item within view
        private bool IsCurrentInView
        {
            get { return (0 <= CurrentPosition && CurrentPosition < InternalCount); } 
        }
 
        // can the group name(s) for an item change after we've grouped the item? 
        private bool CanGroupNamesChange
        { 
            // There's no way we can deduce this - the app has to tell us.
            // If this is true, removing a grouped item is quite difficult.
            // We cannot rely on its group names to tell us which group we inserted
            // it into (they may have been different at insertion time), so we 
            // have to do a linear search.
            get { return true; } 
        } 

        private IList SourceList 
        {
            get { return SourceCollection as IList; }
        }
 
        #endregion Private Properties
 
 
        //-----------------------------------------------------
        // 
        //  Private Methods
        //
        //------------------------------------------------------
 
        #region Private Methods
 
        private void ValidateCollectionChangedEventArgs(NotifyCollectionChangedEventArgs e) 
        {
 
            switch (e.Action)
            {
                case NotifyCollectionChangedAction.Add:
                    if (e.NewItems.Count != 1) 
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported));
                    break; 
 
                case NotifyCollectionChangedAction.Remove:
                    if (e.OldItems.Count != 1) 
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported));
                    break;

                case NotifyCollectionChangedAction.Replace: 
                    if (e.NewItems.Count != 1 || e.OldItems.Count != 1)
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported)); 
                    break; 

                case NotifyCollectionChangedAction.Move: 
                    if (e.NewItems.Count != 1)
                        throw new NotSupportedException(SR.Get(SRID.RangeActionsNotSupported));
                    if (e.NewStartingIndex < 0)
                        throw new InvalidOperationException(SR.Get(SRID.CannotMoveToUnknownPosition)); 
                    break;
 
                case NotifyCollectionChangedAction.Reset: 
                    break;
 
                default:
                    throw new NotSupportedException(SR.Get(SRID.UnexpectedCollectionChangeAction, e.Action));
            }
        } 

 
        ///  
        /// Create, filter and sort the local index array.
        /// called from Refresh(), override in derived classes as needed. 
        /// 
        /// new ILIst to associate this view with
        /// new local array to use for this view
        private IList PrepareLocalArray(IList list) 
        {
            if (list == null) 
                throw new ArgumentNullException("list"); 

            // filter the collection's array into the local array 
            ArrayList al;

            if (ActiveFilter == null)
            { 
                al = new ArrayList(list);
 
                if (IsAddingNew) 
                {
                    al.RemoveAt(_newItemIndex); 
                }
            }
            else
            { 
                al = new ArrayList(list.Count);       //
                for (int k = 0; k < list.Count; ++k) 
                { 
                    if (ActiveFilter(list[k]) && !(IsAddingNew && k == _newItemIndex))
                        al.Add(list[k]); 
                }
            }

            // sort the local array 
            if (ActiveComparer != null)
            { 
                al.Sort(ActiveComparer); 
            }
 
            return al;
        }

        private void MoveCurrencyOffDeletedElement(int oldCurrentPosition) 
        {
            int lastPosition = InternalCount - 1;   // OK if last is -1 
            // if position falls beyond last position, move back to last position 
            int newPosition = (oldCurrentPosition < lastPosition) ? oldCurrentPosition : lastPosition;
 
            // reset this to false before raising events to avoid problems in re-entrancy
            _currentElementWasRemoved = false;

            OnCurrentChanging(); 

            if (newPosition < 0) 
                SetCurrent(null, newPosition); 
            else
                SetCurrent(InternalItemAt(newPosition), newPosition); 

            OnCurrentChanged();
        }
 
        // Convert the collection's index to an index into the view.
        // Return -1 if the index is unknown or moot (Reset events). 
        // Return -2 if the event doesn't apply to this view. 
        private int AdjustBefore (NotifyCollectionChangedAction action, object item, int index)
        { 
            // index is not relevant to Reset events
            if (action == NotifyCollectionChangedAction.Reset)
                return -1;
 
            if (item == NewItemPlaceholder)
            { 
                return (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) 
                        ? 0 : InternalCount - 1;
            } 
            else if (IsAddingNew && NewItemPlaceholderPosition != NewItemPlaceholderPosition.None &&
                        Object.Equals(item, _newItem))
            {
                // we should only get here when removing the AddNew item - i.e. from CancelNew - 
                // and only when the placeholder is active.
                // In that case the item's index in the view is 1 when the placeholder 
                // is AtBeginning, and just before the placeholder when it's AtEnd. 
                // The numerical value for the latter case dependds on whether there's
                // a sort/filter or not, i.e. whether we're using a local array.  That's 
                // because the item has already been removed from the collection, but
                // not from the local array.  (DDB 201860)
                return (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning)
                        ? 1 : UsesLocalArray ? InternalCount - 2 : index; 
            }
 
            int delta = IsGrouping ? 0 : 
                        (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning)
                        ? (IsAddingNew ? 2 : 1) : 0; 
            IList ilFull = (UpdatedOutsideDispatcher ? ShadowCollection : SourceCollection) as IList;

            // validate input
            if (index < -1 || index > ilFull.Count) 
                throw new InvalidOperationException(SR.Get(SRID.CollectionChangeIndexOutOfRange, index, ilFull.Count));
 
            if (action == NotifyCollectionChangedAction.Add) 
            {
                if (index >= 0) 
                {
                    if (!Object.Equals(item, ilFull[index]))
                        throw new InvalidOperationException(SR.Get(SRID.AddedItemNotAtIndex, index));
                } 
                else
                { 
                    // event didn't specify index - determine it the hard way 
                    index = ilFull.IndexOf(item);
                    if (index < 0) 
                        throw new InvalidOperationException(SR.Get(SRID.AddedItemNotInCollection));
                }
            }
 
            // if there's no sort or filter, use the index into the full array
            if (!UsesLocalArray) 
            { 
                if (IsAddingNew)
                { 
                    if (index > _newItemIndex)
                    {
                        --index;        // the new item has been artificially moved elsewhere
                    } 
                }
 
                return index + delta; 
            }
 
            if (action == NotifyCollectionChangedAction.Add)
            {
                // if the item isn't in the filter, return -2
                if (!this.PassesFilter(item)) 
                    return -2;
 
                // search the local array.  If there's no sort order, use the index 
                // in the full array as the sort key.
                IComparer comparer = (ActiveComparer != null) ? ActiveComparer 
                                        : new ListOrdinalComparer(ilFull, item, index);
                ArrayList al = InternalList as ArrayList;
                if (al != null)
                { 
                    index = al.BinarySearch(item, comparer);
                    if (index < 0) 
                        index = ~index; 
                }
                else 
                {
                    index = -1;
                }
            } 
            else if (action == NotifyCollectionChangedAction.Remove)
            { 
                if (!IsAddingNew || item != _newItem) 
                {
                    // a deleted item should already be in the local array 
                    index = InternalList.IndexOf(item);

                    // but may not be, if it was already filtered out (can't use
                    // PassesFilter here, because the item could have changed 
                    // while it was out of our sight)
                    if (index < 0) 
                        return -2; 
                }
                else 
                {
                    // the new item is in a special position
                    switch (NewItemPlaceholderPosition)
                    { 
                        case NewItemPlaceholderPosition.None:
                            return InternalCount - 1; 
                        case NewItemPlaceholderPosition.AtBeginning: 
                            return 1;
                        case NewItemPlaceholderPosition.AtEnd: 
                            return InternalCount - 2;
                    }
                }
            } 
            else
            { 
                index = -1; 
            }
 
            return (index < 0 ) ? index : index + delta;
        }

        // fix up CurrentPosition and CurrentItem after a collection change 
        private void AdjustCurrencyForAdd(int index)
        { 
            if (InternalCount == 1) 
            {
                // added first item; set current at BeforeFirst 
                SetCurrent(null, -1);
            }
            else if (index <= CurrentPosition)  // adjust current index if insertion is earlier
            { 
                int newPosition = CurrentPosition + 1;
                if (newPosition < InternalCount) 
                { 
                    // CurrentItem might be out of [....] if underlying list is not INCC
                    // or if this Add is the result of a Replace (Rem + Add) 
                    SetCurrent(GetItemAt(newPosition), newPosition);
                }
                else
                { 
                    SetCurrent(null, InternalCount);
                } 
            } 
        }
 
        // fix up CurrentPosition and CurrentItem after a collection change
        private void AdjustCurrencyForRemove(int index)
        {
            // adjust current index if deletion is earlier 
            if (index < CurrentPosition)
            { 
                SetCurrent(CurrentItem, CurrentPosition - 1); 
            }
            // remember to move currency off the deleted element 
            else if (index == CurrentPosition)
            {
                _currentElementWasRemoved = true;
            } 
        }
 
        // fix up CurrentPosition and CurrentItem after a collection change 
        private void AdjustCurrencyForMove(int oldIndex, int newIndex)
        { 
            if (oldIndex == CurrentPosition)
            {
                // moving the current item - currency moves with the item (bug 1942184)
                SetCurrent(GetItemAt(newIndex), newIndex); 
            }
            else if (oldIndex < CurrentPosition && CurrentPosition <= newIndex) 
            { 
                // moving an item from before current position to after -
                // current item shifts back one position 
                SetCurrent(CurrentItem, CurrentPosition - 1);
            }
            else if (newIndex <= CurrentPosition && CurrentPosition < oldIndex)
            { 
                // moving an item from after current position to before -
                // current item shifts ahead one position 
                SetCurrent(CurrentItem, CurrentPosition + 1); 
            }
            // else no change necessary 
        }

        // fix up CurrentPosition and CurrentItem after a collection change
        private void AdjustCurrencyForReplace(int index) 
        {
            // remember to move currency off the deleted element 
            if (index == CurrentPosition) 
            {
                _currentElementWasRemoved = true; 
            }
        }

        // build the sort and filter information from the relevant properties 
        private void PrepareSortAndFilter(IList list)
        { 
            // sort:  prepare the comparer 
            if (_customSort != null)
            { 
                ActiveComparer = _customSort;
            }
            else if (_sort != null && _sort.Count > 0)
            { 
                // test for Xml in a way that doesn't load System.Xml unless we really need it
                string name = SourceCollection.GetType().Name; 
                if (name == "XmlDataCollection") 
                {
                    PrepareXmlComparer(); 
                }
                else
                {
                    ActiveComparer = new SortFieldComparer(_sort, Culture); 
                }
            } 
            else 
            {
                ActiveComparer = null; 
            }

            // filter:  prepare the Predicate filter
            ActiveFilter = Filter; 
        }
 
        // set up the Xml comparer - code is isolated here to avoid loading System.Xml 
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]
        private void PrepareXmlComparer() 
        {
            XmlDataCollection xdc = SourceCollection as XmlDataCollection;
            Invariant.Assert(_sort != null);
            ActiveComparer = new XmlNodeComparer(_sort, xdc.XmlNamespaceManager, Culture); 
        }
 
        // set new SortDescription collection; rehook collection change notification handler 
        private void SetSortDescriptions(SortDescriptionCollection descriptions)
        { 
            if (_sort != null)
            {
                ((INotifyCollectionChanged)_sort).CollectionChanged -= new NotifyCollectionChangedEventHandler(SortDescriptionsChanged);
            } 

            _sort = descriptions; 
 
            if (_sort != null)
            { 
                Invariant.Assert(_sort.Count == 0, "must be empty SortDescription collection");
                ((INotifyCollectionChanged)_sort).CollectionChanged += new NotifyCollectionChangedEventHandler(SortDescriptionsChanged);
            }
        } 

        // SortDescription was added/removed, refresh CollectionView 
        private void SortDescriptionsChanged(object sender, NotifyCollectionChangedEventArgs e) 
        {
            if (IsAddingNew || IsEditingItem) 
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Sorting"));

            // adding to SortDescriptions overrides custom sort
            if (_sort.Count > 0) 
            {
                _customSort = null; 
            } 

            RefreshOrDefer(); 
        }

        #region Grouping
 
        // divide the data items into groups
        void PrepareGroups() 
        { 
            // discard old groups
            _group.Clear(); 

            // initialize the synthetic top level group
            _group.Initialize();
 
            // if there's no grouping, there's nothing to do
            _isGrouping = (_group.GroupBy != null); 
            if (!_isGrouping) 
                return;
 
            // loop through the sorted/filtered list of items, dividing them
            // into groups (with special cases for placeholder and new item)
            if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning)
            { 
                _group.InsertSpecialItem(0, NewItemPlaceholder, true /*loading*/);
                if (IsAddingNew) 
                { 
                    _group.InsertSpecialItem(1, _newItem, true /*loading*/);
                } 
            }

            for (int k=0, n=InternalList.Count;  k 
        /// Helper to raise a PropertyChanged event  />).
        ///  
        private void OnPropertyChanged(string propertyName)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        } 

        //----------------------------------------------------- 
        private class ListOrdinalComparer : IComparer 
        {
            IList _ilFull; 
            object _item;
            int _index;

            internal ListOrdinalComparer(IList ilFull, object item, int index) 
            {
                _ilFull = ilFull; 
                _item = item; 
                _index = index;
            } 

            // IComparer
            public int Compare(object o1, object o2)
            { 
                int i1 = Object.Equals(o1, _item) ? _index : _ilFull.IndexOf(o1);
                int i2 = Object.Equals(o2, _item) ? _index : _ilFull.IndexOf(o2); 
                return (i1 - i2); 
            }
        } 

        #endregion Private Methods

 

        //----------------------------------------------------- 
        // 
        //  Private Fields
        // 
        //-----------------------------------------------------

        #region Private Fields
 
        private IList               _internalList;
        private CollectionViewGroupRoot _group; 
        private bool                _isGrouping; 
        private IComparer           _activeComparer;
        private Predicate   _activeFilter; 
        private SortDescriptionCollection  _sort;
        private IComparer           _customSort;
        private ArrayList           _shadowCollection;
        private bool                _applyChangeToShadow = false; 
        private bool                _currentElementWasRemoved;  // true if we need to MoveCurrencyOffDeletedElement
        private object              _newItem; 
        private object              _editItem; 
        private int                 _newItemIndex;  // position _newItem in the source collection
        private NewItemPlaceholderPosition _newItemPlaceholderPosition; 
        private bool                _isItemConstructorValid;
        private ConstructorInfo     _itemConstructor;

        private const int           _unknownIndex = -1; 

        #endregion Private Fields 
    } 

    ///  
    /// A delegate to select the group description as a function of the
    /// parent group and its level.
    /// 
    public delegate GroupDescription GroupDescriptionSelectorCallback(CollectionViewGroup group, int level); 

} 
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

                        

                        

                        
                        
                    
                    

                        
Link Menu

                        
                            Network programming in C#, Network Programming in VB.NET, Network Programming in .NET

                        

                            This book is available now!


                             Buy at Amazon US or 


                             Buy at Amazon UK