public CollectionChange(CollectionChangeType type, int sourceIndex, int destinationIndex, int count) { Type = type; SourceIndex = sourceIndex; DestinationIndex = destinationIndex; Count = count; }
private void OnChange(T item, CollectionChangeType type) { if (Change != null) { this.Change(item, type); } }
void Notify(CollectionChangeType type, T item) { if (this.Changed != null) { this.Changed(type, item); } }
public void RaisePrimitiveCollectionChanged(ICartesianPrimitive primitive, CollectionChangeType changeType) { PrimitiveCollectionChanged(this, new PrimitiveCollectionChangedEventArgs() { Primitive = primitive, IsAdded = changeType }); }
/// <summary> /// Constructor used for add/delete/replace /// </summary> /// <param name="coll">Collection to work with</param> /// <param name="type">Type of change</param> /// <param name="oldPos">Position of change</param> /// <param name="newPos">New position of change</param> /// <param name="oldValue">Old value at position</param> /// <param name="newValue">New value at position</param> public CollectionChangeUndo(IList coll, CollectionChangeType type, int oldPos, int newPos, object oldValue, object newValue) { _collection = coll; _changeType = type; _pos = oldPos; _newPos = newPos; _oldValue = oldValue; _newValue = newValue; }
public void AddCollectionChangedItem_Adds_ChangedItem(CollectionChangeType changeType) { // arrange var entity = TestHelper.CreateEntityWithId <Artist>(1); var propertyChangeTracker = new PropertyChangeTracker(entity); // act propertyChangeTracker.AddCollectionChangedItem(new CollectionChangedItem("StatisticValues", null, changeType)); // assert Assert.True(propertyChangeTracker.HasChanged <Artist>(x => x.StatisticValues)); }
/// <summary> /// Initializes a new instance of the <see cref="CollectionChangeUndo"/> class. /// </summary> /// <param name="collection">Collection to work with.</param> /// <param name="type">Type of change.</param> /// <param name="oldPosition">Position of change.</param> /// <param name="newPosition">New position of change.</param> /// <param name="oldValue">Old value at position.</param> /// <param name="newValue">New value at position.</param> /// <param name="tag">The tag.</param> /// <exception cref="ArgumentNullException">The <paramref name="collection" /> is <c>null</c>.</exception> public CollectionChangeUndo(IList collection, CollectionChangeType type, int oldPosition, int newPosition, object oldValue, object newValue, object tag = null) : base(collection, tag) { Argument.IsNotNull("collection", collection); ChangeType = type; Position = oldPosition; NewPosition = newPosition; OldValue = oldValue; NewValue = newValue; CanRedo = true; }
/// <summary> /// Tries to get the changed collection items. /// </summary> /// <param name="propertyName">The property name.</param> /// <param name="changeType">The collection change type.</param> /// <param name="items">The items.</param> /// <returns>Returns true if the changed values could be recovered.</returns> public bool TryGetChangedCollectionItems(string propertyName, CollectionChangeType changeType, out List <Entity> items) { items = new List <Entity>(); var collectionChanges = _collectionChangedItems.Where(x => x.PropertyName == propertyName && x.CollectionChangeType == changeType); if (!collectionChanges.Any()) { return(false); } items = collectionChanges.Select(x => x.Item).ToList(); return(true); }
public void AddCollectionChangedItem_Prevents_Unneccessary_Changes(CollectionChangeType changeType) { // arrange var entity = TestHelper.CreateEntityWithId <Artist>(1); var propertyChangeTracker = new PropertyChangeTracker(entity); var oppositeChangeType = changeType == CollectionChangeType.Added ? CollectionChangeType.Removed : CollectionChangeType.Added; var statisticValue = new ArtistStatisticValues(); // act propertyChangeTracker.AddCollectionChangedItem(new CollectionChangedItem("StatisticValues", statisticValue, changeType)); propertyChangeTracker.AddCollectionChangedItem(new CollectionChangedItem("StatisticValues", statisticValue, oppositeChangeType)); // assert Assert.False(propertyChangeTracker.HasChanged <Artist>(x => x.StatisticValues)); }
private CollectionChangedArgs( CollectionChangeType type, IVMCollection <TItemVM> collection, IEnumerable <TItemVM> oldItems = null, IEnumerable <TItemVM> newItems = null, IChangeReason reason = null ) { Type = type; Collection = collection; Index = -1; OldItems = oldItems ?? Enumerable.Empty <TItemVM>(); NewItems = newItems ?? Enumerable.Empty <TItemVM>(); Reason = reason; }
/// <summary> /// Initializes a new instance of the <see cref="CollectionChangedEventArgs<T>"/> class. /// </summary> /// <param name="changeType">Type of the change.</param> /// <param name="index">The index.</param> /// <param name="oldIndex">The old index.</param> /// <param name="item">The item.</param> public CollectionChangedEventArgs(CollectionChangeType changeType, int index, int oldIndex, T item) { //if( trace.IsDebugLevel ) //{ // trace.Debug( "CollectionChangedEventArgs.ctor( CollectionChangeType, int, {0} )", typeof( T ).Name ); // trace.Debug( "changeType: {0}", changeType ); // trace.Debug( "index: {0}", index ); // trace.Debug( "oldIndex: {0}", oldIndex ); // trace.Debug( "item: {0}", item == null ? "<null>" : item.ToString() ); //} this.ChangeType = changeType; this.Index = index; this.OldIndex = oldIndex; this.Item = item; }
private CollectionChangedArgs( CollectionChangeType type, IVMCollection <TItemVM> collection, int index, TItemVM oldItem = default(TItemVM), TItemVM newItem = default(TItemVM) ) { Type = type; Collection = collection; Index = index; OldItem = oldItem; OldItems = oldItem != null ? new[] { oldItem } : Enumerable.Empty <TItemVM>(); NewItem = newItem; NewItems = newItem != null ? new[] { newItem } : Enumerable.Empty <TItemVM>(); }
public DictionaryEventArgs(CollectionChangeType changeType, object[] keys, object[] newItems, object[] oldItems = null) : base(changeType, newItems, oldItems) { this.Keys = keys; }
/// <summary> /// Initializes a new CollectionChange /// </summary> /// <param name="propertyName">The property name.</param> /// <param name="item">The entity item.</param> /// <param name="changeType">The collection changed type.</param> public CollectionChangedItem(string propertyName, Entity item, CollectionChangeType changeType) { PropertyName = propertyName; Item = item; CollectionChangeType = changeType; }
protected CollectionEventArgs(CollectionChangeType changeType, object[] newItems, object[] oldItems = null) { this.ChangeType = changeType; this.Items = newItems; this.OldItems = oldItems ?? emptyArray; }
/// <summary> /// Initializes a new instance of the <see cref="CollectionChangedEventArgs"/> class. /// </summary> /// <param name="changeType">Type of the change.</param> public CollectionChangedEventArgs(CollectionChangeType changeType) : base() { _changeType = changeType; }
public CollectionChange(object item, int index, CollectionChangeType type) { Item = item; OldIndex = NewIndex = index; Type = type; }
public CollectionChangeEvent(CollectionChangeType type) { Type = type; }
/// <summary> /// Creates new instance. /// </summary> /// <param name="context"></param> /// <param name="type"></param> public CollectionChangedEventArgs(ITypeDescriptorContext context, CollectionChangeType type) { this.Context = context; this.Type = type; }
public IEnumerable <IJsCsGlue> GetGlues(CollectionChangeType @type) => IndividualChanges.Where(ch => ch.CollectionChangeType == @type).Select(change => change.Glue);
/// <summary> /// Tries to get the changed collection items. /// </summary> /// <typeparam name="T">The entity type.</typeparam> /// <typeparam name="TEntityItem">The collection item type.</typeparam> /// <param name="expression">The expression.</param> /// <param name="changeType">The collection change type.</param> /// <param name="items">The changed items.</param> /// <returns>Returns true if the changed values could be recovered.</returns> public bool TryGetChangedCollectionItems <T, TEntityItem>(Expression <Func <T, object> > expression, CollectionChangeType changeType, out List <TEntityItem> items) where T : Entity { items = new List <TEntityItem>(); var collectionChanges = _collectionChangedItems.Where(x => x.PropertyName == GetPropertyName(expression) && x.CollectionChangeType == changeType); if (!collectionChanges.Any()) { return(false); } items = collectionChanges.Select(x => x.Item).OfType <TEntityItem>().ToList(); return(true); }
public IndividualJavascriptCollectionChange(CollectionChangeType collectionChange, int index, IJavascriptObject @object) { CollectionChangeType = collectionChange; Index = index; Object = @object; }
/// <summary> /// Adds a new collection changed item. /// </summary> /// <param name="property">The property.</param> /// <param name="entityItem">The added or removed entity.</param> /// <param name="changeType">The collection change type.</param> public void AddCollectionChangedItem(string property, Entity entityItem, CollectionChangeType changeType) { AddCollectionChangedItem(new CollectionChangedItem(property, entityItem, changeType)); }
public IndividualJavascriptCollectionChange(CollectionChangeType iCollectionChange, int iIndex, IJavascriptObject iObject) { CollectionChangeType=iCollectionChange; Index= iIndex; Object = iObject; }
public IndividualCollectionChange(CollectionChangeType iCollectionChange, int iIndex, IJSCSGlue iObject) { CollectionChangeType=iCollectionChange; Index= iIndex; Object = iObject; }
public IndividualJavascriptCollectionChange(CollectionChangeType iCollectionChange, int iIndex, IJavascriptObject iObject) { CollectionChangeType = iCollectionChange; Index = iIndex; Object = iObject; }
public CollectionChangedEventArgs(CollectionChangeType type) { changeType = type; }
public CollectionChangeEvent(IStatusUpdate item, CollectionChangeType type) { Item = item; Type = type; }
public IndividualCollectionChange(CollectionChangeType iCollectionChange, int iIndex, IJSCSGlue iObject) { CollectionChangeType = iCollectionChange; Index = iIndex; Object = iObject; }
public CollectionChangeEvent(object item, int index, CollectionChangeType type) { Item = item; OldIndex = NewIndex = index; Type = type; }
/// <summary> /// Adds a new collection changed item. /// </summary> /// <typeparam name="T">The entity type.</typeparam> /// <param name="propertyExpression">The expression representing the local property.</param> /// <param name="entityItem">The added or removed entity.</param> /// <param name="changeType">The collection change type.</param> public void AddCollectionChangedItem <T>(Expression <Func <T, object> > propertyExpression, Entity entityItem, CollectionChangeType changeType) where T : Entity { AddCollectionChangedItem(GetPropertyName(propertyExpression), entityItem, changeType); }
/// <summary> /// Initializes a new instance of the <see cref="CollectionChangedEventArgs<T>"/> class. /// </summary> /// <param name="changeType">Type of the change.</param> public CollectionChangedEventArgs(CollectionChangeType changeType) : this(changeType, -1, -1, default(T)) { }
/// <summary> /// Initializes a new instance of the <see cref="CollectionChangedEventArgs<T>"/> class. /// </summary> /// <param name="changeType">Type of the change.</param> /// <param name="index">The index.</param> public CollectionChangedEventArgs(CollectionChangeType changeType, int index) : this(changeType, index, -1, default(T)) { }
protected ListEventArgs(CollectionChangeType changeType, int[] indexes, object[] newItems, object[] oldItems = null) : base(changeType, newItems, oldItems) { this.Indices = indexes; }
/// <summary> /// Called when the collection has been changed. /// </summary> /// <param name="changeType">Type of the change.</param> /// <remarks>Triggers the <see cref="CollectionChanged"/> event.</remarks> private void OnCollectionChanged(CollectionChangeType changeType) { OnCollectionChanged(this, new CollectionChangedEventArgs(changeType)); }