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