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