File: src\Framework\System\Windows\Data\ListCollectionView.cs
Project: wpf\PresentationFramework.csproj (PresentationFramework)
//---------------------------------------------------------------------------
//
// <copyright file="ListCollectionView.cs" company="Microsoft">
//    Copyright (C) 2003 by Microsoft Corporation.  All rights reserved.
// </copyright>
//
//
// Description: ICollectionView for collections implementing IList
//
// See spec at http://avalon/connecteddata/Specs/CollectionView.mht
//
// History:
//  06/02/2003 : Microsoft   - 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 System.Windows.Threading;
 
using MS.Internal;
using MS.Internal.Data;
using MS.Utility;
 
namespace System.Windows.Data
{
    ///<summary>
    /// <seealso cref="ICollectionView"/> based on and associated to <seealso cref="IList"/>.
    ///</summary>
    public class ListCollectionView : CollectionView, IComparer, IEditableCollectionViewAddNewItem, ICollectionViewLiveShaping, IItemProperties
    {
        //------------------------------------------------------
        //
        //  Constructors
        //
        //------------------------------------------------------
 
        #region Constructors
 
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="list">Underlying IList</param>
        public ListCollectionView(IList list)
            : base(list)
        {
            if (AllowsCrossThreadChanges)
            {
                BindingOperations.AccessCollection(list,
                    () =>
                    {
                        ClearPendingChanges();
                        ShadowCollection = new ArrayList((ICollection)SourceCollection);
                        _internalList = ShadowCollection;
                    },
                    false);
            }
            else
            {
                _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
 
        /// <summary>
        /// Re-create the view over the associated IList
        /// </summary>
        /// <remarks>
        /// Any sorting and filtering will take effect during Refresh.
        /// </remarks>
        protected override void RefreshOverride()
        {
            if (AllowsCrossThreadChanges)
            {
                BindingOperations.AccessCollection(SourceCollection,
                    () =>
                    {
                        lock(SyncRoot)
                        {
                            ClearPendingChanges();
                            ShadowCollection = new ArrayList((ICollection)SourceCollection);
                        }
                    },
                    false);
            }
 
            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();
 
            PrepareLocalArray();
 
            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);
 
        }
 
        /// <summary>
        /// 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.
        /// </summary>
        public override bool Contains(object item)
        {
            VerifyRefreshNotDeferred();
 
            return InternalContains(item);
        }
 
        /// <summary>
        /// Move <seealso cref="CollectionView.CurrentItem"/> to the item at the given index.
        /// </summary>
        /// <param name="position">Move CurrentItem to this index</param>
        /// <returns>true if <seealso cref="CollectionView.CurrentItem"/> points to an item within the view.</returns>
        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;
        }
 
        /// <summary>
        /// Returns true if this view really supports grouping.
        /// When this returns false, the rest of the interface is ignored.
        /// </summary>
        public override bool CanGroup
        {
            get { return true; }
        }
 
        /// <summary>
        /// The description of grouping, indexed by level.
        /// </summary>
        public override ObservableCollection<GroupDescription> GroupDescriptions
        {
            get { return _group.GroupDescriptions; }
        }
 
        /// <summary>
        /// The top-level groups, constructed according to the descriptions
        /// given in GroupDescriptions and/or GroupBySelector.
        /// </summary>
        public override ReadOnlyObservableCollection<object> Groups
        {
            get { return (IsGrouping) ? _group.Items : null; }
        }
 
        #endregion ICollectionView
 
 
        /// <summary>
        /// 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.
        /// </summary>
        public override bool PassesFilter(object item)
        {
            return ActiveFilter == null || ActiveFilter(item);
        }
 
        /// <summary> Return the index where the given item belongs, or -1 if this index is unknown.
        /// </summary>
        /// <remarks>
        /// If this method returns an index other than -1, it must always be true that
        /// view[index-1] &lt; item &lt;= 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.)
        /// </remarks>
        /// <param name="item">data item</param>
        public override int IndexOf(object item)
        {
            VerifyRefreshNotDeferred();
 
            return InternalIndexOf(item);
        }
 
        /// <summary>
        /// Retrieve item at the given zero-based index in this CollectionView.
        /// </summary>
        /// <remarks>
        /// <p>The index is evaluated with any SortDescriptions or Filter being set on this CollectionView.</p>
        /// </remarks>
        /// <exception cref="ArgumentOutOfRangeException">
        /// Thrown if index is out of range
        /// </exception>
        public override object GetItemAt(int index)
        {
            VerifyRefreshNotDeferred();
 
            return InternalItemAt(index);
        }
 
 
        //------------------------------------------------------
        #region IComparer
 
        /// <summary> Return -, 0, or +, according to whether o1 occurs before, at, or after o2 (respectively)
        /// </summary>
        /// <param name="o1">first object</param>
        /// <param name="o2">second object</param>
        /// <remarks>
        /// Compares items by their resp. index in the IList.
        /// </remarks>
        int IComparer.Compare(object o1, object o2)
        {
            return Compare(o1, o2);
        }
 
        /// <summary> Return -, 0, or +, according to whether o1 occurs before, at, or after o2 (respectively)
        /// </summary>
        /// <param name="o1">first object</param>
        /// <param name="o2">second object</param>
        /// <remarks>
        /// Compares items by their resp. index in the IList.
        /// </remarks>
        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
 
        /// <summary>
        /// Implementation of IEnumerable.GetEnumerator().
        /// This provides a way to enumerate the members of the collection
        /// without changing the currency.
        /// </summary>
        protected override IEnumerator GetEnumerator()
        {
            VerifyRefreshNotDeferred();
 
            return InternalGetEnumerator();
        }
 
        #endregion Public Methods
 
 
        //------------------------------------------------------
        //
        //  Public Properties
        //
        //------------------------------------------------------
 
        #region Public Properties
 
        //------------------------------------------------------
        #region ICollectionView
 
        /// <summary>
        /// Collection of Sort criteria to sort items in this view over the SourceCollection.
        /// </summary>
        /// <remarks>
        /// <p>
        /// One or more sort criteria in form of <seealso cref="SortDescription"/>
        /// can be added, each specifying a property and direction to sort by.
        /// </p>
        /// </remarks>
        public override SortDescriptionCollection SortDescriptions
        {
            get
            {
                if (_sort == null)
                    SetSortDescriptions(new SortDescriptionCollection());
                return _sort;
            }
        }
 
        /// <summary>
        /// Test if this ICollectionView supports sorting before adding
        /// to <seealso cref="SortDescriptions"/>.
        /// </summary>
        /// <remarks>
        /// ListCollectionView does implement an IComparer based sorting.
        /// </remarks>
        public override bool CanSort
        {
            get { return true; }
        }
 
        /// <summary>
        /// Test if this ICollectionView supports filtering before assigning
        /// a filter callback to <seealso cref="Filter"/>.
        /// </summary>
        public override bool CanFilter
        {
            get { return true; }
        }
 
        /// <summary>
        /// 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.
        /// </summary>
        /// <exception cref="NotSupportedException">
        /// Simpler implementations do not support filtering and will throw a NotSupportedException.
        /// Use <seealso cref="CanFilter"/> property to test if filtering is supported before
        /// assigning a non-null value.
        /// </exception>
        public override Predicate<object> Filter
        {
            get
            {
                return base.Filter;
            }
            set
            {
                if (AllowsCrossThreadChanges)
                    VerifyAccess();
                if (IsAddingNew || IsEditingItem)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Filter"));
 
                base.Filter = value;
            }
        }
 
        #endregion ICollectionView
 
        /// <summary>
        /// Set a custom comparer to sort items using an object that implements IComparer.
        /// </summary>
        /// <remarks>
        /// Setting the Sort criteria has no immediate effect,
        /// an explicit <seealso cref="CollectionView.Refresh"/> call by the app is required.
        /// Note: Setting the custom comparer object will clear previously set <seealso cref="CollectionView.SortDescriptions"/>.
        /// </remarks>
        public IComparer CustomSort
        {
            get { return _customSort; }
            set
            {
                if (AllowsCrossThreadChanges)
                    VerifyAccess();
                if (IsAddingNew || IsEditingItem)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "CustomSort"));
                _customSort = value;
 
                SetSortDescriptions(null);
 
                RefreshOrDefer();
            }
        }
 
        /// <summary>
        /// A delegate to select the group description as a function of the
        /// parent group and its level.
        /// </summary>
        [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();
            }
        }
 
        /// <summary>
        /// Return the estimated number of records (or -1, meaning "don't know").
        /// </summary>
        public override int Count
        {
            get
            {
                VerifyRefreshNotDeferred();
 
                return InternalCount;
            }
        }
 
        /// <summary>
        /// Returns true if the resulting (filtered) view is emtpy.
        /// </summary>
        public override bool IsEmpty
        {
            get { return (InternalCount == 0); }
        }
 
        /// <summary>
        /// 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.
        /// </summary>
        public bool IsDataInGroupOrder
        {
            get { return _group.IsDataInGroupOrder; }
            set { _group.IsDataInGroupOrder = value; }
        }
 
        #endregion Public Properties
 
        #region IEditableCollectionView
 
        #region Adding new items
 
        /// <summary>
        /// Indicates whether to include a placeholder for a new item, and if so,
        /// where to put it.
        /// </summary>
        public NewItemPlaceholderPosition NewItemPlaceholderPosition
        {
            get { return _newItemPlaceholderPosition; }
            set
            {
                VerifyRefreshNotDeferred();
 
                if (value != _newItemPlaceholderPosition && IsAddingNew)
                    throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "NewItemPlaceholderPosition", "AddNew"));
 
                if (value != _newItemPlaceholderPosition && _isRemoving)
                {
                    DeferAction(() => { NewItemPlaceholderPosition = value; });
                    return;
                }
 
                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");
                }
            }
        }
 
        /// <summary>
        /// Return true if the view supports <seealso cref="AddNew"/>.
        /// </summary>
        public bool CanAddNew
        {
            get { return !IsEditingItem && !SourceList.IsFixedSize && CanConstructItem; }
        }
 
        /// <summary>
        /// Return true if the view supports <seealso cref="AddNewItem"/>.
        /// </summary>
        public bool CanAddNewItem
        {
            get { return !IsEditingItem && !SourceList.IsFixedSize; }
        }
 
        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;
                }
            }
        }
 
        /// <summary>
        /// Add a new item to the underlying collection.  Returns the new item.
        /// After calling AddNew and changing the new item as desired, either
        /// <seealso cref="CommitNew"/> or <seealso cref="CancelNew"/> should be
        /// called to complete the transaction.
        /// </summary>
        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"));
 
            return AddNewCommon(_itemConstructor.Invoke(null));
        }
 
        /// <summary>
        /// Add a new item to the underlying collection.  Returns the new item.
        /// After calling AddNewItem and changing the new item as desired, either
        /// <seealso cref="CommitNew"/> or <seealso cref="CancelNew"/> should be
        /// called to complete the transaction.
        /// </summary>
        public object AddNewItem(object newItem)
        {
            VerifyRefreshNotDeferred();
 
            if (IsEditingItem)
            {
                CommitEdit();   // implicitly close a previous EditItem
            }
 
            CommitNew();        // implicitly close a previous AddNew
 
            if (!CanAddNewItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedForView, "AddNewItem"));
 
            return AddNewCommon(newItem);
        }
 
        object AddNewCommon(object newItem)
        {
            BindingOperations.AccessCollection(SourceList,
                () =>
                {
                    ProcessPendingChanges();    // bring the shadow list up to date
 
                    _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 (!System.Windows.Controls.ItemsControl.EqualsEx(newItem, SourceList[index]))
                        {
                            index = SourceList.IndexOf(newItem);
                        }
 
                        BeginAddNew(newItem, index);
                    }
                },
                true);
 
            Debug.Assert(_newItemIndex != -2 && System.Windows.Controls.ItemsControl.EqualsEx(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 == NoNewItem, "unexpected call to BeginAddNew");
 
            // remember the new item and its position in the underlying list
            SetNewItem(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);
        }
 
        /// <summary>
        /// Complete the transaction started by <seealso cref="AddNew"/>.  The new
        /// item remains in the collection, and the view's sort, filter, and grouping
        /// specifications (if any) are applied to the new item.
        /// </summary>
        public void CommitNew()
        {
            if (IsEditingItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CommitNew", "EditItem"));
            VerifyRefreshNotDeferred();
 
            if (_newItem == NoNewItem)
                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));
        }
 
        /// <summary>
        /// Complete the transaction started by <seealso cref="AddNew"/>.  The new
        /// item is removed from the collection.
        /// </summary>
        public void CancelNew()
        {
            if (IsEditingItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CancelNew", "EditItem"));
            VerifyRefreshNotDeferred();
 
            if (_newItem == NoNewItem)
                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.
            BindingOperations.AccessCollection(SourceList,
                () =>
                {
                    ProcessPendingChanges();
                    SourceList.RemoveAt(_newItemIndex);
 
                    // if the collection doesn't raise events, do the work explicitly on its behalf
                    if (_newItem != NoNewItem)
                    {
                        int index = AdjustBefore(NotifyCollectionChangedAction.Remove, _newItem, _newItemIndex);
                        object newItem = EndAddNew(true);
 
                        ProcessCollectionChangedWithAdjustedIndex(
                                    new NotifyCollectionChangedEventArgs(
                                                        NotifyCollectionChangedAction.Remove,
                                                        newItem,
                                                        index),
                                    index, -1);
                    }
                },
                true);
        }
 
        // Common functionality used by CommitNew, CancelNew, and when the
        // new item is removed by Remove or Refresh.
        object EndAddNew(bool cancel)
        {
            object newItem = _newItem;
 
            SetNewItem(NoNewItem);  // 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;
        }
 
        /// <summary>
        /// Returns true if an </seealso cref="AddNew"> transaction is in progress.
        /// </summary>
        public bool IsAddingNew
        {
            get { return (_newItem != NoNewItem); }
        }
 
        /// <summary>
        /// When an </seealso cref="AddNew"> transaction is in progress, this property
        /// returns the new item.  Otherwise it returns null.
        /// </summary>
        public object CurrentAddItem
        {
            get { return IsAddingNew ? _newItem : null; }
        }
 
        void SetNewItem(object item)
        {
            if (!System.Windows.Controls.ItemsControl.EqualsEx(item, _newItem))
            {
                _newItem = item;
 
                OnPropertyChanged("CurrentAddItem");
                OnPropertyChanged("IsAddingNew");
                OnPropertyChanged("CanRemove");
            }
        }
 
        #endregion Adding new items
 
        #region Removing items
 
        /// <summary>
        /// Return true if the view supports <seealso cref="Remove"/> and
        /// <seealso cref="RemoveAt"/>.
        /// </summary>
        public bool CanRemove
        {
            get { return !IsEditingItem && !IsAddingNew && !SourceList.IsFixedSize; }
        }
 
        /// <summary>
        /// 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).
        /// </summary>
        public void RemoveAt(int index)
        {
            if (IsEditingItem || IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "RemoveAt"));
            VerifyRefreshNotDeferred();
 
            RemoveImpl(GetItemAt(index), index);
        }
 
        /// <summary>
        /// Remove the given item from the underlying collection.
        /// </summary>
        public void Remove(object item)
        {
            if (IsEditingItem || IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Remove"));
            VerifyRefreshNotDeferred();
 
            int index = InternalIndexOf(item);
            if (index >= 0)
            {
                RemoveImpl(item, index);
            }
        }
 
        void RemoveImpl(object item, int index)
        {
            if (item == CollectionView.NewItemPlaceholder)
                throw new InvalidOperationException(SR.Get(SRID.RemovingPlaceholder));
 
            BindingOperations.AccessCollection(SourceList,
                () =>
                {
                    ProcessPendingChanges();
 
                    // the pending changes may have moved (or even removed) the
                    // item.   Verify the index.
                    if (index >= InternalCount || !System.Windows.Controls.ItemsControl.EqualsEx(item, GetItemAt(index)))
                    {
                        index = InternalIndexOf(item);
                        if (index < 0)
                            return;
                    }
 
                    // convert the index from "view-relative" to "list-relative"
                    int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ? 1 : 0;
 
                    int listIndex = index - delta;
                    bool raiseEvent = !(SourceList is INotifyCollectionChanged);
 
                    // remove the item from the list
                    try
                    {
                        _isRemoving = true;
                        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));
                        }
                    }
                    finally
                    {
                        _isRemoving = false;
                        DoDeferredActions();
                    }
                },
                true);
        }
 
        #endregion Removing items
 
        #region Transactional editing of an item
 
        /// <summary>
        /// Begins an editing transaction on the given item.  The transaction is
        /// completed by calling either <seealso cref="CommitEdit"/> or
        /// <seealso cref="CancelEdit"/>.  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.
        /// </summary>
        public void EditItem(object item)
        {
            VerifyRefreshNotDeferred();
 
            if (item == NewItemPlaceholder)
                throw new ArgumentException(SR.Get(SRID.CannotEditPlaceholder), "item");
 
            if (IsAddingNew)
            {
                if (System.Windows.Controls.ItemsControl.EqualsEx(item, _newItem))
                    return;     // EditItem(newItem) is a no-op
 
                CommitNew();    // implicitly close a previous AddNew
            }
 
            CommitEdit();   // implicitly close a previous EditItem transaction
 
            SetEditItem(item);
 
            IEditableObject ieo = item as IEditableObject;
            if (ieo != null)
            {
                ieo.BeginEdit();
            }
        }
 
        /// <summary>
        /// Complete the transaction started by <seealso cref="EditItem"/>.
        /// The pending changes (if any) to the item are committed.
        /// </summary>
        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;
            SetEditItem(null);
 
            if (ieo != null)
            {
                ieo.EndEdit();
            }
 
            // see if the item is entering or leaving the view
            int fromIndex = InternalIndexOf(editItem);
            bool wasInView = (fromIndex >= 0);
            bool isInView = wasInView ? PassesFilter(editItem)
                                    : SourceList.Contains(editItem) && PassesFilter(editItem);
 
            // 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)
            {
                if (wasInView)
                {
                    RemoveItemFromGroups(editItem);
                }
                if (isInView)
                {
                    LiveShapingList lsList = InternalList as LiveShapingList;
                    LiveShapingItem lsi = (lsList == null) ? null : lsList.ItemAt(lsList.IndexOf(editItem));
                    AddItemToGroups(editItem, lsi);
                }
                return;
            }
 
            // the edit may cause the item to move.  If so, report it.
            if (UsesLocalArray)
            {
                IList list = InternalList;
                int delta = (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning) ? 1 : 0;
                int toIndex = -1;
 
                if (wasInView)
                {
                    if (!isInView)
                    {
                        // the item has been effectively removed
                        ProcessCollectionChangedWithAdjustedIndex(
                                    new NotifyCollectionChangedEventArgs(
                                                        NotifyCollectionChangedAction.Remove,
                                                        editItem,
                                                        fromIndex),
                                    fromIndex, -1);
                    }
                    else if (ActiveComparer != null)
                    {
                        // the item may have moved within the view
                        int localIndex = fromIndex - delta;
                        if (localIndex > 0 && ActiveComparer.Compare(list[localIndex-1], editItem) > 0)
                        {
                            // the item has moved toward the front of the list
                            toIndex = list.Search(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.Search(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);
                        }
                    }
                }
                else if (isInView)
                {
                    // the item has effectively been added
                    toIndex = AdjustBefore(NotifyCollectionChangedAction.Add, editItem, SourceList.IndexOf(editItem));
                    ProcessCollectionChangedWithAdjustedIndex(
                                new NotifyCollectionChangedEventArgs(
                                            NotifyCollectionChangedAction.Add,
                                            editItem,
                                            toIndex+delta),
                                -1, toIndex+delta);
                }
            }
        }
 
        /// <summary>
        /// Complete the transaction started by <seealso cref="EditItem"/>.
        /// The pending changes (if any) to the item are discarded.
        /// </summary>
        public void CancelEdit()
        {
            if (IsAddingNew)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringTransaction, "CancelEdit", "AddNew"));
            VerifyRefreshNotDeferred();
 
            if (_editItem == null)
                return;
 
            IEditableObject ieo = _editItem as IEditableObject;
            SetEditItem(null);
 
            if (ieo != null)
            {
                ieo.CancelEdit();
            }
            else
                throw new InvalidOperationException(SR.Get(SRID.CancelEditNotSupported));
        }
 
        private void ImplicitlyCancelEdit()
        {
            IEditableObject ieo = _editItem as IEditableObject;
            SetEditItem(null);
 
            if (ieo != null)
            {
                ieo.CancelEdit();
            }
        }
 
        /// <summary>
        /// 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 <seealso cref="IEditableObject"/>, or if the view has special
        /// knowledge about the item that it can use to support rollback of pending
        /// changes.
        /// </summary>
        public bool CanCancelEdit
        {
            get { return (_editItem is IEditableObject); }
        }
 
        /// <summary>
        /// Returns true if an </seealso cref="EditItem"> transaction is in progress.
        /// </summary>
        public bool IsEditingItem
        {
            get { return (_editItem != null); }
        }
 
        /// <summary>
        /// When an </seealso cref="EditItem"> transaction is in progress, this property
        /// returns the affected item.  Otherwise it returns null.
        /// </summary>
        public object CurrentEditItem
        {
            get { return _editItem; }
        }
 
        void SetEditItem(object item)
        {
            if (!System.Windows.Controls.ItemsControl.EqualsEx(item, _editItem))
            {
                _editItem = item;
 
                OnPropertyChanged("CurrentEditItem");
                OnPropertyChanged("IsEditingItem");
                OnPropertyChanged("CanCancelEdit");
                OnPropertyChanged("CanAddNew");
                OnPropertyChanged("CanAddNewItem");
                OnPropertyChanged("CanRemove");
            }
        }
 
        #endregion Transactional editing of an item
 
        #endregion IEditableCollectionView
 
        #region ICollectionViewLiveShaping
 
        ///<summary>
        /// Gets a value that indicates whether this view supports turning live sorting on or off.
        ///</summary>
        public bool CanChangeLiveSorting
        { get { return true; } }
 
        ///<summary>
        /// Gets a value that indicates whether this view supports turning live filtering on or off.
        ///</summary>
        public bool CanChangeLiveFiltering
        { get { return true; } }
 
        ///<summary>
        /// Gets a value that indicates whether this view supports turning live grouping on or off.
        ///</summary>
        public bool CanChangeLiveGrouping
        { get { return true; } }
 
 
        ///<summary>
        /// Gets or sets a value that indicates whether live sorting is enabled.
        /// The value may be null if the view does not know whether live sorting is enabled.
        /// Calling the setter when CanChangeLiveSorting is false will throw an
        /// InvalidOperationException.
        ///</summary
        public bool? IsLiveSorting
        {
            get { return _isLiveSorting; }
            set
            {
                if (value == null)
                    throw new ArgumentNullException("value");
 
                if (value != _isLiveSorting)
                {
                    _isLiveSorting = value;
                    RebuildLocalArray();
 
                    OnPropertyChanged("IsLiveSorting");
                }
            }
        }
 
        ///<summary>
        /// Gets or sets a value that indicates whether live filtering is enabled.
        /// The value may be null if the view does not know whether live filtering is enabled.
        /// Calling the setter when CanChangeLiveFiltering is false will throw an
        /// InvalidOperationException.
        ///</summary>
        public bool? IsLiveFiltering
        {
            get { return _isLiveFiltering; }
            set
            {
                if (value == null)
                    throw new ArgumentNullException("value");
 
                if (value != _isLiveFiltering)
                {
                    _isLiveFiltering = value;
                    RebuildLocalArray();
 
                    OnPropertyChanged("IsLiveFiltering");
                }
            }
        }
 
        ///<summary>
        /// Gets or sets a value that indicates whether live grouping is enabled.
        /// The value may be null if the view does not know whether live grouping is enabled.
        /// Calling the setter when CanChangeLiveGrouping is false will throw an
        /// InvalidOperationException.
        ///</summary>
        public bool? IsLiveGrouping
        {
            get { return _isLiveGrouping; }
            set
            {
                if (value == null)
                    throw new ArgumentNullException("value");
 
                if (value != _isLiveGrouping)
                {
                    _isLiveGrouping = value;
                    RebuildLocalArray();
 
                    OnPropertyChanged("IsLiveGrouping");
                }
            }
        }
 
        bool IsLiveShaping
        {
            get { return (IsLiveSorting==true) || (IsLiveFiltering==true) || (IsLiveGrouping==true); }
        }
 
        ///<summary>
        /// Gets a collection of strings describing the properties that
        /// trigger a live-sorting recalculation.
        /// The strings use the same format as SortDescription.PropertyName.
        ///</summary>
        ///<notes>
        /// When the underlying view implements ICollectionViewLiveShaping,
        /// this collection is used to set the underlying view's LiveSortingProperties.
        /// When this collection is empty, the view will use the PropertyName strings
        /// from its SortDescriptions.
        ///</notes>
        public ObservableCollection<string> LiveSortingProperties
        {
            get
            {
                if (_liveSortingProperties == null)
                {
                    _liveSortingProperties = new ObservableCollection<string>();
                    _liveSortingProperties.CollectionChanged += new NotifyCollectionChangedEventHandler(OnLivePropertyListChanged);
                }
                return _liveSortingProperties;
            }
        }
 
        ///<summary>
        /// Gets a collection of strings describing the properties that
        /// trigger a live-filtering recalculation.
        /// The strings use the same format as SortDescription.PropertyName.
        ///</summary>
        ///<notes>
        /// When the underlying view implements ICollectionViewLiveShaping,
        /// this collection is used to set the underlying view's LiveFilteringProperties.
        ///</notes>
        public ObservableCollection<string> LiveFilteringProperties
        {
            get
            {
                if (_liveFilteringProperties == null)
                {
                    _liveFilteringProperties = new ObservableCollection<string>();
                    _liveFilteringProperties.CollectionChanged += new NotifyCollectionChangedEventHandler(OnLivePropertyListChanged);
                }
                return _liveFilteringProperties;
            }
        }
 
        ///<summary>
        /// Gets a collection of strings describing the properties that
        /// trigger a live-grouping recalculation.
        /// The strings use the same format as PropertyGroupDescription.PropertyName.
        ///</summary>
        ///<notes>
        /// When the underlying view implements ICollectionViewLiveShaping,
        /// this collection is used to set the underlying view's LiveGroupingProperties.
        ///</notes>
        public ObservableCollection<string> LiveGroupingProperties
        {
            get
            {
                if (_liveGroupingProperties == null)
                {
                    _liveGroupingProperties = new ObservableCollection<string>();
                    _liveGroupingProperties.CollectionChanged += new NotifyCollectionChangedEventHandler(OnLivePropertyListChanged);
                }
                return _liveGroupingProperties;
            }
        }
 
        void OnLivePropertyListChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (IsLiveShaping)
            {
                RebuildLocalArray();
            }
        }
 
        #if LiveShapingInstrumentation

        public void ResetComparisons()
        {
            LiveShapingList lsList = InternalList as LiveShapingList;
            if (lsList != null)
            {
                lsList.ResetComparisons();
            }
        }
 
        public void ResetCopies()
        {
            LiveShapingList lsList = InternalList as LiveShapingList;
            if (lsList != null)
            {
                lsList.ResetCopies();
            }
        }
 
        public void ResetAverageCopy()
        {
            LiveShapingList lsList = InternalList as LiveShapingList;
            if (lsList != null)
            {
                lsList.ResetAverageCopy();
            }
        }
 
        public int GetComparisons()
        {
            LiveShapingList lsList = InternalList as LiveShapingList;
            return (lsList != null) ? lsList.GetComparisons() : 0;
        }
 
        public int GetCopies()
        {
            LiveShapingList lsList = InternalList as LiveShapingList;
            return (lsList != null) ? lsList.GetCopies() : 0;
        }
 
        public double GetAverageCopy()
        {
            LiveShapingList lsList = InternalList as LiveShapingList;
            return (lsList != null) ? lsList.GetAverageCopy() : 0.0;
        }
 
        #endif // LiveShapingInstrumentation
 
        #endregion ICollectionViewLiveShaping
 
        #region IItemProperties
 
        /// <summary>
        /// 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.
        /// </summary>
        public ReadOnlyCollection<ItemPropertyInfo> ItemProperties
        {
            get { return GetItemProperties(); }
        }
 
        #endregion IItemProperties
 
 
 
        //------------------------------------------------------
        //
        //  Protected Methods
        //
        //------------------------------------------------------
        #region Protected Methods
 
 
        protected override void OnAllowsCrossThreadChangesChanged()
        {
            if (AllowsCrossThreadChanges)
            {
                BindingOperations.AccessCollection(SourceCollection,
                    () =>
                    {
                        lock(SyncRoot)
                        {
                            ClearPendingChanges();
                            ShadowCollection = new ArrayList((ICollection)SourceCollection);
 
                            if (!UsesLocalArray)
                            {
                                _internalList = ShadowCollection;
                            }
                        }
                    },
                    false);
            }
            else
            {
                ShadowCollection = null;
                if (!UsesLocalArray)
                {
                    _internalList = SourceList;
                }
            }
        }
 
        /// <summary>
        ///     Obsolete.   Retained for compatibility.
        ///     Use OnAllowsCrossThreadChangesChanged instead.
        /// </summary>
        /// <param name="args">
        ///     The NotifyCollectionChangedEventArgs that is added to the change log
        /// </param>
        [Obsolete("Replaced by OnAllowsCrossThreadChangesChanged")]
        protected override void OnBeginChangeLogging(NotifyCollectionChangedEventArgs args)
        {
        }
 
        /// <summary>
        /// Handle CollectionChange events
        /// </summary>
        protected override void ProcessCollectionChanged(NotifyCollectionChangedEventArgs args)
        {
            if (args == null)
                throw new ArgumentNullException("args");
 
            ValidateCollectionChangedEventArgs(args);
 
            // adding or replacing an item can change CanAddNew, by providing a
            // non-null representative
            if (!_isItemConstructorValid)
            {
                switch (args.Action)
                {
                    case NotifyCollectionChangedAction.Reset:
                    case NotifyCollectionChangedAction.Add:
                    case NotifyCollectionChangedAction.Replace:
                        OnPropertyChanged("CanAddNew");
                        break;
                }
            }
 
            int adjustedOldIndex = -1;
            int adjustedNewIndex = -1;
 
            // apply the change to the shadow copy
            if (AllowsCrossThreadChanges)
            {
                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);
                    }
                }
            }
 
            // 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 (IsAddingNew && args.NewStartingIndex <= _newItemIndex)
                    {
                        ++ _newItemIndex;
                    }
                    break;
 
                case NotifyCollectionChangedAction.Remove:
                    if (IsAddingNew && 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 (IsAddingNew)
                    {
                        if (args.OldStartingIndex == _newItemIndex)
                        {
                            _newItemIndex = args.NewStartingIndex;
                        }
                        else if (args.OldStartingIndex < _newItemIndex && _newItemIndex <= args.NewStartingIndex)
                        {
                            -- _newItemIndex;
                        }
                        else if (args.NewStartingIndex <= _newItemIndex && _newItemIndex < args.OldStartingIndex)
                        {
                            ++ _newItemIndex;
                        }
                    }
 
                    if (ActiveComparer != null && adjustedOldIndex == adjustedNewIndex)
                    {
                        // when we're sorting, ignore Move from the underlying collection -
                        // the position is irrelevant
                        return;
                    }
                    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)
                    {
                        effectiveAction = NotifyCollectionChangedAction.Remove;
                    }
                }
            }
            else if (adjustedOldIndex < -1) // old item is known to be NOT in filtered view
            {
                if (adjustedNewIndex >= 0)
                {
                    // item changes from filtered to unfiltered - effectively it's an Add
                    effectiveAction = NotifyCollectionChangedAction.Add;
                }
                else if (effectiveAction == NotifyCollectionChangedAction.Move)
                {
                    // filtered item has moved - nothing to do
                    return;
                }
                // otherwise 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.
                // (Except that we may have to remove an entry from the internal
                // live-filtered list.)
            }
            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;
 
            object oldItem = (args.OldItems != null && args.OldItems.Count > 0) ? args.OldItems[0] : null;
            object newItem = (args.NewItems != null && args.NewItems.Count > 0) ? args.NewItems[0] : null;
 
            LiveShapingList lsList = InternalList as LiveShapingList;
            LiveShapingItem lsi;
 
            // 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:
                    // when adding a filtered item, all we need to do is enroll it
                    // for live filtering
                    if (adjustedNewIndex == -2)
                    {
                        if (lsList != null && IsLiveFiltering == true)
                        {
                            lsList.AddFilteredItem(newItem);
                        }
                        return;
                    }
 
                    // insert into private view
                    // (unless it's a special item - placeholder or new item)
                    bool isSpecialItem = (newItem == NewItemPlaceholder ||
                                            (IsAddingNew && System.Windows.Controls.ItemsControl.EqualsEx(_newItem, newItem)));
                    if (UsesLocalArray && !isSpecialItem)
                    {
                        InternalList.Insert(adjustedNewIndex - delta, newItem);
                    }
 
                    if (!IsGrouping)
                    {
                        AdjustCurrencyForAdd(adjustedNewIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, newItem, adjustedNewIndex);
                    }
                    else
                    {
                        lsi = (lsList == null || isSpecialItem) ? null : lsList.ItemAt(adjustedNewIndex - delta);
                        AddItemToGroups(newItem, lsi);
                    }
 
                    break;
 
                case NotifyCollectionChangedAction.Remove:
                    // when removing a filtered item, all we need do is remove it from
                    // live filtering
                    if (adjustedOldIndex == -2)
                    {
                        if (lsList != null && IsLiveFiltering == true)
                        {
                            lsList.RemoveFilteredItem(oldItem);
                        }
                        return;
                    }
 
                    // 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 &&
                            System.Windows.Controls.ItemsControl.EqualsEx(ItemFrom(InternalList[localOldIndex]), oldItem))
                        {
                            InternalList.RemoveAt(localOldIndex);
                        }
                    }
 
                    if (!IsGrouping)
                    {
                        AdjustCurrencyForRemove(adjustedOldIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.OldItems[0], adjustedOldIndex);
                    }
                    else
                    {
                        RemoveItemFromGroups(oldItem);
                    }
 
                    break;
 
                case NotifyCollectionChangedAction.Replace:
                    // when replacing a filtered item, all we need do is update
                    // the live filtering list
                    if (adjustedOldIndex == -2)
                    {
                        if (lsList != null && IsLiveFiltering == true)
                        {
                            lsList.ReplaceFilteredItem(oldItem, newItem);
                        }
                        return;
                    }
 
                    // replace item in private view
                    if (UsesLocalArray)
                    {
                        InternalList[adjustedOldIndex - delta] = newItem;
                    }
 
                    if (!IsGrouping)
                    {
                        AdjustCurrencyForReplace(adjustedOldIndex);
                        args = new NotifyCollectionChangedEventArgs(effectiveAction, args.NewItems[0], args.OldItems[0], adjustedOldIndex);
                    }
                    else
                    {
                        lsi = (lsList == null) ? null : lsList.ItemAt(adjustedNewIndex - delta);
                        RemoveItemFromGroups(oldItem);
                        AddItemToGroups(newItem, lsi);
                    }
 
                    break;
 
                case NotifyCollectionChangedAction.Move:
                    // move within private view
 
                    bool simpleMove = System.Windows.Controls.ItemsControl.EqualsEx(oldItem, newItem);
 
                    if (UsesLocalArray && (lsList == null || !lsList.IsRestoringLiveSorting))
                    {
                        int localOldIndex = adjustedOldIndex - delta;
                        int localNewIndex = adjustedNewIndex - delta;
 
                        // move the item to its new position, except in special cases
                        if (localOldIndex < InternalList.Count &&
                            System.Windows.Controls.ItemsControl.EqualsEx(InternalList[localOldIndex], oldItem))
                        {
                            if (NewItemPlaceholder != newItem)
                            {
                                // normal case - just move, and possibly replace
                                InternalList.Move(localOldIndex, localNewIndex);
 
                                if (!simpleMove)
                                {
                                    InternalList[localNewIndex] = newItem;
                                }
                            }
                            else
                            {
                                // moving the placeholder - just remove it
                                InternalList.RemoveAt(localOldIndex);
                            }
                        }
                        else
                        {
                            if (NewItemPlaceholder != newItem)
                            {
                                // old item wasn't present - just insert
                                // (this happens when the item is the object of CommitNew)
                                InternalList.Insert(localNewIndex, newItem);
                            }
                            else
                            {
                                // the remaining case - old item absent, new item is placeholder -
                                // is a no-op
                            }
                        }
                    }
 
                    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
                    {
                        lsi = (lsList == null) ? null : lsList.ItemAt(adjustedNewIndex);
                        if (simpleMove)
                        {
                            // simple move
                            MoveItemWithinGroups(oldItem, lsi, adjustedOldIndex, adjustedNewIndex);
                        }
                        else
                        {
                            // move/replace
                            RemoveItemFromGroups(oldItem);
                            AddItemToGroups(newItem, lsi);
                        }
                    }
                    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);
 
        }
 
        /// <summary>
        /// Return index of item in the internal list.
        /// </summary>
        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 && System.Windows.Controls.ItemsControl.EqualsEx(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;
        }
 
        /// <summary>
        /// Return item at the given index in the internal list.
        /// </summary>
        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];
        }
 
        /// <summary>
        /// Return true if internal list contains the item.
        /// </summary>
        protected bool InternalContains(object item)
        {
            if (item == NewItemPlaceholder)
                return (NewItemPlaceholderPosition != NewItemPlaceholderPosition.None);
 
            return (!IsGrouping) ? InternalList.Contains(item) : (_group.LeafIndexOf(item) >= 0);
        }
 
        /// <summary>
        /// Return an enumerator for the internal list.
        /// </summary>
        protected IEnumerator InternalGetEnumerator()
        {
            if (!IsGrouping)
            {
                return new PlaceholderAwareEnumerator(this, InternalList.GetEnumerator(), NewItemPlaceholderPosition, _newItem);
            }
            else
            {
                return _group.GetLeafEnumerator();
            }
        }
 
        /// <summary>
        /// True if a private copy of the data is needed for sorting and filtering
        /// </summary>
        protected bool UsesLocalArray
        {
            get { return ActiveComparer != null || ActiveFilter != null || (IsGrouping && IsLiveGrouping == true); }
        }
 
        /// <summary>
        /// Protected accessor to private _internalList field.
        /// </summary>
        protected IList InternalList
        {
            get { return _internalList; }
        }
 
        /// <summary>
        /// Protected accessor to private _activeComparer field.
        /// </summary>
        protected IComparer ActiveComparer
        {
            get { return _activeComparer; }
            set
            {
                _activeComparer = value;
            }
        }
 
        /// <summary>
        /// Protected accessor to private _activeFilter field.
        /// </summary>
        protected Predicate<object> ActiveFilter
        {
            get { return _activeFilter; }
            set { _activeFilter = value; }
        }
 
        /// <summary>
        /// Protected accessor to _isGrouping field.
        /// </summary>
        protected bool IsGrouping
        {
            get { return _isGrouping; }
        }
 
        /// <summary>
        /// Protected accessor to private count.
        /// </summary>
        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
 
        /// <summary>
        ///     Contains a snapshot of the ICollectionView.SourceCollection
        ///     at the time that a change notification is posted.
        ///     This is done in OnBeginChangeLogging.
        /// </summary>
        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[tempIndex] = e.NewItems[0];
                    }
                    break;
                case NotifyCollectionChangedAction.Move:
                    tempIndex = e.OldStartingIndex;
                    if (tempIndex < 0)
                    {
                        tempIndex = ShadowCollection.IndexOf(e.NewItems[0]);
                    }
                    ShadowCollection.RemoveAt(tempIndex);
                    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)); }
        }
 
        // return an appropriate comparer.   Common logic used by ListCollectionView
        // and by CollectionViewGroupInternal.
        internal static IComparer PrepareComparer(IComparer customSort, SortDescriptionCollection sort, Func<CollectionView> lazyGetCollectionView)
        {
            if (customSort != null)
            {
                return customSort;
            }
 
            if (sort != null && sort.Count > 0)
            {
                CollectionView view = lazyGetCollectionView();
                Debug.Assert(view != null, "lazyGetCollectionView should not return null");
 
                if (view.SourceCollection != null)
                {
                    IComparer xmlComparer = SystemXmlHelper.PrepareXmlComparer(view.SourceCollection, sort, view.Culture);
                    if (xmlComparer!= null)
                    {
                        return xmlComparer;
                    }
                }
 
                return new SortFieldComparer(sort, view.Culture);
            }
 
            return null;
        }
 
        #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));
            }
        }
 
 
        /// <summary>
        /// Create, filter and sort the local index array.
        /// called from Refresh(), override in derived classes as needed.
        /// </summary>
        /// <param name="list">new ILIst to associate this view with</param>
        /// <returns>new local array to use for this view</returns>
        private void PrepareLocalArray()
        {
            PrepareShaping();
 
            LiveShapingList lsList = _internalList as LiveShapingList;
            if (lsList != null)
            {
                lsList.LiveShapingDirty -= new EventHandler(OnLiveShapingDirty);
                lsList.Clear();
            }
 
            IList list = AllowsCrossThreadChanges ? ShadowCollection : (SourceCollection as IList);
 
            if (!UsesLocalArray)
            {
                // if there's no sort/filter, just use the collection's array
                _internalList = list;
            }
            else
            {
                // otherwise use a private copy - either a simple list or a LiveShapingList
                int size = list.Count;
                IList localList = IsLiveShaping ? (IList)(new LiveShapingList(this, GetLiveShapingFlags(), ActiveComparer))
                                                : (IList)(new ArrayList(size));
                lsList = localList as LiveShapingList;
 
                // filter the collection's array into the local array
                for (int k = 0; k < size; ++k)
                {
                    if (IsAddingNew && k == _newItemIndex)
                        continue;       // the AddNew item is held separately
 
                    object item = list[k];
                    if (ActiveFilter == null || ActiveFilter(item))
                    {
                        localList.Add(item);
                    }
                    else if (IsLiveFiltering == true)
                    {
                        lsList.AddFilteredItem(item);
                    }
                }
 
                // sort the local array
                if (ActiveComparer != null)
                {
                    localList.Sort(ActiveComparer);
                }
 
                if (lsList != null)
                {
                    lsList.LiveShapingDirty += new EventHandler(OnLiveShapingDirty);
                }
 
                _internalList = localList;
            }
 
            PrepareGroups();
        }
 
        void OnLiveShapingDirty(object sender, EventArgs e)
        {
            IsLiveShapingDirty = true;
        }
 
        // rebuild the local array, called when a live-shaping property changes
        void RebuildLocalArray()
        {
            if (IsRefreshDeferred)
            {
                RefreshOrDefer();
            }
            else
            {
                PrepareLocalArray();
            }
        }
 
        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 &&
                        System.Windows.Controls.ItemsControl.EqualsEx(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 = (AllowsCrossThreadChanges ? 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 (!System.Windows.Controls.ItemsControl.EqualsEx(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 (NewItemPlaceholderPosition != NewItemPlaceholderPosition.None &&
                        index > _newItemIndex)
                    {
                        --index;        // the new item has been artificially moved elsewhere
                    }
                }
 
                return (index < 0) ? index : 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 (!UsesLocalArray)
                {
                    index = -1;
                }
                else if (ActiveComparer != null)
                {
                    // if there's a sort order, use binary search
                    index = InternalList.Search(item, ActiveComparer);
                    if (index < 0)
                        index = ~index;
                }
                else
                {
                    // otherwise, do a linear search
                    index = MatchingSearch(item, index, ilFull, InternalList);
                }
            }
            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;
        }
 
        int MatchingSearch(object item, int index, IList ilFull, IList ilPartial)
        {
            // do a linear search of the full array, advancing
            // localIndex past elements that appear in the local array,
            // until either (a) reaching the position of the item in the
            // full array, or (b) falling off the end of the local array.
            // localIndex is now the desired index.
            // One small wrinkle:  we have to ignore the target item in
            // the local array (this arises in a Move event).
            int fullIndex=0, localIndex=0;
 
            while (fullIndex < index && localIndex < InternalList.Count)
            {
                if (System.Windows.Controls.ItemsControl.EqualsEx(ilFull[fullIndex], ilPartial[localIndex]))
                {
                    // match - current item passes filter.  Skip it.
                    ++fullIndex;
                    ++localIndex;
                }
                else if (System.Windows.Controls.ItemsControl.EqualsEx(item, ilPartial[localIndex]))
                {
                    // skip over an unmatched copy of the target item
                    // (this arises in a Move event)
                    ++localIndex;
                }
                else
                {
                    // no match - current item fails filter.  Ignore it.
                    ++fullIndex;
                }
            }
 
            return localIndex;
        }
 
        // 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 sync 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 shaping information from the relevant properties
        private void PrepareShaping()
        {
            // sort:  prepare the comparer
            ActiveComparer = ListCollectionView.PrepareComparer(_customSort, _sort, () => { return this; });
 
            // filter:  prepare the Predicate<object> filter
            ActiveFilter = Filter;
 
            // group : prepare the group descriptions
 
            // discard old groups
            _group.Clear();
 
            // initialize the synthetic top level group
            _group.Initialize();
 
            _isGrouping = (_group.GroupBy != null);
        }
 
        // 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()
        {
            // if there's no grouping, there's nothing to do
            if (!_isGrouping)
                return;
 
            // reset the grouping comparer
            IComparer comparer = ActiveComparer;
            if (comparer != null)
            {
                _group.ActiveComparer = comparer;
            }
            else
            {
                CollectionViewGroupInternal.IListComparer ilc = _group.ActiveComparer as CollectionViewGroupInternal.IListComparer;
                if (ilc != null)
                {
                    ilc.ResetList(InternalList);
                }
                else
                {
                    _group.ActiveComparer = new CollectionViewGroupInternal.IListComparer(InternalList);
                }
            }
 
            // 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*/);
                }
            }
 
            bool isLiveGrouping = (IsLiveGrouping == true);
            LiveShapingList lsList = InternalList as LiveShapingList;
 
            for (int k=0, n=InternalList.Count;  k<n;  ++k)
            {
                object item = InternalList[k];
                LiveShapingItem lsi = (lsList != null) ? lsList.ItemAt(k) : null;
 
                if (!IsAddingNew || !System.Windows.Controls.ItemsControl.EqualsEx(_newItem, item))
                {
                    _group.AddToSubgroups(item, lsi, true /*loading*/);
                }
            }
 
            if (IsAddingNew && NewItemPlaceholderPosition != NewItemPlaceholderPosition.AtBeginning)
            {
                _group.InsertSpecialItem(_group.Items.Count, _newItem, true /*loading*/);
            }
            if (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtEnd)
            {
                _group.InsertSpecialItem(_group.Items.Count, NewItemPlaceholder, true /*loading*/);
            }
        }
 
 
        // For the Group to report collection changed
        void OnGroupChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Add)
            {
                AdjustCurrencyForAdd(e.NewStartingIndex);
            }
            else if (e.Action == NotifyCollectionChangedAction.Remove)
            {
                AdjustCurrencyForRemove(e.OldStartingIndex);
            }
            OnCollectionChanged(e);
        }
 
        // The GroupDescriptions collection changed
        void OnGroupByChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (IsAddingNew || IsEditingItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Grouping"));
 
            // This is a huge change.  Just refresh the view.
            RefreshOrDefer();
        }
 
        // A group description for one of the subgroups changed
        void OnGroupDescriptionChanged(object sender, EventArgs e)
        {
            if (IsAddingNew || IsEditingItem)
                throw new InvalidOperationException(SR.Get(SRID.MemberNotAllowedDuringAddOrEdit, "Grouping"));
 
            // This is a huge change.  Just refresh the view.
            RefreshOrDefer();
        }
 
        // An item was inserted into the collection.  Update the groups.
        void AddItemToGroups(object item, LiveShapingItem lsi)
        {
            if (IsAddingNew && item == _newItem)
            {
                int index;
                switch (NewItemPlaceholderPosition)
                {
                    case NewItemPlaceholderPosition.None:
                    default:
                        index = _group.Items.Count;
                        break;
                    case NewItemPlaceholderPosition.AtBeginning:
                        index = 1;
                        break;
                    case NewItemPlaceholderPosition.AtEnd:
                        index = _group.Items.Count - 1;
                        break;
                }
 
                _group.InsertSpecialItem(index, item, false /*loading*/);
            }
            else
            {
                _group.AddToSubgroups(item, lsi, false /*loading*/);
            }
        }
 
        // An item was removed from the collection.  Update the groups.
        void RemoveItemFromGroups(object item)
        {
            if (CanGroupNamesChange || _group.RemoveFromSubgroups(item))
            {
                // the item didn't appear where we expected it to.
                _group.RemoveItemFromSubgroupsByExhaustiveSearch(item);
            }
        }
 
        // An item has moved.  Update the groups
        void MoveItemWithinGroups(object item, LiveShapingItem lsi, int oldIndex, int newIndex)
        {
            _group.MoveWithinSubgroups(item, lsi, InternalList, oldIndex, newIndex);
        }
 
        #endregion Grouping
 
        #region Live Shaping
 
        const double LiveSortingDensityThreshold = 0.8;
 
        LiveShapingFlags GetLiveShapingFlags()
        {
            LiveShapingFlags result = 0;
 
            if (IsLiveSorting == true)
                result = result | LiveShapingFlags.Sorting;
            if (IsLiveFiltering == true)
                result = result | LiveShapingFlags.Filtering;
            if (IsLiveGrouping == true)
                result = result | LiveShapingFlags.Grouping;
 
            return result;
        }
 
        internal void RestoreLiveShaping()
        {
            LiveShapingList list = InternalList as LiveShapingList;
            if (list == null)
                return;
 
            int oldIndex, newIndex;
 
            // restore sorting
            if (ActiveComparer != null)
            {
                double dirtyDensity = ((double)list.SortDirtyItems.Count) / (list.Count + 1);
                if (dirtyDensity < LiveSortingDensityThreshold)
                {
                    // when few elements are dirty, restore them one-by-one
                    foreach (LiveShapingItem lsi in list.SortDirtyItems)
                    {
                        if (!lsi.IsSortDirty || lsi.IsDeleted || !lsi.ForwardChanges)
                            continue;
 
                        lsi.IsSortDirty = false;
                        lsi.IsSortPendingClean = false;
                        list.FindPosition(lsi, out oldIndex, out newIndex);
 
                        if (oldIndex != newIndex)
                        {
                            if (oldIndex < newIndex)
                                newIndex -= 1;
 
                            ProcessLiveShapingCollectionChange(
                                new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Move,
                                                                        lsi.Item, oldIndex, newIndex),
                                oldIndex, newIndex);
 
                            Debug.Assert(list.VerifyLiveSorting(lsi), "live sorting failed");
                        }
                    }
                }
                else
                {
                    // when most elements are dirty, do a full InsertionSort
                    list.RestoreLiveSortingByInsertionSort(ProcessLiveShapingCollectionChange);
                }
 
                Debug.Assert(list.VerifyLiveSorting(null), "live sorting not resotred");
            }
 
            list.SortDirtyItems.Clear();
 
            // restore filtering
            if (ActiveFilter != null)
            {
                foreach (LiveShapingItem lsi in list.FilterDirtyItems)
                {
                    if (!lsi.IsFilterDirty || !lsi.ForwardChanges)
                        continue;
 
                    object item = lsi.Item;
                    bool oldFailsFilter = lsi.FailsFilter;
                    bool newFailsFilter = !PassesFilter(item);
                    int index;
 
                    if (oldFailsFilter != newFailsFilter)
                    {
                        if (newFailsFilter)
                        {
                            // remove item from the main list
                            index = list.IndexOf(lsi);
                            ProcessLiveShapingCollectionChange(
                                new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove,
                                                                        item, index),
                                index, -1);
 
                            // add it to the filtered list
                            list.AddFilteredItem(lsi);
                        }
                        else
                        {
                            // remove item from the filtered list
                            list.RemoveFilteredItem(lsi);
 
                            // find where it belongs in the main list
                            if (ActiveComparer != null)
                            {
                                // if there's a sort order, do a binary search
                                index = list.Search(0, list.Count, item);
                                if (index < 0)
                                    index = ~index;
                            }
                            else
                            {
                                // otherwise, do it the hard way
                                // First find its index in the source list, starting at
                                // the position of the previous duplicate
                                IList ilFull = (AllowsCrossThreadChanges ? ShadowCollection : SourceCollection) as IList;
                                for (index = lsi.GetAndClearStartingIndex(); index < ilFull.Count; ++index)
                                {
                                    if (System.Windows.Controls.ItemsControl.EqualsEx(item, ilFull[index]))
                                        break;
                                }
 
                                // record the index, for use by the next duplicate
                                list.SetStartingIndexForFilteredItem(item, index+1);
 
                                // now do a linear search in the partial list
                                index = MatchingSearch(item, index, ilFull, list);
                            }
 
                            ProcessLiveShapingCollectionChange(
                                new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add,
                                                                        item, index),
                                -1, index);
                        }
                    }
 
                    lsi.IsFilterDirty = false;
                }
            }
 
            list.FilterDirtyItems.Clear();
 
            // restore grouping
            if (IsGrouping)
            {
                List<AbandonedGroupItem> deleteList = new List<AbandonedGroupItem>();
                foreach (LiveShapingItem lsi in list.GroupDirtyItems)
                {
                    if (!lsi.IsGroupDirty || lsi.IsDeleted || !lsi.ForwardChanges)
                        continue;
 
                    _group.RestoreGrouping(lsi, deleteList);
 
                    lsi.IsGroupDirty = false;
                }
 
                _group.DeleteAbandonedGroupItems(deleteList);
            }
 
            list.GroupDirtyItems.Clear();
 
 
            IsLiveShapingDirty = false;
        }
 
        // changes from the LiveShaping list need indices adjusted for NewItemPlaceholder
        void ProcessLiveShapingCollectionChange(NotifyCollectionChangedEventArgs args, int oldIndex, int newIndex)
        {
            if (!IsGrouping && (NewItemPlaceholderPosition == NewItemPlaceholderPosition.AtBeginning))
            {
                if (oldIndex >= 0)  ++oldIndex;
                if (newIndex >= 0)  ++newIndex;
            }
 
            ProcessCollectionChangedWithAdjustedIndex(args, oldIndex, newIndex);
        }
 
        internal bool IsLiveShapingDirty
        {
            get { return _isLiveShapingDirty; }
            set
            {
                if (value == _isLiveShapingDirty)
                    return;
 
                _isLiveShapingDirty = value;
                if (value)
                {
                    Dispatcher.BeginInvoke(DispatcherPriority.DataBind, (Action)RestoreLiveShaping);
                }
            }
        }
 
        object ItemFrom(object o)
        {
            LiveShapingItem lsi = o as LiveShapingItem;
            return (lsi == null) ? o : lsi.Item;
        }
 
        #endregion Live Shaping
 
        /// <summary>
        /// Helper to raise a PropertyChanged event  />).
        /// </summary>
        private void OnPropertyChanged(string propertyName)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }
 
        #region Deferred work
 
        // defer work until the current activity completes
        private void DeferAction(Action action)
        {
            if (_deferredActions == null)
            {
                _deferredActions = new List<Action>();
            }
            _deferredActions.Add(action);
        }
 
        // perform the deferred work, if any
        private void DoDeferredActions()
        {
            if (_deferredActions != null)
            {
                List<Action> deferredActions = _deferredActions;
                _deferredActions = null;
 
                foreach(Action action in deferredActions)
                {
                    action();
                }
            }
        }
 
        #endregion Deferred work
 
        #endregion Private Methods
 
 
 
        //------------------------------------------------------
        //
        //  Private Fields
        //
        //------------------------------------------------------
 
        #region Private Fields
 
        private IList               _internalList;
        private CollectionViewGroupRoot _group;
        private bool                _isGrouping;
        private IComparer           _activeComparer;
        private Predicate<object>   _activeFilter;
        private SortDescriptionCollection  _sort;
        private IComparer           _customSort;
        private ArrayList           _shadowCollection;
        private bool                _currentElementWasRemoved;  // true if we need to MoveCurrencyOffDeletedElement
        private object              _newItem = NoNewItem;
        private object              _editItem;
        private int                 _newItemIndex;  // position _newItem in the source collection
        private NewItemPlaceholderPosition _newItemPlaceholderPosition;
        private bool                _isItemConstructorValid;
        private ConstructorInfo     _itemConstructor;
        private List<Action>        _deferredActions;
        private ObservableCollection<string>    _liveSortingProperties;
        private ObservableCollection<string>    _liveFilteringProperties;
        private ObservableCollection<string>    _liveGroupingProperties;
        bool?                       _isLiveSorting = false;
        bool?                       _isLiveFiltering = false;
        bool?                       _isLiveGrouping = false;
        bool                        _isLiveShapingDirty;
        bool                        _isRemoving;
 
        private const int           _unknownIndex = -1;
 
        #endregion Private Fields
    }
 
    /// <summary>
    /// A delegate to select the group description as a function of the
    /// parent group and its level.
    /// </summary>
    public delegate GroupDescription GroupDescriptionSelectorCallback(CollectionViewGroup group, int level);
 
}