public bool IsItemsEqual(SelectionRange rangeIntersection, SelectionRangeWithItems rangeWithItemsToCompare) { object[] itemsToCompare = rangeWithItemsToCompare.m_items; if ((m_items == null) || (itemsToCompare == null)) { return(true); } SelectionRange rangeToCompare = rangeWithItemsToCompare.Range; int startIndex = Math.Min(rangeIntersection.StartIndex, rangeIntersection.EndIndex); int itemIndex1 = Math.Abs(startIndex - m_range.StartIndex); int itemIndex2 = Math.Abs(startIndex - rangeToCompare.StartIndex); bool inversedRange1 = m_range.StartIndex > m_range.EndIndex; bool inversedRange2 = rangeToCompare.StartIndex > rangeToCompare.EndIndex; int count = rangeIntersection.Length; for (int i = 0; i < count; i++) { if (!object.Equals(m_items[itemIndex1], itemsToCompare[itemIndex2])) { return(false); } itemIndex1 = inversedRange1 ? itemIndex1 - 1 : itemIndex1 + 1; itemIndex2 = inversedRange2 ? itemIndex2 - 1 : itemIndex2 + 1; } return(true); }
public int IndexOf(object item) { int indexOffset = 0; int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; object[] items = rangeWithItems.Items; if (items != null) { int index = Array.IndexOf <object>(items, item); if (index != -1) { return(indexOffset + index); } } indexOffset += rangeWithItems.Length; } return(-1); }
public object this[int index] { get { if ((index < 0) || (index >= m_list.ItemsCount)) { throw new ArgumentOutOfRangeException("index", "The index must be equal or greater than zero and less than Count."); } int oldIndexOffset = 0; int indexOffset = 0; int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; indexOffset += rangeWithItems.Length; if (index < indexOffset) { return(rangeWithItems.GetItem(m_list.DataGridContext, index - oldIndexOffset)); } oldIndexOffset = indexOffset; } throw new ArgumentOutOfRangeException("index", "The index must be less than Count."); } set { throw new NotSupportedException(); } }
public SelectionCellRangeWithItems( SelectionRange itemRange, object[] items, SelectionRange columnRange ) { if( ( items != null ) && ( items.Length != itemRange.Length ) ) throw new ArgumentException( "itemRange and items must have the same length." ); m_itemRangeWithItems = new SelectionRangeWithItems( itemRange, items ); m_columnRange = columnRange; }
public void Visit( DataGridContext sourceContext, int startSourceDataItemIndex, int endSourceDataItemIndex, ref bool stopVisit ) { SelectionManager selectionChangerManager = sourceContext.DataGridControl.SelectionChangerManager; if( m_selectedColumns != null ) { int columnCount = sourceContext.Columns.Count; if( columnCount == 0 ) return; SelectionRange contextColumnMaxRange = new SelectionRange( 0, columnCount - 1 ); for( int i = 0; i < m_selectedColumns.Length; i++ ) { SelectionRange selectionRange = m_selectedColumns[ i ]; SelectionRange intersectionSelectionRange = selectionRange.Intersect( contextColumnMaxRange ); if( intersectionSelectionRange.IsEmpty ) continue; #if DEBUG string action = ( m_unselect ) ? "Removing" : "Adding"; Debug.WriteLine( "Selection : " + action + " cell : (" + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() + ") - (" + intersectionSelectionRange.StartIndex.ToString() + " - " + intersectionSelectionRange.EndIndex.ToString() + ")" ); #endif var cellRange = new SelectionCellRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null, intersectionSelectionRange ); if( m_unselect ) { selectionChangerManager.UnselectCells( sourceContext, cellRange ); } else { selectionChangerManager.SelectCells( sourceContext, cellRange ); } } } else { #if DEBUG string action = ( m_unselect ) ? "Removing" : "Adding"; Debug.WriteLine( "Selection : " + action + " Adding item : " + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() ); #endif var itemRange = new SelectionRangeWithItems( new SelectionRange( startSourceDataItemIndex, endSourceDataItemIndex ), null ); if( m_unselect ) { selectionChangerManager.UnselectItems( sourceContext, itemRange ); } else { selectionChangerManager.SelectItems( sourceContext, itemRange ); } } }
public SelectionCellRangeWithItems(SelectionRange itemRange, object[] items, SelectionRange columnRange) { if ((items != null) && (items.Length != itemRange.Length)) { throw new ArgumentException("itemRange and items must have the same length."); } m_itemRangeWithItems = new SelectionRangeWithItems(itemRange, items); m_columnRange = columnRange; }
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); }
public void Visit(DataGridContext sourceContext, int startSourceDataItemIndex, int endSourceDataItemIndex, ref bool stopVisit) { SelectionManager selectionChangerManager = sourceContext.DataGridControl.SelectionChangerManager; if (m_selectedColumns != null) { int columnCount = sourceContext.Columns.Count; if (columnCount == 0) { return; } SelectionRange contextColumnMaxRange = new SelectionRange(0, columnCount - 1); for (int i = 0; i < m_selectedColumns.Length; i++) { SelectionRange selectionRange = m_selectedColumns[i]; SelectionRange intersectionSelectionRange = selectionRange.Intersect(contextColumnMaxRange); if (intersectionSelectionRange.IsEmpty) { continue; } var cellRange = new SelectionCellRangeWithItems(new SelectionRange(startSourceDataItemIndex, endSourceDataItemIndex), null, intersectionSelectionRange); if (m_unselect) { selectionChangerManager.UnselectCells(sourceContext, cellRange); } else { selectionChangerManager.SelectCells(sourceContext, cellRange); } } } else { var itemRange = new SelectionRangeWithItems(new SelectionRange(startSourceDataItemIndex, endSourceDataItemIndex), null); if (m_unselect) { selectionChangerManager.UnselectItems(sourceContext, itemRange); } else { selectionChangerManager.SelectItems(sourceContext, itemRange); } } }
public SelectionRangeWithItems this[int index] { get { return(m_list[index]); } set { SelectionRangeWithItems oldRangeWithItems = m_list[index]; m_list[index] = value; m_itemsCount += value.Length - oldRangeWithItems.Length; } }
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)); }
public void UpdateSelectionAfterSourceDataItemRemoved(NotifyCollectionChangedEventArgs e) { int oldStartingIndex = e.OldStartingIndex; IList removedItemsList = e.OldItems; int removedItemsCount = removedItemsList.Count; m_sourceChanges.Add(new SourceChangeInfo(e.Action, oldStartingIndex, removedItemsCount, removedItemsList)); if (oldStartingIndex == -1) { foreach (object item in removedItemsList) { SelectionRangeWithItems rangeWithItemsToRemove = new SelectionRangeWithItems(SelectionRange.Empty, new object[] { item }); m_itemsToSelect.Remove(rangeWithItemsToRemove); m_itemsToUnselect.Remove(rangeWithItemsToRemove); SelectionCellRangeWithItems cellRangeWithItemsToRemove = new SelectionCellRangeWithItems( SelectionRange.Empty, new object[] { item }, new SelectionRange(0, int.MaxValue - 1)); m_cellsToSelect.Remove(cellRangeWithItemsToRemove); m_cellsToUnselect.Remove(cellRangeWithItemsToRemove); } // Seek out in a max range of removedItemsCount the new position for actually selected item. m_itemsToSelect.OffsetIndexBasedOnSourceNewIndex(-removedItemsCount); m_itemsToUnselect.OffsetIndexBasedOnSourceNewIndex(-removedItemsCount); m_cellsToSelect.OffsetIndexBasedOnSourceNewIndex(-removedItemsCount); m_cellsToUnselect.OffsetIndexBasedOnSourceNewIndex(-removedItemsCount); } else { SelectionRange itemRange = new SelectionRange(oldStartingIndex, oldStartingIndex + removedItemsCount - 1); SelectionRangeWithItems rangeWithItemsToRemove = new SelectionRangeWithItems(itemRange, null); m_itemsToSelect.Remove(rangeWithItemsToRemove); m_itemsToUnselect.Remove(rangeWithItemsToRemove); m_itemsToSelect.OffsetIndex(oldStartingIndex, -removedItemsCount); m_itemsToUnselect.OffsetIndex(oldStartingIndex, -removedItemsCount); SelectionCellRangeWithItems cellRangeWithItemsToRemove = new SelectionCellRangeWithItems( itemRange, null, new SelectionRange(0, int.MaxValue - 1)); m_cellsToSelect.Remove(cellRangeWithItemsToRemove); m_cellsToUnselect.Remove(cellRangeWithItemsToRemove); m_cellsToSelect.OffsetIndex(oldStartingIndex, -removedItemsCount); m_cellsToUnselect.OffsetIndex(oldStartingIndex, -removedItemsCount); } }
private IEnumerable <object> EnumerateItems(SelectionRangeWithItems range, DataGridContext dataGridContext, int itemsCount) { var startAt = range.Range.StartIndex; var endAt = range.Range.EndIndex; var min = Math.Min(startAt, endAt); var max = Math.Max(startAt, endAt); if (startAt > endAt) { var upperLimit = Math.Min(startAt, itemsCount - 1); for (int i = upperLimit; i >= endAt; i--) { object item; try { item = range.GetItem(dataGridContext, startAt - i); } catch (ArgumentOutOfRangeException) { continue; } yield return(item); } } else { var upperLimit = Math.Min(endAt, itemsCount - 1); for (int i = startAt; i <= upperLimit; i++) { object item; try { item = range.GetItem(dataGridContext, i - startAt); } catch (ArgumentOutOfRangeException) { break; } yield return(item); } } }
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); }
void ICollection.CopyTo(Array array, int arrayIndex) { DataGridContext dataGridContext = m_list.DataGridContext; int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; int rangeLength = rangeWithItems.Length; for (int j = 0; j < rangeLength; j++) { array.SetValue(rangeWithItems.GetItem(dataGridContext, j), arrayIndex); arrayIndex++; } } }
public void CopyTo(object[] array, int arrayIndex) { DataGridContext dataGridContext = m_list.DataGridContext; int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; int rangeLength = rangeWithItems.Length; for (int j = 0; j < rangeLength; j++) { array[arrayIndex] = rangeWithItems.GetItem(dataGridContext, j); arrayIndex++; } } }
public void RemoveAt(int index) { if ((index < 0) || (index >= m_list.ItemsCount)) { throw new ArgumentOutOfRangeException("index", index, "index must be greater than or equal to zero and less than Count."); } int oldIndexOffset = 0; int indexOffset = 0; int count = m_list.Count; SelectionRangeWithItems rangeWithItemsFound = SelectionRangeWithItems.Empty; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItems = m_list[i]; indexOffset += rangeWithItems.Length; if (index < indexOffset) { rangeWithItemsFound = rangeWithItems; // .GetItem( dataGridContext, index - oldIndexOffset ); break; } oldIndexOffset = indexOffset; } if (!rangeWithItemsFound.IsEmpty) { DataGridContext dataGridContext = m_list.DataGridContext; SelectionManager selectionManager = dataGridContext.DataGridControl.SelectionChangerManager; selectionManager.Begin(); try { selectionManager.UnselectItems(dataGridContext, new SelectionRangeWithItems( rangeWithItemsFound.Range.GetIndexFromItemOffset(index - oldIndexOffset), rangeWithItemsFound.GetItem(dataGridContext, index - oldIndexOffset))); } finally { selectionManager.End(false, true, true); } } }
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); }
private IEnumerable <SelectionRangeWithItems> GetUnselectedItemsFromRemove(ICollection <SelectionRangeWithItems> removedRangeWithItems) { var store = m_owner.SelectedItemsStore; if ((store.Count <= 0) || (m_sourceChanges.Count <= 0)) { return(Enumerable.Empty <SelectionRangeWithItems>()); } var unselectedItemsFromRemove = new List <SelectionRangeWithItems>(); for (int i = 0; i < m_sourceChanges.Count; i++) { var sourceChangeInfo = m_sourceChanges[i]; if ((sourceChangeInfo.Action != NotifyCollectionChangedAction.Remove) || (sourceChangeInfo.StartIndex == -1)) { continue; } var startIndex = sourceChangeInfo.StartIndex; var removedItemCount = sourceChangeInfo.Count; var removedItems = new object[removedItemCount]; sourceChangeInfo.Items.CopyTo(removedItems, 0); var range = new SelectionRange(startIndex, startIndex + removedItemCount - 1); var rangeWithItemsToRemove = new SelectionRangeWithItems(range, removedItems); if (removedRangeWithItems != null) { removedRangeWithItems.Add(rangeWithItemsToRemove); } if (store.Contains(rangeWithItemsToRemove)) { unselectedItemsFromRemove.Add(rangeWithItemsToRemove); } } return(unselectedItemsFromRemove); }
public bool Contains(SelectionRangeWithItems rangeWithItemsToCompare) { int count = m_list.Count; SelectionRange rangeToCompare = rangeWithItemsToCompare.Range; for (int i = 0; i < count; i++) { SelectionRangeWithItems rangeWithItem = m_list[i]; SelectionRange rangeIntersection = rangeWithItem.Range.Intersect(rangeToCompare); if (!rangeIntersection.IsEmpty) { if (rangeWithItemsToCompare.IsItemsEqual(rangeIntersection, rangeWithItem)) { return(true); } } } return(false); }
public static void UpdateSelectionRangeWithItemsFromAdd( DataGridContext dataGridContext, SelectionRangeWithItems newRangeWithItems, ref SelectionRangeWithItems lastRangeWithItems ) { // Only work for adding at the end of an existing range. object[] newRangeItems = newRangeWithItems.Items; if( ( ( dataGridContext == null ) || ( ( dataGridContext.ItemsSourceCollection == null ) && ( newRangeItems == null ) ) || ( dataGridContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase ) ) ) { lastRangeWithItems = new SelectionRangeWithItems( new SelectionRange( lastRangeWithItems.Range.StartIndex, newRangeWithItems.Range.EndIndex ), null ); return; } object[] rangeToUpdateItems = lastRangeWithItems.Items; object[] newItems; int newItemsStartPosition; if( newRangeWithItems == lastRangeWithItems ) { if( newRangeItems != null ) return; newItemsStartPosition = 0; newItems = new object[ lastRangeWithItems.Length ]; } else { newItemsStartPosition = lastRangeWithItems.Length; newItems = new object[ lastRangeWithItems.Length + newRangeWithItems.Length ]; Array.Copy( rangeToUpdateItems, newItems, newItemsStartPosition ); } CollectionView items = ( dataGridContext == null ) ? null : dataGridContext.Items; int rangeToUpdateStartIndex = lastRangeWithItems.Range.StartIndex; int rangeToUpdateEndIndex = lastRangeWithItems.Range.EndIndex; int newRangeStartIndex = newRangeWithItems.Range.StartIndex; int newRangeEndIndex = newRangeWithItems.Range.EndIndex; // If new range have no items set, found the items and set it. if( newRangeItems == null ) { if( newRangeEndIndex > newRangeStartIndex ) { for( int i = newRangeStartIndex; i <= newRangeEndIndex; i++ ) { newItems[ newItemsStartPosition ] = items.GetItemAt( i ); newItemsStartPosition++; } } else { for( int i = newRangeStartIndex; i >= newRangeEndIndex; i-- ) { newItems[ newItemsStartPosition ] = items.GetItemAt( i ); newItemsStartPosition++; } } } else { for( int i = 0; i < newRangeItems.Length; i++ ) { newItems[ newItemsStartPosition ] = newRangeItems[ i ]; newItemsStartPosition++; } } lastRangeWithItems = new SelectionRangeWithItems( new SelectionRange( rangeToUpdateStartIndex, newRangeEndIndex ), newItems ); }
public void OffsetIndexBasedOnSourceNewIndex( int maxOffset ) { if( m_dataGridContext == null ) throw new InvalidOperationException( "We must have a DataGridContext to find the new index." ); CollectionView sourceItems = m_dataGridContext.Items; for( int i = this.Count - 1; i >= 0; i-- ) { SelectionRangeWithItems rangeWithItems = m_list[ i ]; object[] items = rangeWithItems.Items; if( items == null ) throw new InvalidOperationException( "We should have items to find the new index." ); object item = items[ 0 ]; SelectionRange range = rangeWithItems.Range; int startIndex = Math.Min( range.StartIndex, range.EndIndex ); if( maxOffset < 0 ) { for( int j = 0; j >= maxOffset; j-- ) { if( object.Equals( sourceItems.GetItemAt( startIndex ), item ) ) { if( j != 0 ) { SelectionRange newRange = new SelectionRange( range.StartIndex + j, range.EndIndex + j ); m_list[ i ] = new SelectionRangeWithItems( newRange, items ); } break; } startIndex--; if( startIndex < 0 ) break; } } else { int sourceItemCount = sourceItems.Count; for( int j = 0; j <= maxOffset; j++ ) { if( object.Equals( sourceItems.GetItemAt( startIndex ), item ) ) { if( j != 0 ) { SelectionRange newRange = new SelectionRange( range.StartIndex + j, range.EndIndex + j ); m_list[ i ] = new SelectionRangeWithItems( newRange, items ); } break; } startIndex++; if( startIndex >= sourceItemCount ) break; } } } }
private List<SelectionRangeWithItems> GetUnselectedItemsFromRemove( out List<SelectionRangeWithItems> removedRangeWithItems ) { List<SelectionRangeWithItems> unselectedItemsFromRemove = new List<SelectionRangeWithItems>( 8 ); removedRangeWithItems = new List<SelectionRangeWithItems>( 8 ); int count = m_sourceChanges.Count; for( int i = 0; i < count; i++ ) { SourceChangeInfo sourceChangeInfo = m_sourceChanges[ i ]; if( ( sourceChangeInfo.Action != NotifyCollectionChangedAction.Remove ) || ( sourceChangeInfo.StartIndex == -1 ) ) continue; int startIndex = sourceChangeInfo.StartIndex; int removedItemCount = sourceChangeInfo.Count; object[] removedItems = new object[ removedItemCount ]; sourceChangeInfo.Items.CopyTo( removedItems, 0 ); SelectionRangeWithItems rangeWithItemsToRemove = new SelectionRangeWithItems( new SelectionRange( startIndex, startIndex + removedItemCount - 1 ), removedItems ); removedRangeWithItems.Add( rangeWithItemsToRemove ); if( m_owner.SelectedItemsStore.Contains( rangeWithItemsToRemove ) ) { unselectedItemsFromRemove.Add( rangeWithItemsToRemove ); } } return unselectedItemsFromRemove; }
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 OffsetIndexBasedOnSourceNewIndex(int maxOffset) { if (m_dataGridContext == null) { throw new InvalidOperationException("We must have a DataGridContext to find the new index."); } CollectionView sourceItems = m_dataGridContext.Items; for (int i = this.Count - 1; i >= 0; i--) { SelectionCellRangeWithItems cellRangeWithItems = m_list[i]; SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems; object[] items = itemRangeWithItems.Items; if (items == null) { throw new InvalidOperationException("We should have items to find the new index."); } object item = items[0]; SelectionRange itemRange = itemRangeWithItems.Range; int startIndex = Math.Min(itemRange.StartIndex, itemRange.EndIndex); if (maxOffset < 0) { for (int j = 0; j >= maxOffset; j--) { if (object.Equals(sourceItems.GetItemAt(startIndex), item)) { if (j != 0) { SelectionRange newItemRange = new SelectionRange(itemRange.StartIndex + j, itemRange.EndIndex + j); m_list[i] = new SelectionCellRangeWithItems(newItemRange, items, cellRangeWithItems.ColumnRange); } break; } startIndex--; if (startIndex < 0) { break; } } } else { int sourceItemCount = sourceItems.Count; for (int j = 0; j <= maxOffset; j++) { if (object.Equals(sourceItems.GetItemAt(startIndex), item)) { if (j != 0) { SelectionRange newItemRange = new SelectionRange(itemRange.StartIndex + j, itemRange.EndIndex + j); m_list[i] = new SelectionCellRangeWithItems(newItemRange, items, cellRangeWithItems.ColumnRange); } break; } startIndex++; if (startIndex >= sourceItemCount) { break; } } } } }
public bool UnselectItems( DataGridContext dataGridContext, SelectionRangeWithItems rangeWithItems ) { SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext ); return selectionChanger.UnselectItems( rangeWithItems ); }
internal SelectionRangeWithItemsWrapper(SelectionRangeWithItems value, int index) { m_value = value; m_index = index; }
public void OffsetIndex(int startIndex, int offset) { // Used to offset index after an add or remove from the data source of the grid. SelectionRange offsetRange = new SelectionRange( startIndex, startIndex + Math.Abs(offset) - 1); for (int i = this.Count - 1; i >= 0; i--) { SelectionRangeWithItems rangeWithItems = m_list[i]; SelectionRange range = rangeWithItems.Range; if (offsetRange > range) { continue; } SelectionRange rangeIntersection = range.Intersect(offsetRange); object[] originalItems = rangeWithItems.Items; if (!rangeIntersection.IsEmpty) { // Should only happen when adding since when we remove data from the source, we remove the // the range from the list. Debug.Assert(offset > 0); // Offset the index higher than the start index of the new added item SelectionRange topRange; SelectionRange bottomRange; if (range.StartIndex > range.EndIndex) { if (rangeIntersection.EndIndex == range.EndIndex) { SelectionRange newRange = new SelectionRange(range.StartIndex + offset, range.EndIndex + offset); m_list[i] = new SelectionRangeWithItems(newRange, originalItems); continue; } else { int bottomRangeEndIndex = startIndex + offset; bottomRange = new SelectionRange(startIndex - 1, range.EndIndex); topRange = new SelectionRange(range.Length - bottomRange.Length - 1 + bottomRangeEndIndex, bottomRangeEndIndex); } } else { if (rangeIntersection.StartIndex == range.StartIndex) { SelectionRange newRange = new SelectionRange(range.StartIndex + offset, range.EndIndex + offset); m_list[i] = new SelectionRangeWithItems(newRange, originalItems); continue; } else { int bottomRangeStartIndex = startIndex + offset; topRange = new SelectionRange(range.StartIndex, startIndex - 1); bottomRange = new SelectionRange(bottomRangeStartIndex, range.Length - topRange.Length - 1 + bottomRangeStartIndex); } } object[] topItems = null; object[] bottomItems = null; if (originalItems != null) { topItems = new object[topRange.Length]; Array.Copy(originalItems, 0, topItems, 0, topItems.Length); bottomItems = new object[bottomRange.Length]; Array.Copy(originalItems, topItems.Length, bottomItems, 0, bottomItems.Length); } m_list[i] = new SelectionRangeWithItems(topRange, topItems); m_list.Insert(i + 1, new SelectionRangeWithItems(bottomRange, bottomItems)); } else { // Offset the index by the count added SelectionRange newRange = new SelectionRange(range.StartIndex + offset, range.EndIndex + offset); m_list[i] = new SelectionRangeWithItems(newRange, originalItems); } } }
public static void UpdateSelectionRangeWithItemsFromAdd( DataGridContext dataGridContext, SelectionRangeWithItems newRangeWithItems, ref SelectionRangeWithItems lastRangeWithItems) { // Only work for adding at the end of an existing range. object[] newRangeItems = newRangeWithItems.Items; if (((dataGridContext == null) || ((dataGridContext.ItemsSourceCollection == null) && (newRangeItems == null)) || (dataGridContext.ItemsSourceCollection is DataGridVirtualizingCollectionViewBase))) { lastRangeWithItems = new SelectionRangeWithItems( new SelectionRange(lastRangeWithItems.Range.StartIndex, newRangeWithItems.Range.EndIndex), null); return; } object[] rangeToUpdateItems = lastRangeWithItems.Items; object[] newItems; int newItemsStartPosition; if (newRangeWithItems == lastRangeWithItems) { if (newRangeItems != null) { return; } newItemsStartPosition = 0; newItems = new object[lastRangeWithItems.Length]; } else { newItemsStartPosition = lastRangeWithItems.Length; newItems = new object[lastRangeWithItems.Length + newRangeWithItems.Length]; Array.Copy(rangeToUpdateItems, newItems, newItemsStartPosition); } CollectionView items = (dataGridContext == null) ? null : dataGridContext.Items; int rangeToUpdateStartIndex = lastRangeWithItems.Range.StartIndex; int rangeToUpdateEndIndex = lastRangeWithItems.Range.EndIndex; int newRangeStartIndex = newRangeWithItems.Range.StartIndex; int newRangeEndIndex = newRangeWithItems.Range.EndIndex; // If new range have no items set, found the items and set it. if (newRangeItems == null) { if (newRangeEndIndex > newRangeStartIndex) { for (int i = newRangeStartIndex; i <= newRangeEndIndex; i++) { newItems[newItemsStartPosition] = items.GetItemAt(i); newItemsStartPosition++; } } else { for (int i = newRangeStartIndex; i >= newRangeEndIndex; i--) { newItems[newItemsStartPosition] = items.GetItemAt(i); newItemsStartPosition++; } } } else { for (int i = 0; i < newRangeItems.Length; i++) { newItems[newItemsStartPosition] = newRangeItems[i]; newItemsStartPosition++; } } lastRangeWithItems = new SelectionRangeWithItems( new SelectionRange(rangeToUpdateStartIndex, newRangeEndIndex), newItems); }
public void UpdateSelectionAfterSourceDataItemRemoved( NotifyCollectionChangedEventArgs e ) { int oldStartingIndex = e.OldStartingIndex; IList removedItemsList = e.OldItems; int removedItemsCount = removedItemsList.Count; m_sourceChanges.Add( new SourceChangeInfo( e.Action, oldStartingIndex, removedItemsCount, removedItemsList ) ); if( oldStartingIndex == -1 ) { foreach( object item in removedItemsList ) { SelectionRangeWithItems rangeWithItemsToRemove = new SelectionRangeWithItems( SelectionRange.Empty, new object[] { item } ); m_itemsToSelect.Remove( rangeWithItemsToRemove ); m_itemsToUnselect.Remove( rangeWithItemsToRemove ); SelectionCellRangeWithItems cellRangeWithItemsToRemove = new SelectionCellRangeWithItems( SelectionRange.Empty, new object[] { item }, new SelectionRange( 0, int.MaxValue - 1 ) ); m_cellsToSelect.Remove( cellRangeWithItemsToRemove ); m_cellsToUnselect.Remove( cellRangeWithItemsToRemove ); } // Seek out in a max range of removedItemsCount the new position for actually selected item. m_itemsToSelect.OffsetIndexBasedOnSourceNewIndex( -removedItemsCount ); m_itemsToUnselect.OffsetIndexBasedOnSourceNewIndex( -removedItemsCount ); m_cellsToSelect.OffsetIndexBasedOnSourceNewIndex( -removedItemsCount ); m_cellsToUnselect.OffsetIndexBasedOnSourceNewIndex( -removedItemsCount ); } else { SelectionRange itemRange = new SelectionRange( oldStartingIndex, oldStartingIndex + removedItemsCount - 1 ); SelectionRangeWithItems rangeWithItemsToRemove = new SelectionRangeWithItems( itemRange, null ); m_itemsToSelect.Remove( rangeWithItemsToRemove ); m_itemsToUnselect.Remove( rangeWithItemsToRemove ); m_itemsToSelect.OffsetIndex( oldStartingIndex, -removedItemsCount ); m_itemsToUnselect.OffsetIndex( oldStartingIndex, -removedItemsCount ); SelectionCellRangeWithItems cellRangeWithItemsToRemove = new SelectionCellRangeWithItems( itemRange, null, new SelectionRange( 0, int.MaxValue - 1 ) ); m_cellsToSelect.Remove( cellRangeWithItemsToRemove ); m_cellsToUnselect.Remove( cellRangeWithItemsToRemove ); m_cellsToSelect.OffsetIndex( oldStartingIndex, -removedItemsCount ); m_cellsToUnselect.OffsetIndex( oldStartingIndex, -removedItemsCount ); } }
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 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 bool Remove(SelectionRangeWithItems rangeWithItemsToRemove) { bool removed = false; SelectionRange rangeToRemove = rangeWithItemsToRemove.Range; object[] itemsToRemove = rangeWithItemsToRemove.Items; int itemsToRemoveCount = (itemsToRemove == null) ? 0 : itemsToRemove.Length; int itemOffsetToRemove = 0; bool rangeToRemoveIsEmpty = rangeToRemove.IsEmpty; do { for (int i = m_list.Count - 1; i >= 0; i--) { SelectionRangeWithItems rangeWithItems = m_list[i]; SelectionRange range = rangeWithItems.Range; SelectionRange rangeIntersection; object[] oldRangeItems = rangeWithItems.Items; if (rangeToRemoveIsEmpty) { int itemOffset = Array.IndexOf(oldRangeItems, itemsToRemove[itemOffsetToRemove]); if (itemOffset == -1) { continue; } rangeIntersection = new SelectionRange(range.GetIndexFromItemOffset(itemOffset)); } else { rangeIntersection = range.Intersect(rangeToRemove); if (rangeIntersection.IsEmpty) { continue; } if (!rangeWithItems.IsItemsEqual(rangeIntersection, rangeWithItemsToRemove)) { continue; } } removed = true; m_itemsCount -= rangeIntersection.Length; SelectionRange[] newRanges = range.Exclude(rangeIntersection); if (newRanges.Length == 0) { m_list.RemoveAt(i); } else { SelectionRange newRange = newRanges[0]; m_list[i] = new SelectionRangeWithItems(newRange, rangeWithItems.GetItems(newRange)); if (newRanges.Length > 1) { Debug.Assert(newRanges.Length == 2); newRange = newRanges[1]; m_list.Insert(i + 1, new SelectionRangeWithItems(newRange, rangeWithItems.GetItems(newRange))); } } } itemOffsetToRemove++; } while((rangeToRemoveIsEmpty) && (itemOffsetToRemove < itemsToRemoveCount)); return(removed); }
public void Visit(DataGridContext sourceContext, int startSourceDataItemIndex, int endSourceDataItemIndex, ref bool stopVisit) { SelectionManager selectionChangerManager = sourceContext.DataGridControl.SelectionChangerManager; if (m_selectedColumns != null) { int columnCount = sourceContext.Columns.Count; if (columnCount == 0) { return; } SelectionRange contextColumnMaxRange = new SelectionRange(0, columnCount - 1); for (int i = 0; i < m_selectedColumns.Length; i++) { SelectionRange selectionRange = m_selectedColumns[i]; SelectionRange intersectionSelectionRange = selectionRange.Intersect(contextColumnMaxRange); if (intersectionSelectionRange.IsEmpty) { continue; } #if DEBUG string action = (m_unselect) ? "Removing" : "Adding"; Debug.WriteLine("Selection : " + action + " cell : (" + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString() + ") - (" + intersectionSelectionRange.StartIndex.ToString() + " - " + intersectionSelectionRange.EndIndex.ToString() + ")"); #endif var cellRange = new SelectionCellRangeWithItems(new SelectionRange(startSourceDataItemIndex, endSourceDataItemIndex), null, intersectionSelectionRange); if (m_unselect) { selectionChangerManager.UnselectCells(sourceContext, cellRange); } else { selectionChangerManager.SelectCells(sourceContext, cellRange); } } } else { #if DEBUG string action = (m_unselect) ? "Removing" : "Adding"; Debug.WriteLine("Selection : " + action + " Adding item : " + startSourceDataItemIndex.ToString() + " - " + endSourceDataItemIndex.ToString()); #endif var itemRange = new SelectionRangeWithItems(new SelectionRange(startSourceDataItemIndex, endSourceDataItemIndex), null); if (m_unselect) { selectionChangerManager.UnselectItems(sourceContext, itemRange); } else { selectionChangerManager.SelectItems(sourceContext, itemRange); } } }
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 UpdateSelectionAfterSourceCollectionChanged( DataGridContext dataGridContext, NotifyCollectionChangedEventArgs e ) { switch( e.Action ) { case NotifyCollectionChangedAction.Replace: { // When we get a replace with the same instance, we just have nothing to do. if( ( e.NewItems.Count == 1 ) && ( e.OldItems.Count == 1 ) && ( e.OldItems[ 0 ] == e.NewItems[ 0 ] ) ) break; this.Begin(); try { // This is done to force the SelectionChangerManager to call the DataGridControl's // DataGridContext UpdatePublicSelectionProperties method wheter or not // there is any changes to the selection. This is usefull when resetting due to a Sort operation for instance. this.EnsureRootSelectedItemAndSelectedIndex(); SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext ); selectionChanger.UpdateSelectionAfterSourceDataItemReplaced( e ); } finally { this.End( true, false, true ); } break; } case NotifyCollectionChangedAction.Add: { this.Begin(); try { // This is done to force the SelectionChangerManager to call the DataGridControl's // DataGridContext UpdatePublicSelectionProperties method wheter or not // there is any changes to the selection. This is usefull when resetting due to a Sort operation for instance. this.EnsureRootSelectedItemAndSelectedIndex(); m_rangeSelectionItemStartAnchor = -1; m_rangeSelectionColumnStartAnchor = -1; SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext ); selectionChanger.UpdateSelectionAfterSourceDataItemAdded( e ); } finally { this.End( true, false, true ); } break; } case NotifyCollectionChangedAction.Remove: { this.Begin(); try { // This is done to force the SelectionChangerManager to call the DataGridControl's // DataGridContext UpdatePublicSelectionProperties method wheter or not // there is any changes to the selection. This is usefull when resetting due to a Sort operation for instance. this.EnsureRootSelectedItemAndSelectedIndex(); m_rangeSelectionItemStartAnchor = -1; m_rangeSelectionColumnStartAnchor = -1; SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext ); selectionChanger.UpdateSelectionAfterSourceDataItemRemoved( e ); } finally { this.End( true, false, true ); } break; } case NotifyCollectionChangedAction.Move: case NotifyCollectionChangedAction.Reset: { this.Begin(); try { // This is done to force the SelectionChangerManager to call the DataGridControl's // DataGridContext UpdatePublicSelectionProperties method wheter or not // there is any changes to the selection. This is usefull when resetting due to a Sort operation for instance. this.EnsureRootSelectedItemAndSelectedIndex(); m_rangeSelectionItemStartAnchor = -1; m_rangeSelectionColumnStartAnchor = -1; SelectedItemsStorage selectedItemsStorage = dataGridContext.SelectedItemsStore; int selectedItemsCount = selectedItemsStorage.Count; SelectedCellsStorage selectedCellsStorage = dataGridContext.SelectedCellsStore; int selectedCellsCount = selectedCellsStorage.Count; SelectionChanger selectionChanger = this.GetSelectionChanger( dataGridContext ); int newItemCount = dataGridContext.Items.Count; SelectionRange maxItemRange; if( newItemCount == 0 ) { maxItemRange = SelectionRange.Empty; } else { maxItemRange = new SelectionRange( 0, newItemCount - 1 ); } if( selectedItemsCount > 0 ) { selectionChanger.UnselectAllItems(); for( int i = 0; i < selectedItemsCount; i++ ) { SelectionRangeWithItems rangeWithItems = selectedItemsStorage[ i ]; object[] items = rangeWithItems.Items; if( items == null ) { SelectionRange itemRange = rangeWithItems.Range; SelectionRange rangeIntersection = itemRange.Intersect( maxItemRange ); if( rangeIntersection != itemRange ) { if( rangeIntersection.IsEmpty ) continue; rangeWithItems = new SelectionRangeWithItems( rangeIntersection, null ); } selectionChanger.SelectItems( rangeWithItems ); } else { CollectionView sourceItems = dataGridContext.Items; int itemsCount = items.Length; SelectionRange range = rangeWithItems.Range; for( int j = 0; j < itemsCount; j++ ) { object item = items[ j ]; int index = sourceItems.IndexOf( item ); if( index != -1 ) { selectionChanger.SelectItems( new SelectionRangeWithItems( index, item ) ); } } } } } if( selectedCellsCount > 0 ) { selectionChanger.UnselectAllCells(); for( int i = 0; i < selectedCellsCount; i++ ) { SelectionCellRangeWithItems cellRangeWithItems = selectedCellsStorage[ i ]; SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems; object[] items = itemRangeWithItems.Items; if( items == null ) { SelectionRange itemRange = itemRangeWithItems.Range; SelectionRange itemRangeIntersection = itemRange.Intersect( maxItemRange ); if( itemRangeIntersection != itemRange ) { if( itemRangeIntersection.IsEmpty ) continue; cellRangeWithItems = new SelectionCellRangeWithItems( itemRangeIntersection, null, cellRangeWithItems.ColumnRange ); } selectionChanger.SelectCells( cellRangeWithItems ); } else { CollectionView sourceItems = dataGridContext.Items; int itemsCount = items.Length; SelectionRange itemRange = cellRangeWithItems.ItemRange; for( int j = 0; j < itemsCount; j++ ) { object item = items[ j ]; int index = sourceItems.IndexOf( item ); if( index != -1 ) { selectionChanger.SelectCells( new SelectionCellRangeWithItems( new SelectionRange( index ), new object[] { item }, cellRangeWithItems.ColumnRange ) ); } } } } } } finally { this.End( true, false, true ); } break; } } }
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 ); }
public bool Remove(SelectionCellRangeWithItems cellRangeWithItemsToRemove) { if (cellRangeWithItemsToRemove.CellRange.IsEmpty) { return(true); } bool removed = false; SelectionCellRange cellRangeToRemove = cellRangeWithItemsToRemove.CellRange; object[] itemsToRemove = cellRangeWithItemsToRemove.ItemRangeWithItems.Items; int itemsToRemoveCount = (itemsToRemove == null) ? 0 : itemsToRemove.Length; int itemOffsetToRemove = 0; bool itemRangeToRemoveIsEmpty = cellRangeToRemove.ItemRange.IsEmpty; do { for (int i = m_list.Count - 1; i >= 0; i--) { SelectionCellRangeWithItems cellRangeWithItems = m_list[i]; SelectionRange itemRange = cellRangeWithItems.ItemRange; SelectionCellRange cellRange = cellRangeWithItems.CellRange; SelectionRangeWithItems itemRangeWithItems = cellRangeWithItems.ItemRangeWithItems; SelectionCellRange cellRangeIntersection; object[] oldRangeItems = itemRangeWithItems.Items; if (itemRangeToRemoveIsEmpty) { int itemOffset = Array.IndexOf(oldRangeItems, itemsToRemove[itemOffsetToRemove]); if (itemOffset == -1) { continue; } int itemIndex = itemRange.GetIndexFromItemOffset(itemOffset); cellRangeIntersection = new SelectionCellRange( new SelectionRange(itemIndex, itemIndex), cellRangeWithItems.ColumnRange.Intersect(cellRangeToRemove.ColumnRange)); } else { cellRangeIntersection = cellRange.Intersect(cellRangeToRemove); if (cellRangeIntersection.IsEmpty) { continue; } if (!itemRangeWithItems.IsItemsEqual( cellRangeIntersection.ItemRange, cellRangeWithItemsToRemove.ItemRangeWithItems)) { continue; } } removed = true; m_cellsCount -= cellRangeIntersection.Length; SelectionCellRange[] newCellRanges = cellRange.Exclude(cellRangeIntersection); if (newCellRanges.Length == 0) { m_list.RemoveAt(i); } else { SelectionCellRange newCellRange = newCellRanges[0]; m_list[i] = new SelectionCellRangeWithItems( newCellRange.ItemRange, itemRangeWithItems.GetItems(newCellRange.ItemRange), newCellRange.ColumnRange); for (int j = 1; j < newCellRanges.Length; j++) { newCellRange = newCellRanges[j]; m_list.Insert(i + j, new SelectionCellRangeWithItems( newCellRange.ItemRange, itemRangeWithItems.GetItems(newCellRange.ItemRange), newCellRange.ColumnRange)); } } } itemOffsetToRemove++; } while((itemRangeToRemoveIsEmpty) && (itemOffsetToRemove < itemsToRemoveCount)); return(removed); }
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); } }
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 bool SetIsSelectedOnDataRow( Dictionary<int, DataRow> realizedDataRows, SelectionRangeWithItems rangeWithItems, bool selected ) { int rangeLength = rangeWithItems.Length; object[] rangeItems = rangeWithItems.Items; bool selectionChanged = false; if( rangeItems != null ) { for( int i = 0; i < rangeLength; i++ ) { DataRow rangeItemAsDataRow = rangeItems[ i ] as DataRow; if( rangeItemAsDataRow != null ) { selectionChanged = true; rangeItemAsDataRow.SetIsSelected( selected ); } else { // We take for granted that no item will be a DataRow break; } } } return selectionChanged; }
private bool SetIsSelectedOnDataRow(Dictionary <int, DataRow> realizedDataRows, SelectionRangeWithItems rangeWithItems, bool selected) { int rangeLength = rangeWithItems.Length; object[] rangeItems = rangeWithItems.Items; bool selectionChanged = false; if (rangeItems != null) { for (int i = 0; i < rangeLength; i++) { DataRow rangeItemAsDataRow = rangeItems[i] as DataRow; if (rangeItemAsDataRow != null) { selectionChanged = true; rangeItemAsDataRow.SetIsSelected(selected); } else { // We take for granted that no item will be a DataRow break; } } } return(selectionChanged); }
public void OffsetIndex( int startIndex, int offset ) { // Used to offset index after an add or remove from the data source of the grid. SelectionRange offsetRange = new SelectionRange( startIndex, startIndex + Math.Abs( offset ) - 1 ); for( int i = this.Count - 1; i >= 0; i-- ) { SelectionRangeWithItems rangeWithItems = m_list[ i ]; SelectionRange range = rangeWithItems.Range; if( offsetRange > range ) continue; SelectionRange rangeIntersection = range.Intersect( offsetRange ); object[] originalItems = rangeWithItems.Items; if( !rangeIntersection.IsEmpty ) { // Should only happen when adding since when we remove data from the source, we remove the // the range from the list. Debug.Assert( offset > 0 ); // Offset the index higher than the start index of the new added item SelectionRange topRange; SelectionRange bottomRange; if( range.StartIndex > range.EndIndex ) { if( rangeIntersection.EndIndex == range.EndIndex ) { SelectionRange newRange = new SelectionRange( range.StartIndex + offset, range.EndIndex + offset ); m_list[ i ] = new SelectionRangeWithItems( newRange, originalItems ); continue; } else { int bottomRangeEndIndex = startIndex + offset; bottomRange = new SelectionRange( startIndex - 1, range.EndIndex ); topRange = new SelectionRange( range.Length - bottomRange.Length - 1 + bottomRangeEndIndex, bottomRangeEndIndex ); } } else { if( rangeIntersection.StartIndex == range.StartIndex ) { SelectionRange newRange = new SelectionRange( range.StartIndex + offset, range.EndIndex + offset ); m_list[ i ] = new SelectionRangeWithItems( newRange, originalItems ); continue; } else { int bottomRangeStartIndex = startIndex + offset; topRange = new SelectionRange( range.StartIndex, startIndex - 1 ); bottomRange = new SelectionRange( bottomRangeStartIndex, range.Length - topRange.Length - 1 + bottomRangeStartIndex ); } } object[] topItems = null; object[] bottomItems = null; if( originalItems != null ) { topItems = new object[ topRange.Length ]; Array.Copy( originalItems, 0, topItems, 0, topItems.Length ); bottomItems = new object[ bottomRange.Length ]; Array.Copy( originalItems, topItems.Length, bottomItems, 0, bottomItems.Length ); } m_list[ i ] = new SelectionRangeWithItems( topRange, topItems ); m_list.Insert( i + 1, new SelectionRangeWithItems( bottomRange, bottomItems ) ); } else { // Offset the index by the count added SelectionRange newRange = new SelectionRange( range.StartIndex + offset, range.EndIndex + offset ); m_list[ i ] = new SelectionRangeWithItems( newRange, originalItems ); } } }
public bool Contains( SelectionRangeWithItems rangeWithItemsToCompare ) { int count = m_list.Count; SelectionRange rangeToCompare = rangeWithItemsToCompare.Range; for( int i = 0; i < count; i++ ) { SelectionRangeWithItems rangeWithItem = m_list[ i ]; SelectionRange rangeIntersection = rangeWithItem.Range.Intersect( rangeToCompare ); if( !rangeIntersection.IsEmpty ) { if( rangeWithItemsToCompare.IsItemsEqual( rangeIntersection, rangeWithItem ) ) return true; } } return false; }
private bool FindItem(int index, DataGridContext dataGridContext, int itemsCount, out SelectionRangeWithItems range, out int offset) { var rangesCount = m_storage.Count; range = SelectionRangeWithItems.Empty; offset = index; for (int i = 0; i < rangesCount; i++) { if (offset < 0) { break; } range = m_storage[i]; var length = range.Length; if (offset < length) { var startAt = range.Range.StartIndex; var endAt = range.Range.EndIndex; if (startAt > endAt) { if (startAt - offset >= itemsCount) { break; } } else { if (startAt + offset >= itemsCount) { break; } } Debug.Assert((offset >= 0) && (offset < length)); return(true); } else { offset -= length; } } return(false); }
public bool IsItemsEqual( SelectionRange rangeIntersection, SelectionRangeWithItems rangeWithItemsToCompare ) { object[] itemsToCompare = rangeWithItemsToCompare.m_items; if( ( m_items == null ) || ( itemsToCompare == null ) ) return true; SelectionRange rangeToCompare = rangeWithItemsToCompare.Range; int startIndex = Math.Min( rangeIntersection.StartIndex, rangeIntersection.EndIndex ); int itemIndex1 = Math.Abs( startIndex - m_range.StartIndex ); int itemIndex2 = Math.Abs( startIndex - rangeToCompare.StartIndex ); bool inversedRange1 = m_range.StartIndex > m_range.EndIndex; bool inversedRange2 = rangeToCompare.StartIndex > rangeToCompare.EndIndex; int count = rangeIntersection.Length; for( int i = 0; i < count; i++ ) { if( !object.Equals( m_items[ itemIndex1 ], itemsToCompare[ itemIndex2 ] ) ) return false; itemIndex1 = inversedRange1 ? itemIndex1 - 1 : itemIndex1 + 1; itemIndex2 = inversedRange2 ? itemIndex2 - 1 : itemIndex2 + 1; } return true; }
public bool Remove( SelectionRangeWithItems rangeWithItemsToRemove ) { bool removed = false; SelectionRange rangeToRemove = rangeWithItemsToRemove.Range; object[] itemsToRemove = rangeWithItemsToRemove.Items; int itemsToRemoveCount = ( itemsToRemove == null ) ? 0 : itemsToRemove.Length; int itemOffsetToRemove = 0; bool rangeToRemoveIsEmpty = rangeToRemove.IsEmpty; do { for( int i = m_list.Count - 1; i >= 0; i-- ) { SelectionRangeWithItems rangeWithItems = m_list[ i ]; SelectionRange range = rangeWithItems.Range; SelectionRange rangeIntersection; object[] oldRangeItems = rangeWithItems.Items; if( rangeToRemoveIsEmpty ) { int itemOffset = Array.IndexOf( oldRangeItems, itemsToRemove[ itemOffsetToRemove ] ); if( itemOffset == -1 ) continue; rangeIntersection = new SelectionRange( range.GetIndexFromItemOffset( itemOffset ) ); } else { rangeIntersection = range.Intersect( rangeToRemove ); if( rangeIntersection.IsEmpty ) continue; if( !rangeWithItems.IsItemsEqual( rangeIntersection, rangeWithItemsToRemove ) ) continue; } removed = true; m_itemsCount -= rangeIntersection.Length; SelectionRange[] newRanges = range.Exclude( rangeIntersection ); if( newRanges.Length == 0 ) { m_list.RemoveAt( i ); } else { SelectionRange newRange = newRanges[ 0 ]; m_list[ i ] = new SelectionRangeWithItems( newRange, rangeWithItems.GetItems( newRange ) ); if( newRanges.Length > 1 ) { Debug.Assert( newRanges.Length == 2 ); newRange = newRanges[ 1 ]; m_list.Insert( i + 1, new SelectionRangeWithItems( newRange, rangeWithItems.GetItems( newRange ) ) ); } } } itemOffsetToRemove++; } while( ( rangeToRemoveIsEmpty ) && ( itemOffsetToRemove < itemsToRemoveCount ) ); return removed; }