private void RemoveAt(int index, bool repairIndex)
{
var wrapper = m_ranges[index];
var rangeWithItems = wrapper.Value;
Debug.Assert(wrapper.Index == index);
if (!rangeWithItems.IsEmpty)
{
var removed = m_map.Remove(SelectedItemsStorage.GetArea(rangeWithItems), wrapper);
Debug.Assert(removed, "Failed to remove the selection range.");
// Since there should be only a single instance of the wrapper within the collection, try an altenate strategy.
if (!removed)
{
var entry = m_map.FirstOrDefault(e => e.Item == wrapper);
if (entry.Item == wrapper)
{
removed = m_map.Remove(entry);
}
Debug.Assert(removed, "Failed to find the selection range.");
}
}
m_ranges.RemoveAt(index);
if (repairIndex)
{
this.RepairIndex(index);
}
}
public void Visit( DataGridContext sourceContext, ref bool stopVisit )
{
object[] items;
CollectionView itemsCollection = sourceContext.Items;
int count = itemsCollection.Count;
if( count == 0 )
return;
if( sourceContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase )
{
items = null;
}
else
{
items = new object[ count ];
for( int i = 0; i < count; i++ )
{
items[ i ] = itemsCollection.GetItemAt( i );
}
}
SelectionRange itemRange = new SelectionRange( 0, count - 1 );
if( sourceContext.DataGridControl.SelectionUnit == SelectionUnit.Row )
{
sourceContext.DataGridControl.SelectionChangerManager.SelectItems(
sourceContext,
new SelectionRangeWithItems( itemRange, items ) );
}
else
{
HashedLinkedList<ColumnBase> columnsByVisiblePosition = sourceContext.ColumnsByVisiblePosition;
SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null, 8 );
SelectionRange fullColumnRange = new SelectionRange( 0, columnsByVisiblePosition.Count - 1 );
selectedColumnStore.Add( new SelectionRangeWithItems( fullColumnRange, null ) );
int index = 0;
foreach( ColumnBase column in columnsByVisiblePosition )
{
if( !column.Visible )
{
selectedColumnStore.Remove( new SelectionRangeWithItems( new SelectionRange( index ), null ) );
}
index++;
}
int columnRangeCount = selectedColumnStore.Count;
for( int i = 0; i < columnRangeCount; i++ )
{
sourceContext.DataGridControl.SelectionChangerManager.SelectCells(
sourceContext,
new SelectionCellRangeWithItems( itemRange, items, selectedColumnStore[ i ].Range ) );
}
}
}
public SelectionChanger( DataGridContext owner )
{
m_owner = owner;
m_itemsToSelect = new SelectedItemsStorage( owner, 2 );
m_itemsToUnselect = new SelectedItemsStorage( owner, 2 );
m_cellsToSelect = new SelectedCellsStorage( owner, 2 );
m_cellsToUnselect = new SelectedCellsStorage( owner, 2 );
m_toDeferSelect = new List<object>( 1 );
m_sourceChanges = new List<SourceChangeInfo>( 2 );
}
public void Insert(int index, SelectionRangeWithItems rangeWithItems)
{
Debug.Assert(!this.Contains(rangeWithItems.Range));
m_itemsCount += rangeWithItems.Length;
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
m_dataGridContext, rangeWithItems, ref rangeWithItems);
m_list.Insert(index, rangeWithItems);
}
internal SelectionChanger(DataGridContext owner)
{
m_owner = owner;
m_itemsToSelect = new SelectedItemsStorage(owner);
m_itemsToUnselect = new SelectedItemsStorage(owner);
m_cellsToSelect = new SelectedCellsStorage(owner);
m_cellsToUnselect = new SelectedCellsStorage(owner);
m_toDeferSelect = new List <object>(1);
m_sourceChanges = new List <SourceChangeInfo>(2);
}
public void Add(SelectionCellRangeWithItems rangeWithItems)
{
Debug.Assert(m_unsortedRanges.All(r => r.Value.CellRange.Intersect(rangeWithItems.CellRange).IsEmpty), "Part of this range is already selected");
var itemRangeWithItems = rangeWithItems.ItemRangeWithItems;
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(m_dataGridContext, itemRangeWithItems, ref itemRangeWithItems);
var newRangeWithItems = new SelectionCellRangeWithItems(itemRangeWithItems.Range, itemRangeWithItems.Items, rangeWithItems.ColumnRange);
this.Insert(this.Count, newRangeWithItems, true);
}
public object Clone()
{
var copy = new SelectedItemsStorage(m_dataGridContext);
for (int i = 0; i < m_ranges.Count; i++)
{
copy.Insert(i, m_ranges[i].Value, false);
}
copy.m_itemsCount = m_itemsCount;
return(copy);
}
public int Add(SelectionCellRangeWithItems cellRangeWithItems)
{
m_cellsCount += cellRangeWithItems.Length;
SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems;
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
m_dataGridContext, itemRangeWithItems, ref itemRangeWithItems);
m_list.Add(new SelectionCellRangeWithItems(
itemRangeWithItems.Range, itemRangeWithItems.Items, cellRangeWithItems.ColumnRange));
return(m_list.Count - 1);
}
public void Insert(int index, SelectionCellRangeWithItems cellRangeWithItems)
{
Debug.Assert(!this.Contains(cellRangeWithItems.CellRange));
m_cellsCount += cellRangeWithItems.Length;
SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems;
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
m_dataGridContext, itemRangeWithItems, ref itemRangeWithItems);
m_list.Insert(
index, new SelectionCellRangeWithItems(
itemRangeWithItems.Range, itemRangeWithItems.Items, cellRangeWithItems.ColumnRange));
}
internal SelectionInfo(
DataGridContext dataGridContext,
SelectedItemsStorage removedItems,
SelectedItemsStorage addedItems,
SelectedCellsStorage removedCells,
SelectedCellsStorage addedCells )
{
this.DataGridContext = dataGridContext;
this.AddedItems = new ReadOnlyCollection<object>( new SelectionItemCollection( addedItems ) );
this.RemovedItems = new ReadOnlyCollection<object>( new SelectionItemCollection( removedItems ) );
this.AddedItemRanges = new ReadOnlyCollection<SelectionRange>( new SelectionItemRangeCollection( addedItems ) );
this.RemovedItemRanges = new ReadOnlyCollection<SelectionRange>( new SelectionItemRangeCollection( removedItems ) );
this.AddedCellRanges = new ReadOnlyCollection<SelectionCellRange>( new SelectionCellRangeCollection( addedCells ) );
this.RemovedCellRanges = new ReadOnlyCollection<SelectionCellRange>( new SelectionCellRangeCollection( removedCells ) );
}
internal SelectionInfo(
DataGridContext dataGridContext,
SelectedItemsStorage removedItems,
SelectedItemsStorage addedItems,
SelectedCellsStorage removedCells,
SelectedCellsStorage addedCells)
{
this.DataGridContext = dataGridContext;
this.AddedItems = new ReadOnlyCollection <object>(new SelectionItemCollection(addedItems));
this.RemovedItems = new ReadOnlyCollection <object>(new SelectionItemCollection(removedItems));
this.AddedItemRanges = new ReadOnlyCollection <SelectionRange>(new SelectionItemRangeCollection(addedItems));
this.RemovedItemRanges = new ReadOnlyCollection <SelectionRange>(new SelectionItemRangeCollection(removedItems));
this.AddedCellRanges = new ReadOnlyCollection <SelectionCellRange>(new SelectionCellRangeCollection(addedCells));
this.RemovedCellRanges = new ReadOnlyCollection <SelectionCellRange>(new SelectionCellRangeCollection(removedCells));
}
private void Insert(int index, SelectionRangeWithItems item, bool repairIndex)
{
var wrapper = new SelectionRangeWithItemsWrapper(item, index);
m_ranges.Insert(index, wrapper);
if (repairIndex)
{
this.RepairIndex(index + 1);
}
if (!item.IsEmpty)
{
m_map.Add(SelectedItemsStorage.GetArea(item), wrapper);
}
}
private IEnumerable <int> IndexOfOverlap(SelectionRangeWithItems rangeWithItems)
{
foreach (var entry in m_map.GetEntriesWithin(SelectedItemsStorage.GetArea(rangeWithItems)))
{
var candidate = entry.Item;
var target = candidate.Value;
var overlap = rangeWithItems.Range.Intersect(target.Range);
Debug.Assert(!overlap.IsEmpty);
if (!overlap.IsEmpty && (rangeWithItems.IsItemsEqual(overlap, target)))
{
yield return(candidate.Index);
}
}
}
public bool SelectJustThisItem(int itemIndex, object item)
{
bool selectionDone = true;
m_toDeferSelect.Clear();
SelectionRangeWithItems rangeWithItemsToSelect = new SelectionRangeWithItems(itemIndex, item);
SelectionRange range = rangeWithItemsToSelect.Range;
if (m_itemsToSelect.Contains(range))
{
selectionDone = false;
}
m_itemsToSelect.Clear();
SelectedItemsStorage selectedItemsInChange = m_owner.SelectedItemsStore;
if (selectedItemsInChange.Contains(range))
{
if (!m_itemsToUnselect.Contains(range))
{
selectionDone = false;
}
m_itemsToUnselect.Clear();
foreach (SelectionRangeWithItems selectedRangeWithItems in selectedItemsInChange)
{
m_itemsToUnselect.Add(selectedRangeWithItems);
}
m_itemsToUnselect.Remove(rangeWithItemsToSelect);
}
else
{
m_itemsToSelect.Add(rangeWithItemsToSelect);
m_itemsToUnselect.Clear();
foreach (SelectionRangeWithItems selectedRangeWithItems in selectedItemsInChange)
{
m_itemsToUnselect.Add(selectedRangeWithItems);
}
}
this.UnselectAllCells();
return(selectionDone);
}
public int Add(SelectionRangeWithItems rangeWithItems)
{
Debug.Assert(!this.Contains(rangeWithItems.Range));
m_itemsCount += rangeWithItems.Length;
int count = m_list.Count;
if (count > 0)
{
int lastIndex = count - 1;
SelectionRangeWithItems lastRangeWithItems = m_list[lastIndex];
SelectionRange lastRange = lastRangeWithItems.Range;
if ((lastRange.EndIndex + 1) == rangeWithItems.Range.StartIndex)
{
Debug.Assert(rangeWithItems.Range.EndIndex > lastRange.EndIndex);
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
m_dataGridContext, rangeWithItems, ref lastRangeWithItems);
m_list[lastIndex] = lastRangeWithItems;
return(lastIndex);
}
else if ((lastRange.EndIndex - 1) == rangeWithItems.Range.StartIndex)
{
Debug.Assert(rangeWithItems.Range.EndIndex < lastRange.EndIndex);
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
m_dataGridContext, rangeWithItems, ref lastRangeWithItems);
m_list[lastIndex] = lastRangeWithItems;
return(lastIndex);
}
}
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(
m_dataGridContext, rangeWithItems, ref rangeWithItems);
m_list.Add(rangeWithItems);
return(m_list.Count - 1);
}
public void Add(SelectionRangeWithItems rangeWithItems)
{
Debug.Assert(!this.Contains(rangeWithItems.Range));
m_itemsCount += rangeWithItems.Length;
if (this.Count > 0)
{
var lastIndex = this.Count - 1;
var lastRangeWithItems = this[lastIndex];
var lastRange = lastRangeWithItems.Range;
if ((lastRange.EndIndex + 1) == rangeWithItems.Range.StartIndex)
{
Debug.Assert(rangeWithItems.Range.EndIndex > lastRange.EndIndex);
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(m_dataGridContext, rangeWithItems, ref lastRangeWithItems);
this[lastIndex] = lastRangeWithItems;
return;
}
else if ((lastRange.EndIndex - 1) == rangeWithItems.Range.StartIndex)
{
Debug.Assert(rangeWithItems.Range.EndIndex < lastRange.EndIndex);
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(m_dataGridContext, rangeWithItems, ref lastRangeWithItems);
this[lastIndex] = lastRangeWithItems;
return;
}
}
SelectedItemsStorage.UpdateSelectionRangeWithItemsFromAdd(m_dataGridContext, rangeWithItems, ref rangeWithItems);
this.Insert(this.Count, rangeWithItems, true);
}
public bool UnselectItems(SelectionRangeWithItems rangeWithItems)
{
if (!(m_owner.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase))
{
if (m_toDeferSelect.Count > 0)
{
foreach (object item in rangeWithItems.Items)
{
m_toDeferSelect.Remove(item);
}
}
}
SelectionRange range = rangeWithItems.Range;
if (range.IsEmpty)
{
// We have no index we have to remove based on item
bool selectionChanged = false;
List <SelectionRangeWithItems> itemsRangeToRemove = new List <SelectionRangeWithItems>();
List <object> itemsToUnselect = new List <object>(rangeWithItems.Items);
int count = itemsToUnselect.Count;
for (int i = count - 1; i >= 0; i--)
{
object itemToUnselect = itemsToUnselect[i];
bool selectionAdded = false;
foreach (SelectionRangeWithItems existingSelectionRangeWithItems in m_itemsToSelect)
{
int index = Array.IndexOf(existingSelectionRangeWithItems.Items, itemToUnselect);
if (index > -1)
{
selectionAdded = true;
itemsRangeToRemove.Add(
new SelectionRangeWithItems(
existingSelectionRangeWithItems.Range.GetIndexFromItemOffset(index),
itemToUnselect));
}
}
if (selectionAdded)
{
itemsToUnselect.RemoveAt(i);
}
}
// Remove the currently unselected item from the new range to select
foreach (SelectionRangeWithItems itemRangeToRemove in itemsRangeToRemove)
{
selectionChanged |= m_itemsToSelect.Remove(itemRangeToRemove);
}
count = itemsToUnselect.Count;
for (int i = 0; i < count; i++)
{
object itemToUnselect = itemsToUnselect[i];
foreach (SelectionRangeWithItems existingSelectionRangeWithItems in m_owner.SelectedItemsStore)
{
int index = Array.IndexOf(existingSelectionRangeWithItems.Items, itemToUnselect);
if (index >= 0)
{
index = existingSelectionRangeWithItems.Range.GetIndexFromItemOffset(index);
if (!m_itemsToUnselect.Contains(index))
{
selectionChanged = true;
m_itemsToUnselect.Add(new SelectionRangeWithItems(index, itemToUnselect));
}
}
}
}
return(selectionChanged);
}
if (range.Length == 1)
{
if (!m_itemsToSelect.Remove(rangeWithItems))
{
if (!m_owner.SelectedItemsStore.Contains(range))
{
return(false);
}
if (m_itemsToUnselect.Contains(range))
{
return(false);
}
m_itemsToUnselect.Add(rangeWithItems);
}
return(true);
}
else
{
SelectedItemsStorage tempStorage = new SelectedItemsStorage(m_owner);
tempStorage.Add(rangeWithItems);
// Remove the currently selected item from the new range to select
foreach (SelectionRangeWithItems existingSelectionRangeWithItems in m_itemsToSelect)
{
if (!range.Intersect(existingSelectionRangeWithItems.Range).IsEmpty)
{
tempStorage.Remove(existingSelectionRangeWithItems);
}
}
bool selectionChanged = m_itemsToSelect.Remove(rangeWithItems);
if (tempStorage.Count > 0)
{
selectionChanged = true;
foreach (SelectionRangeWithItems rangeWithItemsToAdd in tempStorage)
{
Debug.Assert(!m_itemsToUnselect.Contains(rangeWithItemsToAdd.Range));
m_itemsToUnselect.Add(rangeWithItemsToAdd);
}
}
return(selectionChanged);
}
}
internal SelectedItemsStorage(SelectedItemsStorage collection)
{
m_dataGridContext = collection.m_dataGridContext;
m_list = new List <SelectionRangeWithItems>(collection.m_list);
m_itemsCount = collection.m_itemsCount;
}
internal SelectionItemCollection(SelectedItemsStorage collection)
{
m_storage = collection;
}
public SelectionInfo GetSelectionInfo()
{
List<SelectionRangeWithItems> removedRangeWithItems;
List<SelectionRangeWithItems> unselectedItemsFromRemove = this.GetUnselectedItemsFromRemove( out removedRangeWithItems );
List<SelectionCellRangeWithItems> removedCellsRangeWithItems;
List<SelectionCellRangeWithItems> unselectedCellsFromRemove = this.GetUnselectedCellsFromRemove( out removedCellsRangeWithItems );
SelectedItemsStorage itemsToUnselect = new SelectedItemsStorage( m_itemsToUnselect );
SelectedCellsStorage cellsToUnselect = new SelectedCellsStorage( m_cellsToUnselect );
foreach( SelectionRangeWithItems rangeWithItems in unselectedItemsFromRemove )
{
itemsToUnselect.Add( rangeWithItems );
}
foreach( SelectionCellRangeWithItems cellRangeWithItems in unselectedCellsFromRemove )
{
cellsToUnselect.Add( cellRangeWithItems );
}
return new SelectionInfo(
m_owner, itemsToUnselect, new SelectedItemsStorage( m_itemsToSelect ),
cellsToUnselect, new SelectedCellsStorage( m_cellsToSelect ) );
}
public bool UnselectItems( SelectionRangeWithItems rangeWithItems )
{
if( !( m_owner.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase ) )
{
if( m_toDeferSelect.Count > 0 )
{
foreach( object item in rangeWithItems.Items )
{
m_toDeferSelect.Remove( item );
}
}
}
SelectionRange range = rangeWithItems.Range;
if( range.IsEmpty )
{
// We have no index we have to remove based on item
bool selectionChanged = false;
List<SelectionRangeWithItems> itemsRangeToRemove = new List<SelectionRangeWithItems>();
List<object> itemsToUnselect = new List<object>( rangeWithItems.Items );
int count = itemsToUnselect.Count;
for( int i = count - 1; i >= 0; i-- )
{
object itemToUnselect = itemsToUnselect[ i ];
bool selectionAdded = false;
foreach( SelectionRangeWithItems existingSelectionRangeWithItems in m_itemsToSelect )
{
int index = Array.IndexOf( existingSelectionRangeWithItems.Items, itemToUnselect );
if( index > -1 )
{
selectionAdded = true;
itemsRangeToRemove.Add(
new SelectionRangeWithItems(
existingSelectionRangeWithItems.Range.GetIndexFromItemOffset( index ),
itemToUnselect ) );
}
}
if( selectionAdded )
{
itemsToUnselect.RemoveAt( i );
}
}
// Remove the currently unselected item from the new range to select
foreach( SelectionRangeWithItems itemRangeToRemove in itemsRangeToRemove )
{
selectionChanged |= m_itemsToSelect.Remove( itemRangeToRemove );
}
count = itemsToUnselect.Count;
for( int i = 0; i < count; i++ )
{
object itemToUnselect = itemsToUnselect[ i ];
foreach( SelectionRangeWithItems existingSelectionRangeWithItems in m_owner.SelectedItemsStore )
{
int index = Array.IndexOf( existingSelectionRangeWithItems.Items, itemToUnselect );
if( index > -1 )
{
index = existingSelectionRangeWithItems.Range.GetIndexFromItemOffset( index );
if( !m_itemsToUnselect.Contains( index ) )
{
selectionChanged = true;
m_itemsToUnselect.Add( new SelectionRangeWithItems( index, itemToUnselect ) );
}
}
}
}
return selectionChanged;
}
if( range.Length == 1 )
{
if( !m_itemsToSelect.Remove( rangeWithItems ) )
{
if( !m_owner.SelectedItemsStore.Contains( range ) )
return false;
if( m_itemsToUnselect.Contains( range ) )
return false;
m_itemsToUnselect.Add( rangeWithItems );
}
return true;
}
else
{
SelectedItemsStorage tempStorage = new SelectedItemsStorage( m_owner, 8 );
tempStorage.Add( rangeWithItems );
// Remove the currently selected item from the new range to select
foreach( SelectionRangeWithItems existingSelectionRangeWithItems in m_itemsToSelect )
{
if( !range.Intersect( existingSelectionRangeWithItems.Range ).IsEmpty )
{
tempStorage.Remove( existingSelectionRangeWithItems );
}
}
bool selectionChanged = m_itemsToSelect.Remove( rangeWithItems );
if( tempStorage.Count > 0 )
{
selectionChanged = true;
foreach( SelectionRangeWithItems rangeWithItemsToAdd in tempStorage )
{
Debug.Assert( !m_itemsToUnselect.Contains( rangeWithItemsToAdd.Range ) );
m_itemsToUnselect.Add( rangeWithItemsToAdd );
}
}
return selectionChanged;
}
}
public void Visit(DataGridContext sourceContext, ref bool stopVisit)
{
object[] items;
CollectionView itemsCollection = sourceContext.Items;
int count = itemsCollection.Count;
if (count == 0)
{
return;
}
if (sourceContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase)
{
items = null;
}
else
{
items = new object[count];
for (int i = 0; i < count; i++)
{
items[i] = itemsCollection.GetItemAt(i);
}
}
SelectionRange itemRange = new SelectionRange(0, count - 1);
if (sourceContext.DataGridControl.SelectionUnit == SelectionUnit.Row)
{
sourceContext.DataGridControl.SelectionChangerManager.SelectItems(
sourceContext,
new SelectionRangeWithItems(itemRange, items));
}
else
{
HashedLinkedList <ColumnBase> columnsByVisiblePosition = sourceContext.ColumnsByVisiblePosition;
SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage(null);
SelectionRange fullColumnRange = new SelectionRange(0, columnsByVisiblePosition.Count - 1);
selectedColumnStore.Add(new SelectionRangeWithItems(fullColumnRange, null));
int index = 0;
foreach (ColumnBase column in columnsByVisiblePosition)
{
if (!column.Visible)
{
selectedColumnStore.Remove(new SelectionRangeWithItems(new SelectionRange(index), null));
}
index++;
}
int columnRangeCount = selectedColumnStore.Count;
for (int i = 0; i < columnRangeCount; i++)
{
sourceContext.DataGridControl.SelectionChangerManager.SelectCells(
sourceContext,
new SelectionCellRangeWithItems(itemRange, items, selectedColumnStore[i].Range));
}
}
}
private static RSTree1D <SelectionRangeWithItemsWrapper> .Area GetArea(SelectionRangeWithItems range)
{
return(SelectedItemsStorage.GetArea(range.Range));
}
public SelectionItemRangeCollection(SelectedItemsStorage list)
{
m_list = list;
}
internal SelectedItemsStorage( SelectedItemsStorage collection )
{
m_dataGridContext = collection.m_dataGridContext;
m_list = new List<SelectionRangeWithItems>( collection.m_list );
m_itemsCount = collection.m_itemsCount;
}
public bool SelectItems( SelectionRangeWithItems rangeWithItems )
{
SelectionRange range = rangeWithItems.Range;
if( !( m_owner.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase ) )
{
if( range.IsEmpty )
{
foreach( object item in rangeWithItems.Items )
{
if( !m_toDeferSelect.Contains( item ) )
m_toDeferSelect.Add( item );
}
return false;
}
}
else
{
if( range.IsEmpty )
throw new ArgumentException( "rangeWithItems.Range can't be empty when we are using a DataGridVirtualizingCollectionView", "rangeWithItems" );
}
if( rangeWithItems.Length == 1 )
{
if( !m_itemsToUnselect.Remove( rangeWithItems ) )
{
if( m_owner.SelectedItemsStore.Contains( rangeWithItems ) )
return false;
if( m_itemsToSelect.Contains( range ) )
return false;
this.m_itemsToSelect.Add( rangeWithItems );
}
return true;
}
else
{
bool selectionChanged = m_itemsToUnselect.Remove( rangeWithItems );
SelectedItemsStorage tempStorage = new SelectedItemsStorage( m_owner, 8 );
tempStorage.Add( rangeWithItems );
// Remove the currently selected item from the new range to select
foreach( SelectionRangeWithItems existingSelectionRangeWithItems in m_owner.SelectedItemsStore )
{
tempStorage.Remove( existingSelectionRangeWithItems );
}
// Remove the pending item to be selected from the new range to select
foreach( SelectionRangeWithItems existingSelectionRangeWithItems in m_itemsToSelect )
{
tempStorage.Remove( existingSelectionRangeWithItems );
}
if( tempStorage.Count > 0 )
{
selectionChanged = true;
foreach( SelectionRangeWithItems rangeWithItemsToAdd in tempStorage )
{
m_itemsToSelect.Add( rangeWithItemsToAdd );
}
}
return selectionChanged;
}
}
public bool SelectItems(SelectionRangeWithItems rangeWithItems)
{
SelectionRange range = rangeWithItems.Range;
if (!(m_owner.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase))
{
if (range.IsEmpty)
{
foreach (object item in rangeWithItems.Items)
{
if (!m_toDeferSelect.Contains(item))
{
m_toDeferSelect.Add(item);
}
}
return(false);
}
}
else
{
if (range.IsEmpty)
{
throw new ArgumentException("rangeWithItems.Range can't be empty when we are using a DataGridVirtualizingCollectionView", "rangeWithItems");
}
}
if (rangeWithItems.Length == 1)
{
if (!m_itemsToUnselect.Remove(rangeWithItems))
{
if (m_owner.SelectedItemsStore.Contains(rangeWithItems))
{
return(false);
}
if (m_itemsToSelect.Contains(range))
{
return(false);
}
this.m_itemsToSelect.Add(rangeWithItems);
}
return(true);
}
else
{
bool selectionChanged = m_itemsToUnselect.Remove(rangeWithItems);
SelectedItemsStorage tempStorage = new SelectedItemsStorage(m_owner);
tempStorage.Add(rangeWithItems);
// Remove the currently selected item from the new range to select
foreach (SelectionRangeWithItems existingSelectionRangeWithItems in m_owner.SelectedItemsStore)
{
tempStorage.Remove(existingSelectionRangeWithItems);
}
// Remove the pending item to be selected from the new range to select
foreach (SelectionRangeWithItems existingSelectionRangeWithItems in m_itemsToSelect)
{
tempStorage.Remove(existingSelectionRangeWithItems);
}
if (tempStorage.Count > 0)
{
selectionChanged = true;
foreach (SelectionRangeWithItems rangeWithItemsToAdd in tempStorage)
{
m_itemsToSelect.Add(rangeWithItemsToAdd);
}
}
return(selectionChanged);
}
}
private void DoRangeSelection(
DataGridContext oldCurrentDataGridContext,
object oldCurrentItem,
int oldCurrentColumnIndex,
DataGridContext dataGridContext,
int sourceDataItemIndex,
object item,
int columnIndex,
bool keepPreviousSelection,
bool fromRowSelector )
{
if( item == null )
return;
IDataGridContextVisitable visitable = ( IDataGridContextVisitable )m_owner.DataGridContext;
if( m_rangeSelectionItemStartAnchor == -1 )
{
if( ( oldCurrentDataGridContext != null ) && ( oldCurrentItem != null ) )
{
m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( oldCurrentDataGridContext, oldCurrentItem );
m_rangeSelectionColumnStartAnchor = oldCurrentColumnIndex;
}
else
{
m_rangeSelectionItemStartAnchor = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
m_rangeSelectionColumnStartAnchor = columnIndex;
}
}
if( !keepPreviousSelection )
{
this.UnselectAll();
}
int starting_index = m_rangeSelectionItemStartAnchor;
int ending_index = m_owner.GetGlobalGeneratorIndexFromItem( dataGridContext, item );
int min = Math.Min( starting_index, ending_index );
int max = Math.Max( starting_index, ending_index );
// here I need to normalize the values to ensure that I'm not catching the Fixed Headers or Fixed Footers
if( ( min != -1 ) && ( max != -1 ) )
{
SelectionRange[] selectedColumns;
if( m_owner.SelectionUnit == SelectionUnit.Row )
{
selectedColumns = null;
}
else
{
SelectionRange fullColumnRange;
// If called from a RowSelector, we do a range
// selection using all the columns no matter
// what was the previous anchor
if( fromRowSelector )
{
m_rangeSelectionColumnStartAnchor = 0;
fullColumnRange = new SelectionRange( 0, Math.Max( 0, dataGridContext.ColumnsByVisiblePosition.Count - 1 ) );
}
else
{
if( m_rangeSelectionColumnStartAnchor == -1 )
m_rangeSelectionColumnStartAnchor = 0;
if( columnIndex == -1 )
return;
fullColumnRange = new SelectionRange( m_rangeSelectionColumnStartAnchor, columnIndex );
}
SelectedItemsStorage selectedColumnStore = new SelectedItemsStorage( null, 8 );
selectedColumnStore.Add( new SelectionRangeWithItems( fullColumnRange, null ) );
int index = 0;
foreach( ColumnBase column in dataGridContext.ColumnsByVisiblePosition )
{
if( !column.Visible )
{
selectedColumnStore.Remove( new SelectionRangeWithItems( new SelectionRange( index ), null ) );
}
index++;
}
selectedColumns = selectedColumnStore.ToSelectionRangeArray();
}
bool visitWasStopped;
visitable.AcceptVisitor(
min, max,
new RangeSelectionVisitor( selectedColumns ),
DataGridContextVisitorType.ItemsBlock, out visitWasStopped );
}
}
public bool Contains(SelectionRange range)
{
return(m_map.Overlaps(SelectedItemsStorage.GetArea(range)));
}
public void UpdateSelectionAfterSourceDataItemReplaced(NotifyCollectionChangedEventArgs e)
{
Debug.Assert(e.OldItems.Count == e.NewItems.Count);
Debug.Assert(e.OldStartingIndex == e.NewStartingIndex);
SelectedItemsStorage selectedItemsStorage = m_owner.SelectedItemsStore;
SelectedCellsStorage selectedCellsStorage = m_owner.SelectedCellsStore;
int oldItemIndex = e.OldStartingIndex;
IList oldItems = e.OldItems;
IList newItems = e.NewItems;
int replacedItemCount = oldItems.Count;
int cellRangeCount = selectedCellsStorage.Count;
if (oldItemIndex >= 0)
{
int itemIndex = oldItemIndex;
for (int i = 0; i < replacedItemCount; i++)
{
object newItem = newItems[i];
if (selectedItemsStorage.Contains(itemIndex))
{
this.UnselectItems(new SelectionRangeWithItems(itemIndex, oldItems[i]));
this.SelectItems(new SelectionRangeWithItems(itemIndex, newItem));
}
SelectionCellRange replacedCellRange = new SelectionCellRange(
new SelectionRange(itemIndex), new SelectionRange(0, int.MaxValue - 1));
for (int j = 0; j < cellRangeCount; j++)
{
SelectionCellRangeWithItems cellRangeWithItems = selectedCellsStorage[j];
SelectionCellRange cellRange = cellRangeWithItems.CellRange;
if (!cellRange.Intersect(replacedCellRange).IsEmpty)
{
object[] items = cellRangeWithItems.ItemRangeWithItems.Items;
if (items != null)
{
items[cellRange.ItemRange.GetOffsetFromItemIndex(itemIndex)] = newItem;
}
}
}
itemIndex++;
}
}
else
{
CollectionView sourceItems = m_owner.Items;
for (int i = 0; i < replacedItemCount; i++)
{
object newItem = newItems[i];
int itemIndex = sourceItems.IndexOf(newItem);
if (itemIndex < 0)
{
continue;
}
if (selectedItemsStorage.Contains(itemIndex))
{
this.UnselectItems(new SelectionRangeWithItems(itemIndex, oldItems[i]));
this.SelectItems(new SelectionRangeWithItems(itemIndex, newItem));
}
SelectionCellRange replacedCellRange = new SelectionCellRange(
new SelectionRange(itemIndex), new SelectionRange(0, int.MaxValue - 1));
for (int j = 0; j < cellRangeCount; j++)
{
SelectionCellRangeWithItems cellRangeWithItems = selectedCellsStorage[j];
SelectionCellRange cellRange = cellRangeWithItems.CellRange;
if (!cellRange.Intersect(replacedCellRange).IsEmpty)
{
object[] items = cellRangeWithItems.ItemRangeWithItems.Items;
if (items != null)
{
items[cellRange.ItemRange.GetOffsetFromItemIndex(itemIndex)] = newItem;
}
}
}
}
}
}
internal SelectionItemRangeCollection(SelectedItemsStorage collection)
{
Debug.Assert(collection != null);
m_storage = collection;
}