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;
}
}
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 Initialize()
{
ItemsAdded.Subscribe(x =>
{
_toInsert.Add(x);
//Dump();
});
ItemsRemoved.Subscribe(x =>
{
if (x.IsNew)
{
_toInsert.Remove(x);
//Dump();
}
else
{
_toUpdate.Remove(x);
_toDelete.Add(x);
// Dump();
}
});
ItemChanged.Subscribe(x =>
{
if (!x.Sender.IsNew)
{
_toUpdate.Add(x.Sender);
// Dump();
}
});
}
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;
}
}
void setupCollection(IScheduler sched)
{
ChangeTrackingEnabled = true;
_sched = sched ?? RxApp.DeferredScheduler;
invalidateHash();
ItemsAdded.Subscribe(x => {
if (ChangeTrackingEnabled == false) {
return;
}
CreatedOn[x.ContentHash] = _sched.Now;
UpdatedOn[x.ContentHash] = _sched.Now;
});
ItemsRemoved.Subscribe(x => {
if (ChangeTrackingEnabled == false) {
return;
}
CreatedOn.Remove(x.ContentHash);
UpdatedOn.Remove(x.ContentHash);
});
ItemChanged.Subscribe(x => {
if (ChangeTrackingEnabled == false) {
return;
}
UpdatedOn[x.Sender.ContentHash] = _sched.Now;
});
Changed.Subscribe(_ => invalidateHash());
}
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);
}
/// <summary>
/// Adds the new item.
/// </summary>
/// <param name="item">The item.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public void AddNewItem(BaseItem item)
{
if (item == null)
{
throw new ArgumentNullException();
}
ItemsAdded.Add(item);
}
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();
}
public void Add(T item)
{
if (IsAttached)
{
var trackingInfo = Context.ObjectTracker.GetObjectTrackingInfo(item);
if (trackingInfo == null)
{
Rel.TargetDbSet.Add(item);
}
ItemsAdded.Add(item);
}
else
{
InternalCollection.Add(item);
}
}
public ReactiveDerivedCollectionFromObservable(
IObservable <T> observable,
TimeSpan?withDelay = null,
Action <Exception> onError = null,
IScheduler scheduler = null)
{
scheduler = scheduler ?? RxApp.MainThreadScheduler;
_inner = new SingleAssignmentDisposable();
onError = onError ?? (ex => RxApp.DefaultExceptionHandler.OnNext(ex));
if (withDelay == null)
{
_inner.Disposable = observable.ObserveOn(scheduler).Subscribe(InternalAdd, onError);
return;
}
// On a timer, dequeue items from queue if they are available
var queue = new Queue <T>();
var disconnect = Observable.Timer(withDelay.Value, withDelay.Value, scheduler)
.Subscribe(_ =>
{
if (queue.Count > 0)
{
InternalAdd(queue.Dequeue());
}
});
_inner.Disposable = disconnect;
// When new items come in from the observable, stuff them in the queue.
observable.ObserveOn(scheduler).Subscribe(queue.Enqueue, onError);
// This is a bit clever - keep a running count of the items actually
// added and compare them to the final count of items provided by the
// Observable. Combine the two values, and when they're equal,
// disconnect the timer
ItemsAdded.Scan(0, (acc, _) => acc + 1).Zip(
observable.Aggregate(0, (acc, _) => acc + 1),
(l, r) => l == r).Where(x => x).Subscribe(_ => disconnect.Dispose());
}
public ReactiveObservableCollection()
{
this.ObservableCollection = new ObservableCollection <T>();
ItemsAdded.Subscribe(ObservableCollection.Add);
ItemsRemoved.Subscribe((x) => ObservableCollection.Remove(x));
}
private void OnItemsAdded(object sender, DataChangedEventArgs <TEntity> e)
{
ItemsAdded?.Invoke(this, e);
}
public override void AddItemRange(IEnumerable <GrepResult> itemCollection)
{
base.AddItemRange(itemCollection);
ItemsAdded?.Invoke(itemCollection, EventArgs.Empty);
}
protected virtual void OnItemsAdded(ICollection items) => ItemsAdded?.Invoke(this, new CollectionItemsChangedEventArgs(items));
/// <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(EventArgs <IEnumerable <IStudent> > e)
{
ItemsAdded?.Invoke(this, e);
}
private void Content_Added(object sender, PropStoreEventArgs e)
{
ItemsAdded?.Invoke(this, e);
}
/// <summary>
/// Событие при добавлении элемента в список.
/// </summary>
/// <param name="e"></param>
protected virtual void OnItemsAdded(EventArgs e)
{
ItemsAdded?.Invoke(this, e);
}
protected virtual void OnItemsAdded(List <T> items)
{
ItemsAdded?.Invoke(this, new PersistedEventArgs <T>(items));
}
