private void Items_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (!(e.OldItems is null))
{
List <Control> removedItems = e.OldItems.Cast <Control> ( ).
Where(
control
=> !e ? .NewItems ? .Contains(control) ?? true).
ToList( );
foreach (Control control in removedItems)
{
control.Container = null;
ItemsRemoved? .Invoke(this, new ContainerControlEventArgs ( control ));
}
}
if (!(e.NewItems is null))
{
List <Control> newItems = e.NewItems.Cast <Control> ( ).
Where(control => !e ? .OldItems ? .Contains(control) ?? true).
ToList( );
foreach (Control control in newItems)
{
control.Container = this;
ItemsAdded? .Invoke(this, new ContainerControlEventArgs ( control ));
}
}
}
private void _CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
ItemsAdded?.Invoke(this, e);
break;
case NotifyCollectionChangedAction.Remove:
ItemsRemoved?.Invoke(this, e);
break;
case NotifyCollectionChangedAction.Replace:
break;
case NotifyCollectionChangedAction.Move:
break;
case NotifyCollectionChangedAction.Reset:
break;
default:
break;
}
}
private void _CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
IVector item = (IVector)e.NewItems[0];
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
item.Position = Count;
if (string.IsNullOrEmpty(item.Header))
{
item.Header = DefaultPrefix + Count;
}
ItemsAdded?.Invoke(this, e);
break;
case NotifyCollectionChangedAction.Remove:
ItemsRemoved?.Invoke(this, e);
break;
case NotifyCollectionChangedAction.Replace:
break;
case NotifyCollectionChangedAction.Move:
break;
case NotifyCollectionChangedAction.Reset:
break;
default:
break;
}
}
public new void Add(T item)
{
base.Add(item);
ItemsAdded?.Invoke(this, new ObservableListModified <T>(new List <T> {
item
}));
}
public new void AddRange(IEnumerable<T> collection)
{
var list = collection.ToList();
base.AddRange(list);
ItemsAdded?.Invoke(this, new ObservableListModified<T>(list));
}
public override void AddItem(GrepResult item)
{
base.AddItem(item);
ItemsAdded?.Invoke(new List <GrepResult>()
{
item
}, EventArgs.Empty);
}
public void AddRange(IEnumerable <T> list)
{
var newItems = list.ToArray().Where(x => !_list.Contains(x)).ToArray();
_list.InsertRange(0, newItems);
ItemsAdded?.Invoke(newItems);
}
public new void Add(T item)
{
base.Add(item);
ItemsAdded?.Invoke(this, new ObservableListModified <T>(new List <T> {
item
}));
ItemsChanged?.Invoke(this, new ObservableListChanged <T>(new List <T> {
item
}, NotifyCollectionChangedAction.Add));
}
// --------------------------------------------------------------------------------------------------------------------------
public void Insert(int index, T item)
{
_List.Insert(index, item);
if (CollectionChanged != null)
{
CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
}
NotifyChange(nameof(Count));
ItemsAdded?.Invoke(this, new ItemsChangedEventArgs(item));
}
public void AddItemRange(IEnumerable <KeyCollectionItem> items)
{
foreach (var item in items)
{
Items.Add(item);
}
if (ItemsAdded != null)
{
ItemsAdded.Invoke(items);
}
}
// --------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Returns the index of the new item.
/// </summary>
public int Add(object value)
{
T item = (T)value;
this.Add(item);
int index = _List.Count - 1;
CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));
ItemsAdded?.Invoke(this, new ItemsChangedEventArgs(item));
NotifyChange(nameof(Count));
return(index);
}
private void Nodes_ItemsAdded(object sender, ObservableListModified <DarkTreeNode> e)
{
foreach (var node in e.Items)
{
node.ParentNode = this;
node.ParentTree = ParentTree;
}
if (ParentTree?.TreeViewNodeSorter != null)
{
Nodes.Sort(ParentTree.TreeViewNodeSorter);
}
ItemsAdded?.Invoke(this, e);
}
private void RaiseItemsAdded(T[] items)
{
OnItemsAdded(items);
if (ItemsAdded != null)
{
if (IsLockUpdating)
{
EnqueueEvent(ItemsAdded, new object[] { items });
}
else
{
ItemsAdded?.Invoke(items);
}
}
RaiseCollectionChanged();
}
/// <summary>
/// Событие при добавлении элемента в список.
/// </summary>
/// <param name="e"></param>
protected virtual void OnItemsAdded(EventArgs e)
{
ItemsAdded?.Invoke(this, e);
}
protected virtual void OnItemsAdded(ICollection items) => ItemsAdded?.Invoke(this, new CollectionItemsChangedEventArgs(items));
public override void AddItemRange(IEnumerable <GrepResult> itemCollection)
{
base.AddItemRange(itemCollection);
ItemsAdded?.Invoke(itemCollection, EventArgs.Empty);
}
protected virtual void OnItemsAdded(EventArgs <IEnumerable <IStudent> > e)
{
ItemsAdded?.Invoke(this, e);
}
/// <summary>
///
/// </summary>
/// <param name="Items"></param>
protected virtual void OnItemsAdded(IEnumerable <T> Items)
{
itemsAdded?.Invoke(this, new EventArgs <IEnumerable <object> >(Items.As <IEnumerable>()?.Cast <object>() ?? Enumerable.Empty <object>()));
ItemsAdded?.Invoke(this, new EventArgs <IEnumerable <T> >(Items));
}
public bool TryAddItems(Item item, int amount)
{
if (amount < 1)
{
return(false);
}
var slots = slotToItemBatch.Where(s => s.Value == null || s.Value.item == item).ToArray();
if (slots.Length <= 0)
{
return(false);
}
float totalWeight = item.stackWeight * amount;
//If the total weight is greater than the space we have we cant add the items.
if (totalWeight > slots.Sum(kvp => kvp.Value != null ? maxBatchSize - kvp.Value.fillLevel : maxBatchSize))
{
return(false);
}
List <IItemInstance> addedItemInstances = new List <IItemInstance>();
int addedItems = 0;
//at this point we know there is enough space in the inventory to add all items.
for (int i = 0; i < slots.Length; i++)
{
var kvp = slots[i];
//while there is space in a given item batch, add items to this item batch
//Then proceed with the next batch.
while (
kvp.Value == default ||
kvp.Value.fillLevel < maxBatchSize)
{
IItemInstance addedInstance = default;
if (kvp.Value == null)
{
addedInstance = ItemManager.CreateItemInstance(item, null);
CreateNewItemBatch(item, addedInstance, kvp.Key);
}
else
{
addedInstance = kvp.Value.AddNew(1)[0];
}
addedItemInstances.Add(addedInstance);
++addedItems;
if (addedItems >= amount)
{
break;
}
}
if (addedItems >= amount)
{
break;
}
}
ItemsAdded?.Invoke(addedItemInstances);
ItemAdded?.Invoke(addedItemInstances[0]);
UpdateEmptyBatches();
return(true);
}
protected virtual void OnItemsAdded(List <T> items)
{
ItemsAdded?.Invoke(this, new PersistedEventArgs <T>(items));
}
private void Content_Added(object sender, PropStoreEventArgs e)
{
ItemsAdded?.Invoke(this, e);
}
private void OnItemsAdded(object sender, DataChangedEventArgs <TEntity> e)
{
ItemsAdded?.Invoke(this, e);
}
