public bool Contains(SelectionCellRangeWithItems rangeWithItems)
{
if ((m_unsortedRanges.Count <= 0) || (SelectedCellsStorage.IsEmpty(rangeWithItems)))
{
return(false);
}
if (rangeWithItems.Length == 1)
{
return(this.IndexOfOverlap(rangeWithItems).Any());
}
var store = new SelectedCellsStorage(null);
store.Add(rangeWithItems);
foreach (var match in this.IndexOfOverlap(rangeWithItems))
{
store.Remove(m_unsortedRanges[match].Value);
if (store.Count == 0)
{
return(true);
}
}
return(false);
}
public bool SelectCells(SelectionCellRangeWithItems cellRangeWithItems)
{
SelectionRange itemRange = cellRangeWithItems.ItemRange;
if (itemRange.IsEmpty)
{
throw new ArgumentException("cellRangeWithItems.ItemRange can't be empty", "cellRangeWithItems");
}
if (cellRangeWithItems.Length == 1)
{
if (!m_cellsToUnselect.Remove(cellRangeWithItems))
{
if (m_owner.SelectedCellsStore.Contains(cellRangeWithItems))
{
return(false);
}
if (m_cellsToSelect.Contains(cellRangeWithItems.CellRange))
{
return(false);
}
this.m_cellsToSelect.Add(cellRangeWithItems);
}
return(true);
}
else
{
bool selectionChanged = m_cellsToUnselect.Remove(cellRangeWithItems);
SelectedCellsStorage tempStorage = new SelectedCellsStorage(m_owner);
tempStorage.Add(cellRangeWithItems);
// Remove the currently selected item from the new range to select
foreach (SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_owner.SelectedCellsStore)
{
tempStorage.Remove(existingSelectionCellRangeWithItems);
}
// Remove the pending item to be selected from the new range to select
foreach (SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_cellsToSelect)
{
tempStorage.Remove(existingSelectionCellRangeWithItems);
}
if (tempStorage.Count > 0)
{
selectionChanged = true;
foreach (SelectionCellRangeWithItems cellRangeWithItemsToAdd in tempStorage)
{
m_cellsToSelect.Add(cellRangeWithItemsToAdd);
}
}
return(selectionChanged);
}
}
private void RemoveAt(int index, bool repairIndex)
{
var wrapper = m_ranges[index];
var rangeWithItems = wrapper.Value;
Debug.Assert(wrapper.Index == index);
if (!SelectedCellsStorage.IsEmpty(rangeWithItems))
{
var removed = m_map.Remove(SelectedCellsStorage.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 bool Contains(SelectionCellRange range)
{
if ((m_unsortedRanges.Count <= 0) || (SelectedCellsStorage.IsEmpty(range)))
{
return(false);
}
return(this.Contains(new SelectionCellRangeWithItems(range.ItemRange, null, range.ColumnRange)));
}
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 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 object Clone()
{
var copy = new SelectedCellsStorage(m_dataGridContext);
for (int i = 0; i < m_unsortedRanges.Count; i++)
{
copy.Insert(i, m_unsortedRanges[i].Value, false);
}
return(copy);
}
public bool Remove(SelectionCellRangeWithItems rangeWithItems)
{
if (SelectedCellsStorage.IsEmpty(rangeWithItems))
{
return(true);
}
// It improves performance to leave early and prevent empty enumerators creation.
if (m_ranges.Count <= 0)
{
return(false);
}
// The SelectionCellRange.IsEmpty should be mapped to the item range's SelectionRange.IsEmpty property.
Debug.Assert(!rangeWithItems.ItemRange.IsEmpty);
var matches = this.IndexOfOverlap(rangeWithItems).OrderBy(index => index).ToList();
var rangeToRemove = rangeWithItems.CellRange;
for (int i = matches.Count - 1; i >= 0; i--)
{
var index = matches[i];
var currentRangeWithItems = m_ranges[index].Value;
var currentRange = currentRangeWithItems.CellRange;
var overlap = rangeToRemove.Intersect(currentRange);
Debug.Assert(!overlap.IsEmpty);
var newRanges = currentRange.Exclude(overlap);
if (newRanges.Length == 0)
{
this.RemoveAt(index, true);
}
else
{
var currentRangeItems = currentRangeWithItems.ItemRangeWithItems;
this[index] = new SelectionCellRangeWithItems(newRanges[0].ItemRange, currentRangeItems.GetItems(newRanges[0].ItemRange), newRanges[0].ColumnRange);
if (newRanges.Length > 1)
{
for (int j = 1; j < newRanges.Length; j++)
{
this.Insert(index + j, new SelectionCellRangeWithItems(newRanges[j].ItemRange, currentRangeItems.GetItems(newRanges[j].ItemRange), newRanges[j].ColumnRange), false);
}
this.RepairIndex(index + 1);
}
}
}
return(matches.Count > 0);
}
internal ItemComparer(SelectionCellRangeWithItemsWrapper target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (SelectedCellsStorage.IsEmpty(target.Value))
{
throw new ArgumentException("The selection range must not be empty.", "target");
}
m_target = target;
}
public bool SelectJustThisCell(int itemIndex, object item, int columnIndex)
{
bool selectionDone = true;
m_toDeferSelect.Clear();
SelectionCellRangeWithItems rangeWithItemsToSelect =
new SelectionCellRangeWithItems(itemIndex, item, columnIndex);
SelectionCellRange cellRange = rangeWithItemsToSelect.CellRange;
if (m_cellsToSelect.Contains(cellRange))
{
selectionDone = false;
}
m_cellsToSelect.Clear();
SelectedCellsStorage selectedCellsInChange = m_owner.SelectedCellsStore;
if (selectedCellsInChange.Contains(cellRange))
{
if (!m_cellsToUnselect.Contains(cellRange))
{
selectionDone = false;
}
m_cellsToUnselect.Clear();
foreach (SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange)
{
m_cellsToUnselect.Add(selectedCellRangeWithItems);
}
m_cellsToUnselect.Remove(rangeWithItemsToSelect);
}
else
{
m_cellsToSelect.Add(rangeWithItemsToSelect);
m_cellsToUnselect.Clear();
foreach (SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange)
{
m_cellsToUnselect.Add(selectedCellRangeWithItems);
}
}
this.UnselectAllItems();
return(selectionDone);
}
public bool Contains(SelectionCellRangeWithItems cellRangeWithItemsToCompare)
{
int count = m_list.Count;
SelectionCellRange cellRangeToCompare = cellRangeWithItemsToCompare.CellRange;
int cellRangeLength = cellRangeToCompare.Length;
// If there is more than one Cell in the range, ensure
// the range is completely contained within this SelectedCellsStorage
if (cellRangeLength > 1)
{
SelectedCellsStorage cellStorage = new SelectedCellsStorage(null, cellRangeLength);
cellStorage.Add(cellRangeWithItemsToCompare);
// The range is completely contained when the store
// is empty after removing all ranges contained within
// this SelectedCellsStorage
for (int i = 0; i < count; i++)
{
SelectionCellRangeWithItems cellRangeWithItems = m_list[i];
cellStorage.Remove(cellRangeWithItems);
if (cellStorage.Count == 0)
{
return(true);
}
}
}
else
{
for (int i = 0; i < count; i++)
{
SelectionCellRangeWithItems rangeWithItem = m_list[i];
SelectionCellRange rangeIntersection = rangeWithItem.CellRange.Intersect(cellRangeToCompare);
if (!rangeIntersection.IsEmpty)
{
if (cellRangeWithItemsToCompare.ItemRangeWithItems.IsItemsEqual(
rangeIntersection.ItemRange, rangeWithItem.ItemRangeWithItems))
{
return(true);
}
}
}
}
return(false);
}
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, SelectionCellRangeWithItems item, bool repairIndex)
{
var wrapper = new SelectionCellRangeWithItemsWrapper(item, index);
m_ranges.Insert(index, wrapper);
if (repairIndex)
{
this.RepairIndex(index + 1);
}
if (!SelectedCellsStorage.IsEmpty(item))
{
m_map.Add(SelectedCellsStorage.GetArea(item), wrapper);
}
}
private IEnumerable <int> IndexOfOverlap(SelectionCellRange target)
{
if ((m_sortedRanges.Count <= 0) || SelectedCellsStorage.IsEmpty(target))
{
yield break;
}
var comparer = new ItemRangeComparer(target.ItemRange);
var index = this.FindIndex(comparer);
if (index < 0)
{
yield break;
}
while (index > 0)
{
if (comparer.Compare(m_sortedRanges[index - 1]) != 0)
{
break;
}
index--;
}
for (int i = index; i < m_sortedRanges.Count; i++)
{
var wrapper = m_sortedRanges[i];
if (comparer.Compare(wrapper) != 0)
{
break;
}
var currentRangeWithItems = wrapper.Value;
var overlap = target.Intersect(currentRangeWithItems.CellRange);
if (!SelectedCellsStorage.IsEmpty(overlap))
{
yield return(wrapper.Index);
}
}
}
private void Insert(int index, SelectionCellRangeWithItems item, bool repairIndex)
{
var wrapper = new SelectionCellRangeWithItemsWrapper(item, index);
m_unsortedRanges.Insert(index, wrapper);
if (repairIndex)
{
this.RepairIndex(index + 1);
}
if (!SelectedCellsStorage.IsEmpty(item))
{
var insertionIndex = ~this.FindIndex(new ItemComparer(wrapper));
Debug.Assert(insertionIndex >= 0);
m_sortedRanges.Insert(insertionIndex, wrapper);
}
}
private void RemoveAt(int index, bool repairIndex)
{
var wrapper = m_unsortedRanges[index];
Debug.Assert(wrapper.Index == index);
if (!SelectedCellsStorage.IsEmpty(wrapper.Value))
{
var removalIndex = this.FindIndex(new ItemComparer(wrapper));
Debug.Assert(removalIndex >= 0);
m_sortedRanges.RemoveAt(removalIndex);
}
m_unsortedRanges.RemoveAt(index);
if (repairIndex)
{
this.RepairIndex(index);
}
}
private IEnumerable <int> IndexOfOverlap(SelectionCellRange range)
{
// It improves performance to leave early.
if (m_map.Count <= 0)
{
yield break;
}
foreach (var entry in m_map.GetEntriesWithin(SelectedCellsStorage.GetArea(range)))
{
var candidate = entry.Item;
var target = candidate.Value;
var overlap = range.Intersect(target.CellRange);
Debug.Assert(!SelectedCellsStorage.IsEmpty(overlap));
if (!SelectedCellsStorage.IsEmpty(overlap))
{
yield return(candidate.Index);
}
}
}
public bool Contains(SelectionCellRange cellRange)
{
int count = m_list.Count;
int cellRangeLength = cellRange.Length;
// Ensure every Cells are present in the SelectedCellsStorage
if (cellRangeLength > 1)
{
SelectedCellsStorage cellStorage = new SelectedCellsStorage(null, cellRangeLength);
cellStorage.Add(new SelectionCellRangeWithItems(cellRange.ItemRange,
null,
cellRange.ColumnRange));
for (int i = 0; i < count; i++)
{
cellStorage.Remove(m_list[i]);
if (cellStorage.Count == 0)
{
return(true);
}
}
}
else
{
for (int i = 0; i < count; i++)
{
if (!m_list[i].CellRange.Intersect(cellRange).IsEmpty)
{
return(true);
}
}
}
return(false);
}
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 ) );
}
internal SelectedCellsStorage(SelectedCellsStorage collection)
{
m_dataGridContext = collection.m_dataGridContext;
m_list = new List <SelectionCellRangeWithItems>(collection.m_list);
m_cellsCount = collection.m_cellsCount;
}
public SelectionCellRangeCollection(SelectedCellsStorage list)
{
m_list = list;
}
public bool ToggleItemCellsSelection(
DataGridContext dataGridContext,
int itemIndex,
object item )
{
SelectionRange itemRange = new SelectionRange( itemIndex );
SelectionRange cellRange = new SelectionRange( 0,
Math.Max( 0, dataGridContext.Columns.Count - 1 ) );
// Select all visible cells for this itemIndex
SelectionCellRangeWithItems selection = new SelectionCellRangeWithItems( itemRange,
new object[] { item },
cellRange );
SelectedCellsStorage tempStorage = new SelectedCellsStorage( null, 1 );
tempStorage.Add( selection );
foreach( ColumnBase column in dataGridContext.ColumnsByVisiblePosition )
{
if( !column.Visible )
tempStorage.Remove( new SelectionCellRangeWithItems( itemIndex, item, column.VisiblePosition ) );
}
int tempStorageCount = tempStorage.Count;
bool allCellSelected = true;
foreach( SelectionCellRangeWithItems allCellSelection in tempStorage )
{
if( !dataGridContext.SelectedCellsStore.Contains( allCellSelection ) )
{
allCellSelected = false;
break;
}
}
bool selectionDone = true;
if( allCellSelected )
{
foreach( SelectionCellRangeWithItems allCellSelection in tempStorage )
{
selectionDone &= this.UnselectCells( dataGridContext, allCellSelection );
}
}
else
{
foreach( SelectionCellRangeWithItems allCellSelection in tempStorage )
{
selectionDone &= this.SelectCells( dataGridContext, allCellSelection );
}
}
return selectionDone;
}
internal SelectedCellsStorage( SelectedCellsStorage collection )
{
m_dataGridContext = collection.m_dataGridContext;
m_list = new List<SelectionCellRangeWithItems>( collection.m_list );
m_cellsCount = collection.m_cellsCount;
}
public bool UnselectCells( SelectionCellRangeWithItems cellRangeWithItems )
{
SelectionRange itemRange = cellRangeWithItems.ItemRange;
SelectionRange columnRange = cellRangeWithItems.ColumnRange;
SelectionCellRange cellRange = cellRangeWithItems.CellRange;
if( itemRange.IsEmpty )
{
// We have no index we have to remove based on item
bool selectionChanged = false;
List<SelectionCellRangeWithItems> cellsRangeToRemove = new List<SelectionCellRangeWithItems>();
List<object> itemsToUnselect = new List<object>( cellRangeWithItems.ItemRangeWithItems.Items );
int count = itemsToUnselect.Count;
for( int i = count - 1; i >= 0; i-- )
{
object itemToUnselect = itemsToUnselect[ i ];
foreach( SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_cellsToSelect )
{
SelectionRange columnIntersection = columnRange.Intersect( existingSelectionCellRangeWithItems.ColumnRange );
if( columnIntersection.IsEmpty )
continue;
int index = Array.IndexOf( existingSelectionCellRangeWithItems.ItemRangeWithItems.Items, itemToUnselect );
if( index > -1 )
{
cellsRangeToRemove.Add(
new SelectionCellRangeWithItems(
new SelectionRange( existingSelectionCellRangeWithItems.ItemRange.GetIndexFromItemOffset( index ) ),
new object[] { itemToUnselect },
columnIntersection ) );
}
}
}
// Remove the currently unselected item from the new range to select
foreach( SelectionCellRangeWithItems cellRangeToRemove in cellsRangeToRemove )
{
selectionChanged |= m_cellsToSelect.Remove( cellRangeToRemove );
}
count = itemsToUnselect.Count;
for( int i = 0; i < count; i++ )
{
object itemToUnselect = itemsToUnselect[ i ];
foreach( SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_owner.SelectedCellsStore )
{
SelectionRange columnIntersection = columnRange.Intersect( existingSelectionCellRangeWithItems.ColumnRange );
if( columnIntersection.IsEmpty )
continue;
int index = Array.IndexOf( existingSelectionCellRangeWithItems.ItemRangeWithItems.Items, itemToUnselect );
if( index > -1 )
{
index = existingSelectionCellRangeWithItems.ItemRange.GetIndexFromItemOffset( index );
SelectionCellRange cellRangeTemp = new SelectionCellRange(
new SelectionRange( existingSelectionCellRangeWithItems.ItemRange.GetIndexFromItemOffset( index ) ),
columnIntersection );
if( !m_cellsToUnselect.Contains( cellRangeTemp ) )
{
selectionChanged = true;
m_cellsToUnselect.Add( new SelectionCellRangeWithItems(
cellRangeTemp.ItemRange, new object[] { itemToUnselect }, cellRangeTemp.ColumnRange ) );
}
}
}
}
return selectionChanged;
}
if( cellRangeWithItems.Length == 1 )
{
if( !m_cellsToSelect.Remove( cellRangeWithItems ) )
{
if( !m_owner.SelectedCellsStore.Contains( cellRange ) )
return false;
if( m_cellsToUnselect.Contains( cellRange ) )
return false;
m_cellsToUnselect.Add( cellRangeWithItems );
}
return true;
}
else
{
SelectedCellsStorage tempStorage = new SelectedCellsStorage( m_owner, 8 );
tempStorage.Add( cellRangeWithItems );
// Remove the currently selected item from the new range to select
foreach( SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_cellsToSelect )
{
tempStorage.Remove( existingSelectionCellRangeWithItems );
}
bool selectionChanged = m_cellsToSelect.Remove( cellRangeWithItems );
if( tempStorage.Count > 0 )
{
selectionChanged = true;
foreach( SelectionCellRangeWithItems cellRangeWithItemsToAdd in tempStorage )
{
Debug.Assert( !m_cellsToUnselect.Contains( cellRangeWithItemsToAdd.CellRange ) );
m_cellsToUnselect.Add( cellRangeWithItemsToAdd );
}
}
return selectionChanged;
}
}
public bool SelectItemCells(
int itemIndex,
object item,
HashedLinkedList <ColumnBase> columnsByVisiblePosition,
bool preserveSelection)
{
bool selectionDone = true;
int columnsCount = columnsByVisiblePosition.Count;
m_toDeferSelect.Clear();
SelectionCellRangeWithItems rangeWithItemsToSelect =
new SelectionCellRangeWithItems(
new SelectionRange(itemIndex),
new object[] { item },
new SelectionRange(0, columnsCount - 1));
SelectionCellRange cellRange = rangeWithItemsToSelect.CellRange;
m_cellsToSelect.Clear();
SelectedCellsStorage selectedCellsInChange = m_owner.SelectedCellsStore;
// Remove all currently selected Cells from the new selectionRange
// to avoid duplicate SelectionCellRange
SelectedCellsStorage tempStorage = new SelectedCellsStorage(null);
tempStorage.Add(rangeWithItemsToSelect);
for (int i = 0; i < selectedCellsInChange.Count; i++)
{
tempStorage.Remove(selectedCellsInChange[i]);
}
foreach (ColumnBase column in columnsByVisiblePosition)
{
if (!column.Visible)
{
tempStorage.Remove(new SelectionCellRangeWithItems(itemIndex, item, column.VisiblePosition));
}
}
int tempStorageCount = tempStorage.Count;
// All Cells are already selected
if (tempStorageCount == 0)
{
if (!m_cellsToUnselect.Contains(cellRange))
{
selectionDone = false;
}
m_cellsToUnselect.Clear();
if (!preserveSelection)
{
foreach (SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange)
{
m_cellsToUnselect.Add(selectedCellRangeWithItems);
}
}
m_cellsToUnselect.Remove(rangeWithItemsToSelect);
}
else
{
// Add each range to selection
for (int i = 0; i < tempStorageCount; i++)
{
m_cellsToSelect.Add(tempStorage[i]);
}
m_cellsToUnselect.Clear();
if (!preserveSelection)
{
foreach (SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange)
{
tempStorage = new SelectedCellsStorage(null);
tempStorage.Add(selectedCellRangeWithItems);
tempStorage.Remove(rangeWithItemsToSelect);
tempStorageCount = tempStorage.Count;
for (int i = 0; i < tempStorageCount; i++)
{
m_cellsToUnselect.Add(tempStorage[i]);
}
}
}
}
if (!preserveSelection)
{
this.UnselectAllItems();
}
return(selectionDone);
}
public bool SelectItemCells(
int itemIndex,
object item,
HashedLinkedList<ColumnBase> columnsByVisiblePosition,
bool preserveSelection )
{
bool selectionDone = true;
int columnsCount = columnsByVisiblePosition.Count;
m_toDeferSelect.Clear();
SelectionCellRangeWithItems rangeWithItemsToSelect =
new SelectionCellRangeWithItems(
new SelectionRange( itemIndex ),
new object[] { item },
new SelectionRange( 0, columnsCount - 1 ) );
SelectionCellRange cellRange = rangeWithItemsToSelect.CellRange;
m_cellsToSelect.Clear();
SelectedCellsStorage selectedCellsInChange = m_owner.SelectedCellsStore;
// Remove all currently selected Cells from the new selectionRange
// to avoid duplicate SelectionCellRange
SelectedCellsStorage tempStorage = new SelectedCellsStorage( null, 1 );
tempStorage.Add( rangeWithItemsToSelect );
for( int i = 0; i < selectedCellsInChange.Count; i++ )
{
tempStorage.Remove( selectedCellsInChange[ i ] );
}
foreach( ColumnBase column in columnsByVisiblePosition )
{
if( !column.Visible )
tempStorage.Remove( new SelectionCellRangeWithItems( itemIndex, item, column.VisiblePosition ) );
}
int tempStorageCount = tempStorage.Count;
// All Cells are already selected
if( tempStorageCount == 0 )
{
if( !m_cellsToUnselect.Contains( cellRange ) )
selectionDone = false;
m_cellsToUnselect.Clear();
if( !preserveSelection )
{
foreach( SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange )
{
m_cellsToUnselect.Add( selectedCellRangeWithItems );
}
}
m_cellsToUnselect.Remove( rangeWithItemsToSelect );
}
else
{
// Add each range to selection
for( int i = 0; i < tempStorageCount; i++ )
{
m_cellsToSelect.Add( tempStorage[ i ] );
}
m_cellsToUnselect.Clear();
if( !preserveSelection )
{
foreach( SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange )
{
tempStorage = new SelectedCellsStorage( null, 1 );
tempStorage.Add( selectedCellRangeWithItems );
tempStorage.Remove( rangeWithItemsToSelect );
tempStorageCount = tempStorage.Count;
for( int i = 0; i < tempStorageCount; i++ )
{
m_cellsToUnselect.Add( tempStorage[ i ] );
}
}
}
}
if( !preserveSelection )
this.UnselectAllItems();
return selectionDone;
}
private static RSTree2D <SelectionCellRangeWithItemsWrapper> .Area GetArea(SelectionCellRangeWithItems range)
{
return(SelectedCellsStorage.GetArea(range.CellRange));
}
public bool UnselectCells(SelectionCellRangeWithItems cellRangeWithItems)
{
SelectionRange itemRange = cellRangeWithItems.ItemRange;
SelectionRange columnRange = cellRangeWithItems.ColumnRange;
SelectionCellRange cellRange = cellRangeWithItems.CellRange;
if (itemRange.IsEmpty)
{
// We have no index we have to remove based on item
bool selectionChanged = false;
List <SelectionCellRangeWithItems> cellsRangeToRemove = new List <SelectionCellRangeWithItems>();
List <object> itemsToUnselect = new List <object>(cellRangeWithItems.ItemRangeWithItems.Items);
int count = itemsToUnselect.Count;
for (int i = count - 1; i >= 0; i--)
{
object itemToUnselect = itemsToUnselect[i];
foreach (SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_cellsToSelect)
{
SelectionRange columnIntersection = columnRange.Intersect(existingSelectionCellRangeWithItems.ColumnRange);
if (columnIntersection.IsEmpty)
{
continue;
}
int index = Array.IndexOf(existingSelectionCellRangeWithItems.ItemRangeWithItems.Items, itemToUnselect);
if (index > -1)
{
cellsRangeToRemove.Add(
new SelectionCellRangeWithItems(
new SelectionRange(existingSelectionCellRangeWithItems.ItemRange.GetIndexFromItemOffset(index)),
new object[] { itemToUnselect },
columnIntersection));
}
}
}
// Remove the currently unselected item from the new range to select
foreach (SelectionCellRangeWithItems cellRangeToRemove in cellsRangeToRemove)
{
selectionChanged |= m_cellsToSelect.Remove(cellRangeToRemove);
}
count = itemsToUnselect.Count;
for (int i = 0; i < count; i++)
{
object itemToUnselect = itemsToUnselect[i];
foreach (SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_owner.SelectedCellsStore)
{
SelectionRange columnIntersection = columnRange.Intersect(existingSelectionCellRangeWithItems.ColumnRange);
if (columnIntersection.IsEmpty)
{
continue;
}
int index = Array.IndexOf(existingSelectionCellRangeWithItems.ItemRangeWithItems.Items, itemToUnselect);
if (index > -1)
{
index = existingSelectionCellRangeWithItems.ItemRange.GetIndexFromItemOffset(index);
SelectionCellRange cellRangeTemp = new SelectionCellRange(
new SelectionRange(existingSelectionCellRangeWithItems.ItemRange.GetIndexFromItemOffset(index)),
columnIntersection);
if (!m_cellsToUnselect.Contains(cellRangeTemp))
{
selectionChanged = true;
m_cellsToUnselect.Add(new SelectionCellRangeWithItems(
cellRangeTemp.ItemRange, new object[] { itemToUnselect }, cellRangeTemp.ColumnRange));
}
}
}
}
return(selectionChanged);
}
if (cellRangeWithItems.Length == 1)
{
if (!m_cellsToSelect.Remove(cellRangeWithItems))
{
if (!m_owner.SelectedCellsStore.Contains(cellRange))
{
return(false);
}
if (m_cellsToUnselect.Contains(cellRange))
{
return(false);
}
m_cellsToUnselect.Add(cellRangeWithItems);
}
return(true);
}
else
{
SelectedCellsStorage tempStorage = new SelectedCellsStorage(m_owner);
tempStorage.Add(cellRangeWithItems);
// Remove the currently selected item from the new range to select
foreach (SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_cellsToSelect)
{
tempStorage.Remove(existingSelectionCellRangeWithItems);
}
bool selectionChanged = m_cellsToSelect.Remove(cellRangeWithItems);
if (tempStorage.Count > 0)
{
selectionChanged = true;
foreach (SelectionCellRangeWithItems cellRangeWithItemsToAdd in tempStorage)
{
Debug.Assert(!m_cellsToUnselect.Contains(cellRangeWithItemsToAdd.CellRange));
m_cellsToUnselect.Add(cellRangeWithItemsToAdd);
}
}
return(selectionChanged);
}
}
internal SelectionCellRangeCollection(SelectedCellsStorage collection)
{
Debug.Assert(collection != null);
m_storage = collection;
}
public bool Contains( SelectionCellRange cellRange )
{
int count = m_list.Count;
int cellRangeLength = cellRange.Length;
// Ensure every Cells are present in the SelectedCellsStorage
if( cellRangeLength > 1 )
{
SelectedCellsStorage cellStorage = new SelectedCellsStorage( null, cellRangeLength );
cellStorage.Add( new SelectionCellRangeWithItems( cellRange.ItemRange,
null,
cellRange.ColumnRange ) );
for( int i = 0; i < count; i++ )
{
cellStorage.Remove( m_list[ i ] );
if( cellStorage.Count == 0 )
return true;
}
}
else
{
for( int i = 0; i < count; i++ )
{
if( !m_list[ i ].CellRange.Intersect( cellRange ).IsEmpty )
return true;
}
}
return false;
}
public bool Contains( SelectionCellRangeWithItems cellRangeWithItemsToCompare )
{
int count = m_list.Count;
SelectionCellRange cellRangeToCompare = cellRangeWithItemsToCompare.CellRange;
int cellRangeLength = cellRangeToCompare.Length;
// If there is more than one Cell in the range, ensure
// the range is completely contained within this SelectedCellsStorage
if( cellRangeLength > 1 )
{
SelectedCellsStorage cellStorage = new SelectedCellsStorage( null, cellRangeLength );
cellStorage.Add( cellRangeWithItemsToCompare );
// The range is completely contained when the store
// is empty after removing all ranges contained within
// this SelectedCellsStorage
for( int i = 0; i < count; i++ )
{
SelectionCellRangeWithItems cellRangeWithItems = m_list[ i ];
cellStorage.Remove( cellRangeWithItems );
if( cellStorage.Count == 0 )
return true;
}
}
else
{
for( int i = 0; i < count; i++ )
{
SelectionCellRangeWithItems rangeWithItem = m_list[ i ];
SelectionCellRange rangeIntersection = rangeWithItem.CellRange.Intersect( cellRangeToCompare );
if( !rangeIntersection.IsEmpty )
{
if( cellRangeWithItemsToCompare.ItemRangeWithItems.IsItemsEqual(
rangeIntersection.ItemRange, rangeWithItem.ItemRangeWithItems ) )
{
return true;
}
}
}
}
return false;
}
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;
}
}
}
}
}
}
public bool SelectCells( SelectionCellRangeWithItems cellRangeWithItems )
{
SelectionRange itemRange = cellRangeWithItems.ItemRange;
if( itemRange.IsEmpty )
throw new ArgumentException( "cellRangeWithItems.ItemRange can't be empty", "cellRangeWithItems" );
if( cellRangeWithItems.Length == 1 )
{
if( !m_cellsToUnselect.Remove( cellRangeWithItems ) )
{
if( m_owner.SelectedCellsStore.Contains( cellRangeWithItems ) )
return false;
if( m_cellsToSelect.Contains( cellRangeWithItems.CellRange ) )
return false;
this.m_cellsToSelect.Add( cellRangeWithItems );
}
return true;
}
else
{
bool selectionChanged = m_cellsToUnselect.Remove( cellRangeWithItems );
SelectedCellsStorage tempStorage = new SelectedCellsStorage( m_owner, 8 );
tempStorage.Add( cellRangeWithItems );
// Remove the currently selected item from the new range to select
foreach( SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_owner.SelectedCellsStore )
{
tempStorage.Remove( existingSelectionCellRangeWithItems );
}
// Remove the pending item to be selected from the new range to select
foreach( SelectionCellRangeWithItems existingSelectionCellRangeWithItems in m_cellsToSelect )
{
tempStorage.Remove( existingSelectionCellRangeWithItems );
}
if( tempStorage.Count > 0 )
{
selectionChanged = true;
foreach( SelectionCellRangeWithItems cellRangeWithItemsToAdd in tempStorage )
{
m_cellsToSelect.Add( cellRangeWithItemsToAdd );
}
}
return selectionChanged;
}
}