/// <summary> /// If a new item has been added to the list, and <paramref name="itemIndex" /> is the position of that item, /// remove it from the list and cancel the add operation. /// </summary> /// <param name="itemIndex"> Index of item to be removed as a result of the cancellation of a previous addition. </param> void ICancelAddNew.CancelNew(int itemIndex) { if (_addNewIndex >= 0 && itemIndex == _addNewIndex) { var item = _viewData.List[_addNewIndex]; _listener.UnregisterEntityEvents(item); var oldIndex = _addNewIndex; // Reset the addNewIndex here so that the IObjectView.CollectionChanged method // will not attempt to examine the item being removed. // See IObjectView.CollectionChanged method for details. _addNewIndex = -1; try { _suspendEvent = true; _viewData.Remove(item, true); } finally { _suspendEvent = false; } OnListChanged(ListChangedType.ItemDeleted, oldIndex, -1); } }
public ListChangedEventArgs OnCollectionChanged( object sender, CollectionChangeEventArgs e, ObjectViewListener listener) { ListChangedEventArgs changedEventArgs = (ListChangedEventArgs)null; switch (e.Action) { case CollectionChangeAction.Add: if (e.Element is TViewElement && !this._itemCommitPending) { TViewElement element = (TViewElement)e.Element; this._bindingList.Add(element); listener.RegisterEntityEvents((object)element); changedEventArgs = new ListChangedEventArgs(ListChangedType.ItemAdded, this._bindingList.Count - 1, -1); break; } break; case CollectionChangeAction.Remove: if (e.Element is TViewElement) { TViewElement element = (TViewElement)e.Element; int newIndex = this._bindingList.IndexOf(element); if (newIndex != -1) { this._bindingList.Remove(element); listener.UnregisterEntityEvents((object)element); changedEventArgs = new ListChangedEventArgs(ListChangedType.ItemDeleted, newIndex, -1); break; } break; } break; case CollectionChangeAction.Refresh: foreach (TViewElement binding in this._bindingList) { listener.UnregisterEntityEvents((object)binding); } this._bindingList.Clear(); foreach (TViewElement viewElement in this._entityCollection.GetInternalEnumerable()) { this._bindingList.Add(viewElement); listener.RegisterEntityEvents((object)viewElement); } changedEventArgs = new ListChangedEventArgs(ListChangedType.Reset, -1, -1); break; } return(changedEventArgs); }
public ListChangedEventArgs OnCollectionChanged(object sender, CollectionChangeEventArgs e, ObjectViewListener listener) { ListChangedEventArgs changeArgs = null; // Since event is coming from cache and it might be shared among different queries // we have to check to see if correct event is being handled. if (e.Element.GetType().IsAssignableFrom(typeof(TElement)) && _bindingList.Contains((TElement)(e.Element))) { var item = (TElement)e.Element; var itemIndex = _bindingList.IndexOf(item); if (itemIndex >= 0) // Ignore entities that we don't know about. { // Only process "remove" events. Debug.Assert(e.Action != CollectionChangeAction.Refresh, "Cache should never fire with refresh, it does not have clear"); if (e.Action == CollectionChangeAction.Remove) { _bindingList.Remove(item); listener.UnregisterEntityEvents(item); changeArgs = new ListChangedEventArgs(ListChangedType.ItemDeleted, itemIndex /* newIndex*/, -1 /* oldIndex*/); } } } return(changeArgs); }
public ListChangedEventArgs OnCollectionChanged( object sender, CollectionChangeEventArgs e, ObjectViewListener listener) { ListChangedEventArgs changedEventArgs = (ListChangedEventArgs)null; if (e.Element.GetType().IsAssignableFrom(typeof(TElement)) && this._bindingList.Contains((TElement)e.Element)) { TElement element = (TElement)e.Element; int newIndex = this._bindingList.IndexOf(element); if (newIndex >= 0 && e.Action == CollectionChangeAction.Remove) { this._bindingList.Remove(element); listener.UnregisterEntityEvents((object)element); changedEventArgs = new ListChangedEventArgs(ListChangedType.ItemDeleted, newIndex, -1); } } return(changedEventArgs); }
public ListChangedEventArgs OnCollectionChanged(object sender, CollectionChangeEventArgs e, ObjectViewListener listener) { ListChangedEventArgs changeArgs = null; switch (e.Action) { case CollectionChangeAction.Remove: // An Entity is being removed from entity collection, remove it from list. if (e.Element is TViewElement) { var removedItem = (TViewElement)e.Element; var oldIndex = _bindingList.IndexOf(removedItem); if (oldIndex != -1) { _bindingList.Remove(removedItem); // Unhook from events of removed entity. listener.UnregisterEntityEvents(removedItem); changeArgs = new ListChangedEventArgs(ListChangedType.ItemDeleted, oldIndex /* newIndex*/, -1 /* oldIndex*/); } } break; case CollectionChangeAction.Add: // Add the entity to our list. if (e.Element is TViewElement) { // Do not process Add events that fire as a result of committing an item to the entity collection. if (!_itemCommitPending) { var addedItem = (TViewElement)e.Element; _bindingList.Add(addedItem); // Register to its events. listener.RegisterEntityEvents(addedItem); changeArgs = new ListChangedEventArgs( ListChangedType.ItemAdded, _bindingList.Count - 1 /* newIndex*/, -1 /* oldIndex*/); } } break; case CollectionChangeAction.Refresh: foreach (var entity in _bindingList) { listener.UnregisterEntityEvents(entity); } _bindingList.Clear(); foreach (TViewElement entity in _entityCollection.GetInternalEnumerable()) { _bindingList.Add(entity); listener.RegisterEntityEvents(entity); } changeArgs = new ListChangedEventArgs(ListChangedType.Reset, -1 /*newIndex*/, -1 /*oldIndex*/); break; } return(changeArgs); }