/// <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);
}
