public new void Remove(T item)
{
if (base.Remove(item))
{
ItemsRemoved?.Invoke(this, new ObservableListModified <T>(new List <T> {
item
}));
}
}
private void Nodes_ItemsRemoved(object sender, ObservableListModified <DarkTreeNode> e)
{
if (Nodes.Count == 0)
{
Expanded = false;
}
ItemsRemoved?.Invoke(this, e);
}
protected void OnItemsRemoved()
{
if (_disableChangeEvents > 0)
{
return;
}
UpdateScrollbar();
ItemsRemoved?.Invoke(this);
}
/// <summary>
/// Adds the removed item.
/// </summary>
/// <param name="item">The item.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddRemovedItem(BaseItem item)
{
if (item == null)
{
throw new ArgumentNullException();
}
ItemsRemoved.Add(item);
}
public new void Remove(T item)
{
base.Remove(item);
ItemsRemoved?.Invoke(this, new ObservableListModified <T>(new List <T> {
item
}));
ItemsChanged?.Invoke(this, new ObservableListChanged <T>(new List <T> {
item
}, NotifyCollectionChangedAction.Remove));
}
public new void Clear()
{
ObservableListModified <T> removed = new(this.ToList <T>());
base.Clear();
if (removed.Items.Any())
{
ItemsRemoved?.Invoke(this, removed);
}
}
public int MoveWindow(IEnumerable <T> nextItems)
{
ItemsRemoved.DequeueAll();
ItemsInside.EnqueueAll(ItemsInserted.DequeueAll());
StrongBox <int> amount = new StrongBox <int>(0);
nextItems.ForEach(newItem =>
{
ItemsInserted.Enqueue(newItem);
ItemsRemoved.Enqueue(ItemsInside.Dequeue());
amount.Value++;
});
return(amount.Value);
}
private void RaiseItemsRemoved(T[] items)
{
OnItemsRemoved(items);
if (ItemsRemoved != null)
{
if (IsLockUpdating)
{
EnqueueEvent(ItemsRemoved, new object[] { items });
}
else
{
ItemsRemoved?.Invoke(items);
}
}
RaiseCollectionChanged();
}
// --------------------------------------------------------------------------------------------------------------------------
public void RemoveAt(int index)
{
T toRemove = _List[index];
_List.RemoveAt(index);
if (CollectionChanged != null)
{
// NOTE: The 'Remove' actions will cause access violations in downstream XAML components.
// A special thanks goes out to MS for allowing this garbage to make it to production!
var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
CollectionChanged(this, args);
ItemsRemoved?.Invoke(this, new ItemsChangedEventArgs(toRemove));
NotifyChange(nameof(Count));
}
}
// --------------------------------------------------------------------------------------------------------------------------
public bool Remove(T item)
{
bool res = _List.Remove(item);
if (res && CollectionChanged != null)
{
// NOTE: The 'Remove' actions will cause access violations in downstream XAML components.
// A special thanks goes out to MS for allowing this garbage to make it to production!
var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset); //new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item);
CollectionChanged(this, args);
ItemsRemoved?.Invoke(this, new ItemsChangedEventArgs(item));
NotifyChange(nameof(Count));
}
return(res);
}
protected virtual void OnItemsRemoved(List <T> items)
{
ItemsRemoved?.Invoke(this, new PersistedEventArgs <T>(items));
}
private void Content_Removed(object sender, PropStoreEventArgs e)
{
ItemsRemoved?.Invoke(this, e);
}
/// <summary>
///
/// </summary>
/// <param name="OldItems"></param>
protected virtual void OnItemsRemoved(IEnumerable <T> OldItems)
{
itemsRemoved?.Invoke(this, new EventArgs <IEnumerable <object> >(OldItems.As <IEnumerable>()?.Cast <object>() ?? Enumerable.Empty <object>()));
ItemsRemoved?.Invoke(this, new EventArgs <IEnumerable <T> >(OldItems));
}
public ReactiveObservableCollection()
{
this.ObservableCollection = new ObservableCollection <T>();
ItemsAdded.Subscribe(ObservableCollection.Add);
ItemsRemoved.Subscribe((x) => ObservableCollection.Remove(x));
}
/// <summary>
/// Событие при удалении элемента из списка.
/// </summary>
/// <param name="e"></param>
protected virtual void OnItemsRemoved(EventArgs e)
{
ItemsRemoved?.Invoke(this, e);
}
public void Clear()
{
ItemsRemoved?.Invoke(_list);
_list.Clear();
}
protected virtual void OnItemsRemoved(ICollection items) => ItemsRemoved?.Invoke(this, new CollectionItemsChangedEventArgs(items));
public Vector ChangedCountVector()
{
var vec = ItemsInserted.CountVector() - ItemsRemoved.CountVector();
return(vec);
}
private void OnItemsRemoved(object sender, DataChangedEventArgs <TEntity> e)
{
ItemsRemoved?.Invoke(this, e);
}
protected virtual void OnItemsRemoved(EventArgs <IEnumerable <IStudent> > e)
{
ItemsRemoved?.Invoke(this, e);
}
