private void ContentChanged(object sender, ContentChangeEventArgs e) { if (!notifyChangesOnly || !Equals(Content.Retrieve(e.OldValue, e.Index, e.Content.Descriptor), Content.Retrieve(e.NewValue, e.Index, e.Content.Descriptor))) { propertyChanged?.Invoke(new[] { propertyName }); } }
private void ContentChanged(object sender, ContentChangeEventArgs e) { if (!notifyChangesOnly || !Equals(e.OldValue, e.NewValue)) { propertyChanged?.Invoke(new[] { propertyName }); } }
private void ContentPrepareChange(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; var path = GetPath(e.Content.OwnerNode); if (node != null) { switch (e.ChangeType) { case ContentChangeType.ValueChange: foreach (var child in node.GetAllChildNodes()) { UnregisterNode(child.Item1); } break; case ContentChangeType.CollectionRemove: if (node.Content.IsReference && e.OldValue != null) { var removedNode = node.Content.Reference.AsEnumerable[e.Index].TargetNode; if (removedNode != null) { foreach (var child in removedNode.GetAllChildNodes()) { UnregisterNode(child.Item1); } UnregisterNode(removedNode); } } break; } } PrepareChange?.Invoke(sender, new GraphContentChangeEventArgs(e, path)); }
private void AssetContentChanging(object sender, ContentChangeEventArgs e) { var overrideValue = OverrideType.Base; var node = (AssetNode)e.Content.OwnerNode; if (e.ChangeType == ContentChangeType.ValueChange || e.ChangeType == ContentChangeType.CollectionRemove) { // For value change and remove, we store the current override state. if (e.Index == Index.Empty) { overrideValue = node.GetContentOverride(); } else if (!node.IsNonIdentifiableCollectionContent) { overrideValue = node.GetItemOverride(e.Index); } } if (e.ChangeType == ContentChangeType.CollectionRemove) { // For remove, we also collect the id of the item that will be removed, so we can pass it to the Changed event. var itemId = ItemId.Empty; CollectionItemIdentifiers ids; if (CollectionItemIdHelper.TryGetCollectionItemIds(e.Content.Retrieve(), out ids)) { ids.TryGet(e.Index.Value, out itemId); } removedItemIds[e.Content.OwnerNode] = itemId; } if (e.ChangeType == ContentChangeType.CollectionAdd && !node.IsNonIdentifiableCollectionContent) { // If the change is an add, we set the previous override as New so the Undo will try to remove the item instead of resetting to the base value previousOverrides[e.Content.OwnerNode] = OverrideType.New; } previousOverrides[e.Content.OwnerNode] = overrideValue; }
private void ContentChanged(object sender, ContentChangeEventArgs e) { if (!updatingValue) { OnPropertyChanged(nameof(VirtualObservableNode <object> .TypedValue)); } }
private void ContentPrepareChange(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; if (node != null) { var visitor = new GraphVisitorBase(); visitor.Visiting += UnregisterNode; visitor.ShouldVisit = shouldRegisterNode; switch (e.ChangeType) { case ContentChangeType.ValueChange: // The changed node itself is still valid, we don't want to unregister it visitor.SkipRootNode = true; visitor.Visit(node); break; case ContentChangeType.CollectionRemove: if (node.Content.IsReference && e.OldValue != null) { var removedNode = node.Content.Reference.AsEnumerable[e.Index].TargetNode; if (removedNode != null) { visitor.Visit(removedNode); } } break; } } PrepareChange?.Invoke(sender, new GraphContentChangeEventArgs(e)); }
public AssetContentChangeEventArgs(ContentChangeEventArgs e, OverrideType previousOverride, OverrideType newOverride, ItemId itemId) : base(e.Content, e.Index, e.ChangeType, e.OldValue, e.NewValue) { PreviousOverride = previousOverride; NewOverride = newOverride; ItemId = itemId; }
private void ContentFinalizeChange(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; if (node != null) { foreach (var child in node.GetAllChildNodes()) { RegisterNode(child); } } FinalizeChange?.Invoke(sender, e); }
private void ContentFinalizeChange(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; var path = GetPath(e.Content.OwnerNode); if (node != null) { foreach (var child in node.GetAllChildNodes(path)) { RegisterNode(child.Item1, child.Item2); } } FinalizeChange?.Invoke(sender, new GraphContentChangeEventArgs(e, path)); }
private void ContentChanged(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; if (node != null) { foreach (var child in GetAllChildNodes(node)) { child.Content.Changing += ContentChanging; child.Content.Changed += ContentChanged; } } Changed?.Invoke(sender, e); }
private void ContentFinalizeChange(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; var path = GetPath(e.Content.OwnerNode); if (node != null) { switch (e.ChangeType) { case ContentChangeType.ValueChange: foreach (var child in node.GetAllChildNodes(path)) { RegisterNode(child.Item1, child.Item2); } break; case ContentChangeType.CollectionAdd: if (node.Content.IsReference && e.NewValue != null) { var index = e.Index; IGraphNode addedNode; if (index != null) { addedNode = node.Content.Reference.AsEnumerable[e.Index].TargetNode; } else { var reference = node.Content.Reference.AsEnumerable.First(x => x.TargetNode.Content.Retrieve() == e.NewValue); index = reference.Index; addedNode = reference.TargetNode; } if (addedNode != null) { var addedNodePath = path?.Append(node, addedNode, GraphNodePath.ElementType.Index, index); RegisterNode(addedNode, addedNodePath); foreach (var child in addedNode.GetAllChildNodes()) { RegisterNode(child.Item1, child.Item2); } } } break; } } FinalizeChange?.Invoke(sender, new GraphContentChangeEventArgs(e, path)); }
private void ContentFinalizeChange(object sender, ContentChangeEventArgs e) { var node = e.Content.OwnerNode as IGraphNode; if (node != null) { var visitor = new GraphVisitorBase(); visitor.Visiting += (node1, path) => RegisterNode(node1); visitor.ShouldVisit = shouldRegisterNode; switch (e.ChangeType) { case ContentChangeType.ValueChange: // The changed node itself is still valid, we don't want to re-register it visitor.SkipRootNode = true; visitor.Visit(node); break; case ContentChangeType.CollectionAdd: if (node.Content.IsReference && e.NewValue != null) { IGraphNode addedNode; Index index; if (!e.Index.IsEmpty) { index = e.Index; addedNode = node.Content.Reference.AsEnumerable[e.Index].TargetNode; } else { var reference = node.Content.Reference.AsEnumerable.First(x => x.TargetNode.Content.Retrieve() == e.NewValue); index = reference.Index; addedNode = reference.TargetNode; } if (addedNode != null) { var path = new GraphNodePath(node).PushIndex(index); visitor.Visit(addedNode, path); } } break; } } FinalizeChange?.Invoke(sender, new GraphContentChangeEventArgs(e)); }
private void AssetContentChanged(object sender, ContentChangeEventArgs e) { var previousOverride = previousOverrides[e.Content.OwnerNode]; previousOverrides.Remove(e.Content.OwnerNode); var itemId = ItemId.Empty; var overrideValue = OverrideType.Base; var node = (AssetNode)e.Content.OwnerNode; if (e.ChangeType == ContentChangeType.ValueChange || e.ChangeType == ContentChangeType.CollectionAdd) { if (e.Index == Index.Empty) { // No index, we're changing an object that is not in a collection, let's just retrieve it's override status. overrideValue = node.GetContentOverride(); } else { // We're changing an item of a collection. If the collection has identifiable items, retrieve the override status of the item. if (!node.IsNonIdentifiableCollectionContent) { overrideValue = node.GetItemOverride(e.Index); } // Also retrieve the id of the modified item (this should fail only if the collection doesn't have identifiable items) CollectionItemIdentifiers ids; if (CollectionItemIdHelper.TryGetCollectionItemIds(e.Content.Retrieve(), out ids)) { ids.TryGet(e.Index.Value, out itemId); } } } else { // When deleting we are always overriding (unless there is no base) overrideValue = !((AssetNode)node.BaseContent?.OwnerNode)?.contentUpdating == true ? OverrideType.New : OverrideType.Base; itemId = removedItemIds[e.Content.OwnerNode]; removedItemIds.Remove(e.Content.OwnerNode); } Changed?.Invoke(sender, new AssetContentChangeEventArgs(e, previousOverride, overrideValue, itemId)); }
private void OnBaseContentChanged(ContentChangeEventArgs e, IContent assetContent) { // Ignore base change if propagation is disabled. if (!Container.PropagateChangesFromBase) { return; } UpdatingPropertyFromBase = true; // TODO: we want to refresh the base only starting from the modified node! RefreshBase(baseGraph); var rootNode = (AssetNode)assetContent.OwnerNode; var visitor = CreateReconcilierVisitor(); visitor.Visiting += (node, path) => ReconcileWithBaseNode((AssetNode)node); visitor.Visit(rootNode); UpdatingPropertyFromBase = false; BaseContentChanged?.Invoke(e, assetContent); }
private void ContentChanged(object sender, ContentChangeEventArgs e) { Changed?.Invoke(sender, new GraphContentChangeEventArgs(e)); }
private void DataContextChanger_DataContextChange(object sender, ContentChangeEventArgs e) { AssociatedObject.Content = e.NewContent; }
private void ContentChanged(object sender, ContentChangeEventArgs e) { // Make sure that we have item ids everywhere we're supposed to. AssetCollectionItemIdHelper.GenerateMissingItemIds(e.Content.Retrieve()); var node = (AssetNode)e.Content.OwnerNode; if (node.IsNonIdentifiableCollectionContent) { return; } // Create new ids for collection items var baseNode = (AssetNode)BaseContent?.OwnerNode; var isOverriding = !baseNode?.contentUpdating == true; var removedId = ItemId.Empty; switch (e.ChangeType) { case ContentChangeType.ValueChange: break; case ContentChangeType.CollectionAdd: { var collectionDescriptor = e.Content.Descriptor as CollectionDescriptor; var itemIds = CollectionItemIdHelper.GetCollectionItemIds(e.Content.Retrieve()); // Compute the id we will add for this item ItemId itemId; if (baseNode?.contentUpdating == true) { var baseCollection = baseNode.Content.Retrieve(); var baseIds = CollectionItemIdHelper.GetCollectionItemIds(baseCollection); itemId = itemIds.FindMissingId(baseIds); } else { itemId = restoringId != ItemId.Empty ? restoringId : ItemId.New(); } // Add the id to the proper location (insert or add) if (collectionDescriptor != null) { if (e.Index != Index.Empty) { itemIds.Insert(e.Index.Int, itemId); } else { throw new InvalidOperationException("An item has been added to a collection that does not have a predictable Add. Consider using NonIdentifiableCollectionItemsAttribute on this collection."); } } else { itemIds[e.Index.Value] = itemId; } } break; case ContentChangeType.CollectionRemove: { var collectionDescriptor = e.Content.Descriptor as CollectionDescriptor; if (collectionDescriptor != null) { var itemIds = CollectionItemIdHelper.GetCollectionItemIds(e.Content.Retrieve()); removedId = itemIds.DeleteAndShift(e.Index.Int, isOverriding); } else { var itemIds = CollectionItemIdHelper.GetCollectionItemIds(e.Content.Retrieve()); removedId = itemIds.Delete(e.Index.Value, isOverriding); } } break; default: throw new ArgumentOutOfRangeException(); } // Don't update override if propagation from base is disabled. if (PropertyGraph?.Container?.PropagateChangesFromBase == false) { return; } // Mark it as New if it does not come from the base if (!baseNode?.contentUpdating == true && !ResettingOverride) { if (e.ChangeType != ContentChangeType.CollectionRemove) { if (e.Index == Index.Empty) { OverrideContent(!ResettingOverride); } else { OverrideItem(!ResettingOverride, e.Index); } } else { OverrideDeletedItem(true, removedId); } } }
/// <summary> /// Initializes a new instance of the <see cref="GraphContentChangeEventArgs"/> class. /// </summary> /// <param name="e">A <see cref="ContentChangeEventArgs"/> instance corresponding to this event.</param> /// <param name="path">The path to the node of content that has been modified.</param> public GraphContentChangeEventArgs(ContentChangeEventArgs e, GraphNodePath path) : this(e.Content, e.Index, e.ChangeType, e.OldValue, e.NewValue, path) { }
private void ContentChanged(object sender, ContentChangeEventArgs e) { Changed?.Invoke(sender, e); }
/// <summary> /// Initializes a new instance of the <see cref="GraphContentChangeEventArgs"/> class. /// </summary> /// <param name="e">A <see cref="ContentChangeEventArgs"/> instance corresponding to this event.</param> public GraphContentChangeEventArgs(ContentChangeEventArgs e) : this(e.Content, e.Index, e.ChangeType, e.OldValue, e.NewValue) { }
private void ContentChanged(object sender, ContentChangeEventArgs e) { var path = GetPath(e.Content.OwnerNode); Changed?.Invoke(sender, new GraphContentChangeEventArgs(e, path)); }