void Add(NotifyCollectionChangedEventArgs args) { if (NotLoadedYet()) { _collectionView.ReloadData(); return; } var startIndex = args.NewStartingIndex > -1 ? args.NewStartingIndex : IndexOf(args.NewItems[0]); var count = args.NewItems.Count; if (!_grouped && _collectionView.NumberOfItemsInSection(_section) == 0) { // Okay, we're going from completely empty to more than 0 items; there's an iOS bug which apparently // will just crash if we call InsertItems here, so we have to do ReloadData. _collectionView.ReloadData(); Count += count; return; } _collectionView.PerformBatchUpdates(() => { var indexes = CreateIndexesFrom(startIndex, count); _collectionView.InsertItems(indexes); Count += count; }, null); }
void Add(NotifyCollectionChangedEventArgs args) { var startIndex = args.NewStartingIndex > -1 ? args.NewStartingIndex : _itemsSource.IndexOf(args.NewItems[0]); var count = args.NewItems.Count; _collectionView.InsertItems(CreateIndexesFrom(startIndex, count)); }
private async Task InsertItemsAsync(UICollectionView collectionView, IReadOnlyCollection <int> indexes) { await collectionView.PerformBatchUpdatesAsync(() => { ItemsCount = _itemCollection.Count; InvokeHeightWillChange(); collectionView.InsertItems(indexes.ToNSIndexPaths().ToArray()); }); }
public virtual void InsertItems(IndexPath[] indexPaths) { if (!_collectionView.Busy) { _collectionView.Progress = 0.0f; _collectionView.InsertItems(indexPaths); } }
private void AddItem(IAutoDropItem item) { CollectionResult.PerformBatchUpdates(delegate { var now = ResultItems.Count; ResultItems.Add(item); CollectionResult.InsertItems(new NSIndexPath[] { NSIndexPath.FromRowSection(now, 0) }); }, null); HeightOfCollection.Constant = CollectionResult.CollectionViewLayout.CollectionViewContentSize.Height; }
void Add(NotifyCollectionChangedEventArgs args) { var count = args.NewItems.Count; Count += count; var startIndex = args.NewStartingIndex > -1 ? args.NewStartingIndex : IndexOf(args.NewItems[0]); // Queue up the updates to the UICollectionView Update(() => CollectionView.InsertItems(CreateIndexesFrom(startIndex, count)), args); }
public NSIndexPath InsertItemView(DateTimeOffset startTime, TimeSpan duration) { if (!IsEditing) { throw new InvalidOperationException("Set IsEditing before calling insert/update/remove"); } editingItemIndexPath = insertCalendarItem(startTime, duration); collectionView.InsertItems(new NSIndexPath[] { editingItemIndexPath }); return(editingItemIndexPath); }
async Task Add(NotifyCollectionChangedEventArgs args) { if (ReloadRequired()) { await Reload(); return; } var count = args.NewItems.Count; Count += count; var startIndex = args.NewStartingIndex > -1 ? args.NewStartingIndex : IndexOf(args.NewItems[0]); // Queue up the updates to the UICollectionView BatchUpdate(() => _collectionView.InsertItems(CreateIndexesFrom(startIndex, count))); }
void Add(NotifyCollectionChangedEventArgs args) { var startIndex = args.NewStartingIndex > -1 ? args.NewStartingIndex : _itemsSource.IndexOf(args.NewItems[0]); var count = args.NewItems.Count; _collectionView.PerformBatchUpdates(() => { if (!_grouped && _collectionView.NumberOfSections() != GroupCount) { // We had an empty non-grouped list, and now we're trying to add an item; // we need to give it a section as well _collectionView.InsertSections(new NSIndexSet(0)); } _collectionView.InsertItems(CreateIndexesFrom(startIndex, count)); }, null); }
public void PhotoLibraryDidChange(PHChange changeInstance) { // Check if there are changes to the assets we are showing. var collectionChanges = changeInstance.GetFetchResultChangeDetails(AssetsFetchResults); if (collectionChanges == null) { return; } DispatchQueue.MainQueue.DispatchAsync(() => { // Get the new fetch result. AssetsFetchResults = collectionChanges.FetchResultAfterChanges; UICollectionView collectionView = CollectionView; if (collectionChanges.HasIncrementalChanges || !collectionChanges.HasMoves) { collectionView.PerformBatchUpdates(() => { var removedIndexes = collectionChanges.RemovedIndexes; if (removedIndexes != null && removedIndexes.Count > 0) { collectionView.DeleteItems(removedIndexes.GetIndexPaths(0)); } var insertedIndexes = collectionChanges.InsertedIndexes; if (insertedIndexes != null && insertedIndexes.Count > 0) { collectionView.InsertItems(insertedIndexes.GetIndexPaths(0)); } var changedIndexes = collectionChanges.ChangedIndexes; if (changedIndexes != null && changedIndexes.Count > 0) { collectionView.ReloadItems(changedIndexes.GetIndexPaths(0)); } }, null); } else { collectionView.ReloadData(); } ResetCachedAssets(); }); }
public void Execute() { // If we have incremental diffs, animate them in the collection view _collectionView.PerformBatchUpdates(() => { // For indexes to make sense, updates must be in this order: // delete, insert, reload, move if (_changes.RemovedIndexes?.Count > 0) { var result = new List <NSIndexPath>(); _changes.RemovedIndexes.EnumerateIndexes((nuint idx, ref bool stop) => result.Add(NSIndexPath.FromItemSection((nint)idx, _sectionIndex))); _collectionView.DeleteItems(result.ToArray()); } if (_changes.InsertedIndexes?.Count > 0) { var result = new List <NSIndexPath>(); _changes.InsertedIndexes.EnumerateIndexes((nuint idx, ref bool stop) => result.Add(NSIndexPath.FromItemSection((nint)idx, _sectionIndex))); _collectionView.InsertItems(result.ToArray()); } if (_changes.ChangedIndexes?.Count > 0) { var result = new List <NSIndexPath>(); _changes.ChangedIndexes.EnumerateIndexes((nuint idx, ref bool stop) => result.Add(NSIndexPath.FromItemSection((nint)idx, _sectionIndex))); _collectionView.ReloadItems(result.ToArray()); } _changes.EnumerateMoves((fromIndex, toIndex) => { _collectionView.MoveItem(NSIndexPath.FromItemSection((nint)fromIndex, _sectionIndex), NSIndexPath.FromItemSection((nint)toIndex, _sectionIndex)); }); }, null); }
void Add(NotifyCollectionChangedEventArgs args) { var startIndex = args.NewStartingIndex > -1 ? args.NewStartingIndex : _itemsSource.IndexOf(args.NewItems[0]); var count = args.NewItems.Count; if (!_grouped && _collectionView.NumberOfSections() != GroupCount && count > 0) { // Okay, we're going from completely empty to more than 0 items; this means we don't even // have a section 0 yet. Inserting a section 0 manually results in an unexplained crash, so instead // we'll just reload the data so the UICollectionView can get its internal state sorted out. _collectionView.ReloadData(); } else { _collectionView.PerformBatchUpdates(() => { var indexes = CreateIndexesFrom(startIndex, count); _collectionView.InsertItems(indexes); }, null); } }
void HandleChatPromptTypesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) { collectionView.PerformBatchUpdates(() => { var safetyCheckAdded = e.NewItems != null && e.NewItems.Count > 0; if (safetyCheckAdded) { collectionView.InsertItems(new NSIndexPath[] { NSIndexPath.FromItemSection(e.NewStartingIndex, 0) }); } else { collectionView.DeleteItems(new NSIndexPath[] { NSIndexPath.FromItemSection(2, 0) }); } ((UICollectionViewFlowLayout)collectionView.CollectionViewLayout).ItemSize = new CGSize { Height = Shared.Constants.PulloutBottomMargin, Width = UIScreen.MainScreen.Bounds.Width / (safetyCheckAdded ? 3 : 2), }; collectionView.CollectionViewLayout.InvalidateLayout(); }, null); }
void HandleChatMessagesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) { InvokeOnMainThread(() => { var indexPaths = new List <NSIndexPath>(); if (e.NewItems != null) { for (var i = 0; i < e.NewItems.Count; i++) { indexPaths.Add(NSIndexPath.FromItemSection(e.NewStartingIndex + i, 0)); } chatCollectionView.PerformBatchUpdates( () => chatCollectionView.InsertItems(indexPaths.ToArray()), finished => ScrollChatToBottom() ); } else { chatCollectionView.ReloadSections(NSIndexSet.FromIndex(0)); } }); }
private void HandleCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { if (_view == null) { return; } Action act = () => { switch (e.Action) { case NotifyCollectionChangedAction.Add: { var count = e.NewItems.Count; var paths = new NSIndexPath[count]; for (var i = 0; i < count; i++) { paths[i] = NSIndexPath.FromRowSection(e.NewStartingIndex + i, 0); } _view.InsertItems(paths); } break; case NotifyCollectionChangedAction.Remove: { var count = e.OldItems.Count; var paths = new NSIndexPath[count]; for (var i = 0; i < count; i++) { var index = NSIndexPath.FromRowSection(e.OldStartingIndex + i, 0); paths[i] = index; var item = e.OldItems[i]; if (Equals(SelectedItem, item)) { SelectedItem = default(TItem); } } _view.DeleteItems(paths); } break; default: _view.ReloadData(); break; } }; var isMainThread = Thread.CurrentThread == _mainThread; if (isMainThread) { act(); } else { NSOperationQueue.MainQueue.AddOperation(act); NSOperationQueue.MainQueue.WaitUntilAllOperationsAreFinished(); } }