internal RawItem GetRawItemAtGlobalSortedIndex(int index)
{
if (this.IsBottomLevel)
{
return(m_sortedRawItems[index]);
}
else
{
foreach (object value in this.ProtectedItems)
{
DataGridCollectionViewGroup subGroup = value as DataGridCollectionViewGroup;
int subGroupCount = subGroup.GlobalRawItemCount;
if (index < subGroupCount)
{
return(subGroup.GetRawItemAtGlobalSortedIndex(index));
}
index -= subGroupCount;
}
}
throw new ArgumentOutOfRangeException("index");
}
private void RemoveGroup(DataGridCollectionViewGroup group)
{
if (group == null)
{
throw new ArgumentNullException("group");
}
Debug.Assert(this == group.m_parent);
// We do not remove group forced in SubGroupBy.GroupNames
if (group.UnsortedIndex < this.SubGroupBy.GroupNames.Count)
{
return;
}
Debug.Assert(!this.IsBottomLevel);
Debug.Assert((group.m_globalRawItemCount == 0) && (group.ProtectedItemCount == 0));
m_subGroups.Remove(DataGridCollectionViewGroup.GetHashKeyFromName(group.Name));
this.ProtectedItemCount--;
this.ProtectedItems.Remove(group);
if ((m_subGroups.Count == 0) && (m_parent != null))
{
m_parent.RemoveGroup(this);
}
}
internal bool Contains(object item)
{
var group = item as DataGridCollectionViewGroup;
if (group != null)
{
//Must make sure the group the group is ref equals, because there can be groups with a null name at more than one level.
DataGridCollectionViewGroup foundGroup;
if (m_subGroups.TryGetValue(DataGridCollectionViewGroup.GetHashKeyFromName(group.Name), out foundGroup))
{
return(foundGroup == group);
}
return(false);
}
DataGridCollectionView collectionView = this.GetCollectionView();
if (collectionView != null)
{
RawItem rawItem = collectionView.GetFirstRawItemFromDataItem(item);
if (rawItem != null)
{
return(rawItem.ParentGroup == this);
}
}
return(false);
}
public override int Compare(int xDataIndex, int yDataIndex)
{
DataGridCollectionViewGroup xGroup = m_groups[xDataIndex];
DataGridCollectionViewGroup yGroup = m_groups[yDataIndex];
return(m_groupSortedComparer.Compare(xGroup, yGroup));
}
internal int GetFirstRawItemGlobalSortedIndex()
{
int index = 0;
DataGridCollectionViewGroup group = this;
DataGridCollectionViewGroup parent = this.Parent;
DataGridCollectionViewGroup currentGroup = null;
while (parent != null)
{
foreach (object value in parent.ProtectedItems)
{
if (value == group)
{
break;
}
currentGroup = value as DataGridCollectionViewGroup;
index += currentGroup.GlobalRawItemCount;
}
group = parent;
parent = parent.Parent;
}
return(index);
}
internal virtual void InsertRawItem(int index, RawItem rawItem)
{
Debug.Assert(this.IsBottomLevel);
m_globalRawItemCount++;
DataGridCollectionViewGroup parent = m_parent;
while (parent != null)
{
parent.m_globalRawItemCount++;
parent = parent.m_parent;
}
int count = m_sortedRawItems.Count;
for (int i = index; i < count; i++)
{
m_sortedRawItems[i].SetSortedIndex(i + 1);
}
m_sortedRawItems.Insert(index, rawItem);
rawItem.SetParentGroup(this);
rawItem.SetSortedIndex(index);
this.ProtectedItemCount++;
this.ProtectedItems.Insert(index, rawItem.DataItem);
}
private void InsertGroup(int index, DataGridCollectionViewGroup group)
{
Debug.Assert(!this.IsBottomLevel);
m_subGroups.Add(DataGridCollectionViewGroup.GetHashKeyFromName(group.Name), group);
this.ProtectedItemCount++;
this.ProtectedItems.Insert(index, group);
}
internal OptimizedReadOnlyObservableCollection(DataGridCollectionViewGroup dataGridCollectionViewGroup)
: base(dataGridCollectionViewGroup.ProtectedItems)
{
if (dataGridCollectionViewGroup == null)
{
throw new ArgumentNullException("dataGridCollectionViewGroup");
}
m_dataGridCollectionViewGroup = dataGridCollectionViewGroup;
}
private DataGridCollectionViewGroup(object name, DataGridCollectionViewGroup parent, int unsortedIndex, int rawCapacity, int groupCapacity)
: base(name)
{
m_parent = parent;
m_unsortedIndex = unsortedIndex;
m_protectedItems = ObservableCollectionHelper.GetItems(base.ProtectedItems);
m_protectedItemsCollectionChanged = ObservableCollectionHelper.GetCollectionChanged(base.ProtectedItems);
m_optimizedItems = new OptimizedReadOnlyObservableCollection(this);
m_subGroups = new Dictionary <object, DataGridCollectionViewGroup>(groupCapacity);
m_sortedRawItems = new List <RawItem>(rawCapacity);
}
private int BinarySearchGroup(DataGridCollectionViewGroup value, IComparer <DataGridCollectionViewGroup> comparer)
{
if (comparer == null)
{
throw new ArgumentNullException("comparer");
}
int low = 0;
int hi = (this.ProtectedItemCount) - 1;
int median;
int compareResult;
while (low <= hi)
{
median = (low + ((hi - low) >> 1));
DataGridCollectionViewGroup medianGroup = this.ProtectedItems[median] as DataGridCollectionViewGroup;
if (medianGroup == value)
{
if (low == hi)
{
return(low);
}
return(median);
}
try
{
compareResult = comparer.Compare(medianGroup, value);
}
catch (Exception exception)
{
throw new InvalidOperationException("IComparer has failed to compare the values.", exception);
}
if (compareResult == 0)
{
return(median);
}
if (compareResult < 0)
{
low = median + 1;
}
else
{
hi = median - 1;
}
}
return(~low);
}
private DataGridCollectionViewGroup MoveToFirstLeafGroup(DataGridCollectionViewGroup referenceGroup, int index)
{
while (!referenceGroup.IsBottomLevel)
{
referenceGroup = referenceGroup.Items[index] as DataGridCollectionViewGroup;
m_currentGroupIndex.Push(index);
if (index != 0)
{
index = 0;
}
}
return(referenceGroup);
}
internal DataGridCollectionViewGroup GetGroup(
RawItem rawItem,
int level,
CultureInfo culture,
ObservableCollection <GroupDescription> groupByList,
List <GroupSortComparer> groupSortComparers)
{
// If sortComparers is null, we are in massive group creation, no order check.
if (this.IsBottomLevel)
{
throw new InvalidOperationException("An attempt was made to get a group for which a GroupDescription has not been provided.");
}
object groupName = m_subGroupBy.GroupNameFromItem(rawItem.DataItem, level, culture);
DataGridCollectionViewGroup group;
if ((m_subGroupBy is DataGridGroupDescription) || (m_subGroupBy is PropertyGroupDescription))
{
m_subGroups.TryGetValue(DataGridCollectionViewGroup.GetHashKeyFromName(groupName), out group);
}
else
{
//If dealing with an unknown GroupDescription type, use the standard method to retrieve a group, in case group retrival is handle differently.
group = null;
foreach (var tempGroup in m_subGroups.Values)
{
if (m_subGroupBy.NamesMatch(tempGroup.Name, groupName))
{
group = tempGroup;
break;
}
}
}
if (group == null)
{
group = this.CreateSubGroup(groupName, level, groupByList, groupSortComparers);
}
return(group);
}
public void InvalidateGroupStats(DataGridCollectionViewGroup group, bool calculateAllStats = false)
{
if (group == null)
{
return;
}
lock (this)
{
if (this.RefreshPending)
{
return;
}
DataGridCollectionViewGroup parent = group;
while (parent != null)
{
if (!m_invalidatedGroups.Contains(parent))
{
m_invalidatedGroups.Add(parent);
}
parent.ClearStatFunctionsResult();
parent.CalculateAllStats = calculateAllStats;
parent = parent.Parent;
}
if (m_dispatcher != null)
{
if (m_dispatcherOperation == null)
{
m_dispatcherOperation = m_dispatcher.BeginInvoke(DispatcherPriority.DataBind, new DispatcherOperationCallback(this.Dispatched_Process), null);
m_dispatcherOperationStartTime = DateTime.UtcNow;
}
else
{
m_hasNewOperationsSinceStartTime = true;
}
}
}
}
internal virtual void RemoveRawItemAt(int index)
{
Debug.Assert(this.IsBottomLevel);
Debug.Assert(m_sortedRawItems.Count > 0);
int count = m_sortedRawItems.Count;
if (count == 0)
{
return;
}
if (index != -1)
{
m_globalRawItemCount--;
DataGridCollectionViewGroup parent = m_parent;
while (parent != null)
{
parent.m_globalRawItemCount--;
parent = parent.Parent;
}
for (int i = index + 1; i < count; i++)
{
m_sortedRawItems[i].SetSortedIndex(i - 1);
}
RawItem rawItem = m_sortedRawItems[index];
rawItem.SetParentGroup(null);
rawItem.SetSortedIndex(-1);
m_sortedRawItems.RemoveAt(index);
this.ProtectedItemCount--;
this.ProtectedItems.RemoveAt(index);
if ((this.ProtectedItemCount == 0) && (m_parent != null))
{
m_parent.RemoveGroup(this);
}
}
}
internal void SortGroups(List <GroupSortComparer> groupSortComparers, int level)
{
int itemCount = this.ProtectedItemCount;
if (itemCount == 0)
{
return;
}
int[] indexes;
indexes = new int[itemCount + 1];
for (int i = 0; i < itemCount; i++)
{
indexes[i] = i;
}
DataGridCollectionViewGroup[] subGroupsArray = new DataGridCollectionViewGroup[itemCount];
m_subGroups.Values.CopyTo(subGroupsArray, 0);
// "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
DataGridCollectionViewGroupSort collectionViewSort = new DataGridCollectionViewGroupSort(indexes, groupSortComparers[level], subGroupsArray);
collectionViewSort.Sort(itemCount);
level++;
m_protectedItems.Clear();
for (int i = 1; i <= itemCount; i++)
{
DataGridCollectionViewGroup group = subGroupsArray[indexes[i]];
// Sort sub groups
if (!group.IsBottomLevel)
{
group.SortGroups(groupSortComparers, level);
}
m_protectedItems.Add(group);
}
this.ProtectedItemCount = m_protectedItems.Count;
m_protectedItemsCollectionChanged.Invoke(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
internal static SelectionRange GetRange(this CollectionViewGroup collectionViewGroup, DataGridContext dataGridContext)
{
int startIndex = -1;
int endIndex = -1;
DataGridVirtualizingCollectionViewGroupBase dataGridVirtualizingCollectionViewGroupBase = collectionViewGroup as DataGridVirtualizingCollectionViewGroupBase;
DataGridCollectionViewGroup dataGridCollectionViewGroup = collectionViewGroup as DataGridCollectionViewGroup;
if (dataGridVirtualizingCollectionViewGroupBase != null)
{
startIndex = dataGridVirtualizingCollectionViewGroupBase.StartGlobalIndex;
endIndex = startIndex + dataGridVirtualizingCollectionViewGroupBase.VirtualItemCount - 1;
}
else if (dataGridCollectionViewGroup != null)
{
startIndex = dataGridCollectionViewGroup.GetFirstRawItemGlobalSortedIndex();
endIndex = startIndex + dataGridCollectionViewGroup.GlobalRawItemCount - 1;
}
else if (collectionViewGroup.ItemCount > 0)
{
if (dataGridContext == null)
{
throw new DataGridInternalException("This collectionViewGroup require a DataGridContext instance");
}
var firstItem = collectionViewGroup.GetFirstLeafItem();
var lastItem = collectionViewGroup.GetLastLeafItem();
if (firstItem != null && lastItem != null)
{
startIndex = dataGridContext.Items.IndexOf(firstItem);
endIndex = dataGridContext.Items.IndexOf(lastItem);
}
}
return((startIndex >= 0) && (startIndex <= endIndex)
? new SelectionRange(startIndex, endIndex)
: SelectionRange.Empty);
}
private DataGridCollectionViewGroup CreateSubGroup(object groupName, int level, ObservableCollection <GroupDescription> groupByList,
List <GroupSortComparer> groupSortComparers)
{
// If sortComparers is null, we are in massive group creation, no order check.
DataGridCollectionViewGroup group = new DataGridCollectionViewGroup(groupName, this, m_nextSubGroupUnsortedIndex);
unchecked
{
m_nextSubGroupUnsortedIndex++;
}
int index;
if (groupSortComparers == null)
{
Debug.Assert(this.ProtectedItemCount == this.ProtectedItems.Count);
index = this.ProtectedItemCount;
}
else
{
index = this.BinarySearchGroup(group, groupSortComparers[level]);
if (index < 0)
{
index = ~index;
}
}
level++;
if (level < groupByList.Count)
{
group.SetSubGroupBy(groupByList[level]);
group.CreateFixedGroupNames(level, groupByList, groupSortComparers);
}
this.InsertGroup(index, group);
return(group);
}
internal void SetParentGroup(DataGridCollectionViewGroup parentGroup)
{
m_parentGroup = parentGroup;
}
internal void SortItems(
SortDescriptionInfo[] sortDescriptionInfos,
List <GroupSortComparer> groupSortComparers,
int level,
List <RawItem> globalRawItems,
DataGridCollectionViewGroup newSortedGroup)
{
int itemCount = this.ProtectedItemCount;
if (itemCount == 0)
{
return;
}
if (this.IsBottomLevel)
{
int[] indexes;
indexes = new int[itemCount + 1];
for (int i = 0; i < itemCount; i++)
{
indexes[i] = m_sortedRawItems[i].Index;
}
// "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
DataGridCollectionViewSort collectionViewSort = new DataGridCollectionViewSort(indexes, sortDescriptionInfos);
collectionViewSort.Sort(itemCount);
int index = 0;
for (int i = 1; i <= itemCount; i++)
{
newSortedGroup.InsertRawItem(index, globalRawItems[indexes[i]]);
index++;
}
}
else
{
int[] indexes;
indexes = new int[itemCount + 1];
for (int i = 0; i < itemCount; i++)
{
indexes[i] = i;
}
DataGridCollectionViewGroup[] subGroupsArray = new DataGridCollectionViewGroup[itemCount];
m_subGroups.Values.CopyTo(subGroupsArray, 0);
// "Weak heap sort" sort array[0..NUM_ELEMENTS-1] to array[1..NUM_ELEMENTS]
DataGridCollectionViewGroupSort collectionViewSort = new DataGridCollectionViewGroupSort(indexes, groupSortComparers[level], subGroupsArray);
collectionViewSort.Sort(itemCount);
int index = 0;
level++;
for (int i = 1; i <= itemCount; i++)
{
DataGridCollectionViewGroup oldGroup = subGroupsArray[indexes[i]];
DataGridCollectionViewGroup newGroup = new DataGridCollectionViewGroup(oldGroup, newSortedGroup);
// Sort sub items
oldGroup.SortItems(sortDescriptionInfos, groupSortComparers, level, globalRawItems, newGroup);
newSortedGroup.InsertGroup(index, newGroup);
index++;
}
}
}
protected DataGridCollectionViewGroup(DataGridCollectionViewGroup template, DataGridCollectionViewGroup parent)
: this(template.Name, parent, template.m_unsortedIndex, template.m_sortedRawItems.Count, template.m_subGroups.Count)
{
m_nextSubGroupUnsortedIndex = template.m_nextSubGroupUnsortedIndex;
m_subGroupBy = template.m_subGroupBy;
}
private DataGridCollectionViewGroup(object name, DataGridCollectionViewGroup parent, int unsortedIndex)
: this(name, parent, unsortedIndex, 4, 4)
{
}
