protected override void RemoveItem(int index)
{
T deletedItem = Items[index];
BeforeRemove?.Invoke(this, deletedItem);
base.RemoveItem(index);
}
protected override void RemoveItem(int itemIndex)
{
var deletedItem = Items[itemIndex];
BeforeRemove?.Invoke(deletedItem);
base.RemoveItem(itemIndex);
}
protected override void ClearItems()
{
for (int i = 0; i < Items.Count; ++i)
{
BeforeRemove?.Invoke(this, new RemovingOldEventArgs(Items[i], i));
}
base.ClearItems();
}
/// <inheritdoc />
protected override void RemoveItem(int index)
{
if (RaiseListChangedEvents)
{
BeforeRemove?.Invoke(this, new RemovingOldEventArgs(Items[index], index));
}
base.RemoveItem(index);
}
public new void Remove(T item)
{
if (RaiseListChangedEvents && this.Contains(item))
{
BeforeRemove?.Invoke(new T[] { item });
}
base.Remove(item);
}
protected override void SetItem(int index, T item)
{
T objOldItem = Items[index];
if (!objOldItem.Equals(item))
{
BeforeRemove?.Invoke(this, new RemovingOldEventArgs(objOldItem, index));
}
base.SetItem(index, item);
}
/// <inheritdoc />
protected override void SetItem(int index, T item)
{
if (RaiseListChangedEvents)
{
T objOldItem = Items[index];
if (!ReferenceEquals(objOldItem, item))
{
BeforeRemove?.Invoke(this, new RemovingOldEventArgs(objOldItem, index));
}
}
base.SetItem(index, item);
}
public new void RemoveAt(int index)
{
if (index < 0 || index >= Count)
{
throw new ArgumentOutOfRangeException();
}
if (RaiseListChangedEvents)
{
BeforeRemove?.Invoke(new T[] { base[index] });
}
RemoveItem(index);
}
public new void Remove(TKey key)
{
bool bContains = ContainsKey(TransformKey(key));
if (m_bThrowErrorOnInvalidRemove && !bContains)
{
throw new IndexedDictionaryException("Key does not exist within the Dictionary");
}
else if (!bContains)
{
return;
}
// Raise before events:
DictionaryBeforeEventArgs <TKey, TValue> e = new DictionaryBeforeEventArgs <TKey, TValue>
(key, base[TransformKey(key)]);
// Raise before events:
bool bubble = true;
if (BeforeRemove != null)
{
foreach (DictionaryBeforeDelegate <TKey, TValue> function in BeforeRemove.GetInvocationList())
{
e.Bubble = true;
function.Invoke(this, e);
bubble = bubble && e.Bubble;
}
}
if (!bubble)
{
return;
}
// Remove item:
// Use value returend by event:
m_col.Remove(e.Key);
base.Remove(TransformKey(e.Key));
// Raise after events:
if (AfterRemove != null)
{
AfterRemove.Invoke(this, e);
}
}
/// <summary>
/// Clear the list raising the BeforeRemove event with a list of all items currently in the list (if RaiseListChangedEvents is true).
/// </summary>
public new void Clear()
{
if (RaiseListChangedEvents)
{
BeforeRemove?.Invoke(this);
}
bool fireEvents = RaiseListChangedEvents; //Remember whether or not to raise list change events.
if (Count > 0)
{
RaiseListChangedEvents = false; //Set raise list events to false because we only want to do it once on the last element.
}
while (Count > 0)
{
//Raise list changed once on the last element.
if (Count == 1)
{
RaiseListChangedEvents = fireEvents; //Set RaiseListChangedEvents back to what it's value was at the start of this method.
}
RemoveAt(0);
}
}
public void RemoveRange(IEnumerable <T> items)
{
bool fireEvents = RaiseListChangedEvents;
//TODO: Can use https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.intersect later.
List <T> intersect = new List <T>(); //Items that are in both lists.
foreach (T item in items)
{
if (this.Contains(item))
{
intersect.Add(item);
}
}
if (RaiseListChangedEvents)
{
BeforeRemove?.Invoke(intersect);
}
if (intersect.Count > 0)
{
RaiseListChangedEvents = false;
}
for (int i = intersect.Count - 1; i >= 0; i--)
{
//Raise list changed once on the last element.
if (i == 0)
{
RaiseListChangedEvents = fireEvents;
}
this.Remove(intersect[i]);
intersect.RemoveAt(i);
}
}
protected override void RemoveItem(int index)
{
BeforeRemove?.Invoke(this, new RemovingOldEventArgs(Items[index], index));
base.RemoveItem(index);
}
public void RemoveTask()
{
BeforeRemove?.Invoke();
Dispose();
}
protected override void RemoveItem(int index)
{
BeforeRemove?.Invoke(this, new ListChangedEventArgs(ListChangedType.ItemDeleted, 0, index));
base.RemoveItem(index);
}
/// <summary>
/// Raises the <see cref="BeforeRemove"/> event.
/// </summary>
/// <returns><c>true</c>, if it is OK for the remove-item to continue, <c>false</c> if it is has been cancelled.</returns>
/// <param name="args">Event arguments.</param>
protected bool HandleBeforeRemove(BeforeModifyEventArgs <TItem> args)
{
BeforeRemove?.Invoke(this, args);
return((!(args is ICancelable cancelable)) || !cancelable.IsCancelled);
}
/// <summary>
/// Self-removes from parent control on button click.
/// </summary>
/// <param name="sender">object that requests removal</param>
/// <param name="e">event arguments</param>
private void removeButton_Click(object sender, System.EventArgs e)
{
// Simplified form of if (BeforeRemove != null) { BeforeRemove(this, e); }
BeforeRemove?.Invoke(this, e);
Parent.Controls.Remove(this);
}
