private static RSTree2D <SelectionCellRangeWithItemsWrapper> .Area GetArea(SelectionCellRange range) { if (range.IsEmpty) { return(RSTree2D <SelectionCellRangeWithItemsWrapper> .Area.Empty); } var itemRange = range.ItemRange; var columnRange = range.ColumnRange; int rs, re, cs, ce; if (itemRange.StartIndex <= itemRange.EndIndex) { rs = itemRange.StartIndex; re = itemRange.EndIndex; } else { rs = itemRange.EndIndex; re = itemRange.StartIndex; } if (columnRange.StartIndex <= columnRange.EndIndex) { cs = columnRange.StartIndex; ce = columnRange.EndIndex; } else { cs = columnRange.EndIndex; ce = columnRange.StartIndex; } return(new RSTree2D <SelectionCellRangeWithItemsWrapper> .Area(rs, re - rs + 1, cs, ce - cs + 1)); }
public IEnumerable <SelectionRange> GetIntersectedColumnRanges(SelectionCellRange range) { return((from match in this.IndexOfOverlap(range) let current = m_unsortedRanges[match].Value let intersection = current.CellRange.Intersect(range) select intersection.ColumnRange).ToList()); }
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))); }
public override bool Equals(object obj) { if (!(obj is SelectionCellRange)) { return(false); } SelectionCellRange selectionRange = ( SelectionCellRange )obj; return((selectionRange.m_itemRange == m_itemRange) && (selectionRange.m_columnRange == m_columnRange)); }
public IEnumerable <SelectionRange> GetIntersectedColumnRanges(SelectionCellRange range) { // It improves performance to leave early and prevent empty enumerators creation. if (m_ranges.Count <= 0) { return(Enumerable.Empty <SelectionRange>()); } return((from match in this.IndexOfOverlap(range) let current = m_ranges[match].Value let intersection = current.CellRange.Intersect(range) select intersection.ColumnRange).ToList()); }
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 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 List <SelectionRange> GetIntersectedColumnRanges(SelectionCellRange cellRange) { List <SelectionRange> intersectionRanges = new List <SelectionRange>(); int count = m_list.Count; for (int i = 0; i < count; i++) { SelectionCellRangeWithItems range = m_list[i]; SelectionCellRange cellRangeIntersection = range.CellRange.Intersect(cellRange); if (!cellRangeIntersection.IsEmpty) { intersectionRanges.Add(cellRangeIntersection.ColumnRange); } } return(intersectionRanges); }
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); } } }
public bool Contains(int itemIndex, int columnIndex) { if ((itemIndex < 0) || (columnIndex < 0)) { return(false); } SelectionCellRange cellRange = new SelectionCellRange(itemIndex, columnIndex); int count = m_list.Count; for (int i = 0; i < count; i++) { if (!m_list[i].CellRange.Intersect(cellRange).IsEmpty) { return(true); } } return(false); }
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); } } }
private IEnumerable <SelectionCellRangeWithItems> GetUnselectedCellsFromRemove(ICollection <SelectionCellRangeWithItems> removedCellsRangeWithItems) { var store = m_owner.SelectedCellsStore; if ((store.Count <= 0) || (m_sourceChanges.Count <= 0)) { return(Enumerable.Empty <SelectionCellRangeWithItems>()); } var unselectedCellsFromRemove = new List <SelectionCellRangeWithItems>(); 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 range = new SelectionCellRange(new SelectionRange(startIndex, startIndex + removedItemCount - 1), new SelectionRange(0, int.MaxValue - 1)); if (removedCellsRangeWithItems != null) { var removedItems = new object[removedItemCount]; sourceChangeInfo.Items.CopyTo(removedItems, 0); removedCellsRangeWithItems.Add(new SelectionCellRangeWithItems(range.ItemRange, removedItems, range.ColumnRange)); } foreach (var cellRangeWithItems in store.GetIntersectedCellRangesWithItems(range)) { unselectedCellsFromRemove.Add(cellRangeWithItems); } } return(unselectedCellsFromRemove); }
public SelectionCellRange Intersect(SelectionCellRange range) { SelectionCellRange cellRangeIntersection = SelectionCellRange.Empty; SelectionRange itemRange = range.ItemRange; SelectionRange itemRangeIntersection = m_itemRange.Intersect(itemRange); if (itemRangeIntersection.IsEmpty) { return(SelectionCellRange.Empty); } SelectionRange columnRange = range.ColumnRange; SelectionRange columnRangeIntersection = m_columnRange.Intersect(columnRange); if (columnRangeIntersection.IsEmpty) { return(SelectionCellRange.Empty); } return(new SelectionCellRange(itemRangeIntersection, columnRangeIntersection)); }
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 SelectionCellRange[] Exclude(SelectionCellRange cellRangeToExclude) { if (cellRangeToExclude.IsEmpty) { return new SelectionCellRange[] { this } } ; SelectionCellRange cellRangeIntersection = this.Intersect(cellRangeToExclude); if (cellRangeIntersection.IsEmpty) { return new SelectionCellRange[] { this } } ; SelectionRange[] itemRanges = m_itemRange.Exclude(cellRangeToExclude.ItemRange); SelectionRange[] columnRanges = m_columnRange.Exclude(cellRangeToExclude.ColumnRange); SelectionCellRange[] cellRanges = new SelectionCellRange[itemRanges.Length + columnRanges.Length]; int index = 0; foreach (SelectionRange itemRange in itemRanges) { cellRanges[index] = new SelectionCellRange(itemRange, m_columnRange); index++; } foreach (SelectionRange columnRange in columnRanges) { cellRanges[index] = new SelectionCellRange(cellRangeIntersection.ItemRange, columnRange); index++; } Debug.Assert(index == cellRanges.Length); return(cellRanges); }
public bool Contains( int itemIndex, int columnIndex ) { if( ( itemIndex < 0 ) || ( columnIndex < 0 ) ) return false; SelectionCellRange cellRange = new SelectionCellRange( itemIndex, columnIndex ); int count = m_list.Count; for( int i = 0; i < count; i++ ) { if( !m_list[ i ].CellRange.Intersect( cellRange ).IsEmpty ) return true; } return false; }
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 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 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 != -1 ) { 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 == -1 ) 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 IEnumerable <SelectionCellRangeWithItems> GetIntersectedCellRangesWithItems(SelectionCellRange range) { return((from match in this.IndexOfOverlap(range) let current = m_unsortedRanges[match].Value let intersection = current.CellRange.Intersect(range) select new SelectionCellRangeWithItems( intersection.ItemRange, current.ItemRangeWithItems.GetItems(intersection.ItemRange), intersection.ColumnRange)).ToList()); }
private static bool IsEmpty(SelectionCellRange range) { return((range.ItemRange.IsEmpty) || (range.ColumnRange.IsEmpty)); }
public List<SelectionCellRangeWithItems> GetIntersectedCellRangesWithItems( SelectionCellRange cellRange ) { List<SelectionCellRangeWithItems> intersectionCellRanges = new List<SelectionCellRangeWithItems>(); int count = m_list.Count; for( int i = 0; i < count; i++ ) { SelectionCellRangeWithItems range = m_list[ i ]; SelectionCellRange cellRangeIntersection = range.CellRange.Intersect( cellRange ); if( !cellRangeIntersection.IsEmpty ) { intersectionCellRanges.Add( new SelectionCellRangeWithItems( cellRangeIntersection.ItemRange, range.ItemRangeWithItems.GetItems( cellRangeIntersection.ItemRange ), cellRangeIntersection.ColumnRange ) ); } } return intersectionCellRanges; }
public SelectionCellRange[] Exclude( SelectionCellRange cellRangeToExclude ) { if( cellRangeToExclude.IsEmpty ) return new SelectionCellRange[] { this }; SelectionCellRange cellRangeIntersection = this.Intersect( cellRangeToExclude ); if( cellRangeIntersection.IsEmpty ) return new SelectionCellRange[] { this }; SelectionRange[] itemRanges = m_itemRange.Exclude( cellRangeToExclude.ItemRange ); SelectionRange[] columnRanges = m_columnRange.Exclude( cellRangeToExclude.ColumnRange ); SelectionCellRange[] cellRanges = new SelectionCellRange[ itemRanges.Length + columnRanges.Length ]; int index = 0; foreach( SelectionRange itemRange in itemRanges ) { cellRanges[ index ] = new SelectionCellRange( itemRange, m_columnRange ); index++; } foreach( SelectionRange columnRange in columnRanges ) { cellRanges[ index ] = new SelectionCellRange( cellRangeIntersection.ItemRange, columnRange ); index++; } Debug.Assert( index == cellRanges.Length ); return cellRanges; }
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 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); } }
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 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 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 SelectionCellRange Intersect( SelectionCellRange range ) { SelectionCellRange cellRangeIntersection = SelectionCellRange.Empty; SelectionRange itemRange = range.ItemRange; SelectionRange itemRangeIntersection = m_itemRange.Intersect( itemRange ); if( itemRangeIntersection.IsEmpty ) return SelectionCellRange.Empty; SelectionRange columnRange = range.ColumnRange; SelectionRange columnRangeIntersection = m_columnRange.Intersect( columnRange ); if( columnRangeIntersection.IsEmpty ) return SelectionCellRange.Empty; return new SelectionCellRange( itemRangeIntersection, columnRangeIntersection ); }