//------------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
/// <summary>
/// Removes an empty group from the PagedCollectionView grouping
/// </summary>
/// <param name="group">Empty subgroup to remove</param>
private static void RemoveEmptyGroup(CollectionViewGroupInternal group)
{
CollectionViewGroupInternal parent = group.Parent;
if (parent != null)
{
GroupDescription groupBy = parent.GroupBy;
int index = parent.ProtectedItems.IndexOf(group);
// remove the subgroup unless it is one of the explicit groups
if (index >= groupBy.GroupNames.Count)
{
parent.Remove(group, false);
}
}
}
/// <summary>
/// Finds the index of the specified item
/// </summary>
/// <param name="item">Item we are looking for</param>
/// <param name="seed">Seed of the item we are looking for</param>
/// <param name="comparer">Comparer used to find the item</param>
/// <param name="low">Low range of item index</param>
/// <param name="high">High range of item index</param>
/// <returns>Index of the specified item</returns>
protected virtual int FindIndex(object item, object seed, IComparer comparer, int low, int high)
{
int index;
if (comparer != null)
{
ListComparer listComparer = comparer as ListComparer;
if (listComparer != null)
{
// reset the IListComparer before each search. This cannot be done
// any less frequently (e.g. in Root.AddToSubgroups), due to the
// possibility that the item may appear in more than one subgroup.
listComparer.Reset();
}
CollectionViewGroupComparer groupComparer = comparer as CollectionViewGroupComparer;
if (groupComparer != null)
{
// reset the CollectionViewGroupComparer before each search. This cannot be done
// any less frequently (e.g. in Root.AddToSubgroups), due to the
// possibility that the item may appear in more than one subgroup.
groupComparer.Reset();
}
for (index = low; index < high; ++index)
{
CollectionViewGroupInternal subgroup = ProtectedItems[index] as CollectionViewGroupInternal;
object seed1 = (subgroup != null) ? subgroup.SeedItem : ProtectedItems[index];
if (seed1 == DependencyProperty.UnsetValue)
{
continue;
}
if (comparer.Compare(seed, seed1) < 0)
{
break;
}
}
}
else
{
index = high;
}
return(index);
}
/// <summary>
/// The item did not appear in one or more of the subgroups it
/// was supposed to. This can happen if the item's properties
/// change so that the group names we used to insert it are
/// different from the names used to remove it. If this happens,
/// remove the item the hard way.
/// </summary>
/// <param name="group">Group to remove item from</param>
/// <param name="item">Item to remove</param>
private void RemoveItemFromSubgroupsByExhaustiveSearch(CollectionViewGroupInternal group, object item)
{
// try to remove the item from the direct children
// this function only returns true if it failed to remove from group directly
// in which case we will step through and search exhaustively
if (RemoveFromGroupDirectly(group, item))
{
// if that didn't work, recurse into each subgroup
// (loop runs backwards in case an entire group is deleted)
for (int k = group.Items.Count - 1; k >= 0; --k)
{
CollectionViewGroupInternal subgroup = group.Items[k] as CollectionViewGroupInternal;
if (subgroup != null)
{
RemoveItemFromSubgroupsByExhaustiveSearch(subgroup, item);
}
}
}
}
//------------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
/// <summary>
/// Add an item to the subgroup with the given name
/// </summary>
/// <param name="item">Item to add</param>
/// <param name="group">Group to add item to</param>
/// <param name="level">The level of grouping.</param>
/// <param name="name">Name of subgroup to add to</param>
/// <param name="loading">Whether we are currently loading</param>
private void AddToSubgroup(object item, CollectionViewGroupInternal group, int level, object name, bool loading)
{
CollectionViewGroupInternal subgroup;
int index = (_isDataInGroupOrder) ? group.LastIndex : 0;
// find the desired subgroup
for (int n = group.Items.Count; index < n; ++index)
{
subgroup = group.Items[index] as CollectionViewGroupInternal;
if (subgroup == null)
{
continue; // skip children that are not groups
}
if (group.GroupBy.NamesMatch(subgroup.Name, name))
{
group.LastIndex = index;
AddToSubgroups(item, subgroup, level + 1, loading);
return;
}
}
// the item didn't match any subgroups. Create a new subgroup and add the item.
subgroup = new CollectionViewGroupInternal(name, group);
InitializeGroup(subgroup, level + 1, item);
if (loading)
{
group.Add(subgroup);
group.LastIndex = index;
}
else
{
// using insert will find the correct sort index to
// place the subgroup, and will default to the last
// position if no ActiveComparer is specified
group.Insert(subgroup, item, ActiveComparer);
}
AddToSubgroups(item, subgroup, level + 1, loading);
}
/// <summary>
/// MoveNext implementation for IEnumerator
/// </summary>
/// <returns>Returns whether the MoveNext operation was successful</returns>
bool IEnumerator.MoveNext()
{
Debug.Assert(_group != null, "_group should have been initialized in constructor");
// check for invalidated enumerator
if (_group._version != _version)
{
throw new InvalidOperationException();
}
// move forward to the next leaf
while (_subEnum == null || !_subEnum.MoveNext())
{
// done with the current top-level item. Move to the next one.
++_index;
if (_index >= _group.Items.Count)
{
return(false);
}
CollectionViewGroupInternal subgroup = _group.Items[_index] as CollectionViewGroupInternal;
if (subgroup == null)
{
// current item is a leaf - it's the new Current
_current = _group.Items[_index];
_subEnum = null;
return(true);
}
else
{
// current item is a subgroup - get its enumerator
_subEnum = subgroup.GetLeafEnumerator();
}
}
// the loop terminates only when we have a subgroup enumerator
// positioned at the new Current item
_current = _subEnum.Current;
return(true);
}
/// <summary>
/// Initialize the given group
/// </summary>
/// <param name="group">Group to initialize</param>
/// <param name="level">The level of grouping</param>
/// <param name="seedItem">The seed item to compare with to see where to insert</param>
private void InitializeGroup(CollectionViewGroupInternal group, int level, object seedItem)
{
// set the group description for dividing the group into subgroups
GroupDescription groupDescription = GetGroupDescription(group, level);
group.GroupBy = groupDescription;
// create subgroups for each of the explicit names
ObservableCollection <object> explicitNames =
(groupDescription != null) ? groupDescription.GroupNames : null;
if (explicitNames != null)
{
for (int k = 0, n = explicitNames.Count; k < n; ++k)
{
CollectionViewGroupInternal subgroup = new CollectionViewGroupInternal(explicitNames[k], group);
InitializeGroup(subgroup, level + 1, seedItem);
group.Add(subgroup);
}
}
group.LastIndex = 0;
}
/// <summary>
/// Returns the index of the given item within the list of leaves governed
/// by this group
/// </summary>
/// <param name="item">Item we are looking for</param>
/// <returns>Number of items under that leaf</returns>
internal int LeafIndexOf(object item)
{
int leaves = 0; // number of leaves we've passed over so far
for (int k = 0, n = Items.Count; k < n; ++k)
{
CollectionViewGroupInternal subgroup = Items[k] as CollectionViewGroupInternal;
if (subgroup != null)
{
int subgroupIndex = subgroup.LeafIndexOf(item);
if (subgroupIndex < 0)
{
leaves += subgroup.ItemCount; // item not in this subgroup
}
else
{
return(leaves + subgroupIndex); // item is in this subgroup
}
}
else
{
// current item is a leaf - compare it directly
if (Equals(item, Items[k]))
{
return(leaves);
}
else
{
leaves += 1;
}
}
}
// item not found
return(-1);
}
private int _version; // parent group's version at ctor
/// <summary>
/// Initializes a new instance of the LeafEnumerator class.
/// </summary>
/// <param name="group">CollectionViewGroupInternal that uses the enumerator</param>
public LeafEnumerator(CollectionViewGroupInternal group)
{
_group = group;
DoReset(); // don't call virtual Reset in ctor
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
/// <summary>
/// Initializes a new instance of the CollectionViewGroupInternal class.
/// </summary>
/// <param name="name">Name of the CollectionViewGroupInternal</param>
/// <param name="parent">Parent node of the CollectionViewGroup</param>
internal CollectionViewGroupInternal(object name, CollectionViewGroupInternal parent)
: base(name)
{
_parentGroup = parent;
}