public void TestPushTarget()
{
var obj = new Class {
ClassMember = new Class()
};
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode);
path.PushMember(nameof(Class.ClassMember));
path.PushTarget();
var targetNode = nodeContainer.GetNode(obj.ClassMember);
var nodes = new IGraphNode[] { rootNode, rootNode[nameof(Class.ClassMember)], targetNode };
Assert.NotNull(targetNode);
Assert.False(path.IsEmpty);
AssertAreEqual(rootNode, path.RootNode);
AssertAreEqual(targetNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
AssertAreEqual(nodes[i++], node);
}
AssertAreEqual(nodes.Length, i);
}
public void TestGetParent()
{
var obj = new Class {
StructMember = { StringMember = "aa" }, ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() }
};
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode).PushMember(nameof(Class.IntMember));
var parentPath = new GraphNodePath(rootNode);
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember)).PushMember(nameof(Struct.StringMember));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember));
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget();
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember));
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget();
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember));
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1));
AssertAreEqual(parentPath, path.GetParent());
}
public void TestClone()
{
var obj = new Class {
ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() }
};
var nodeContainer = new NodeContainer();
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
var clone = path1.Clone();
AssertAreEqual(path1, clone);
AssertAreEqual(path1.GetHashCode(), clone.GetHashCode());
AssertAreEqual(path1.RootNode, clone.RootNode);
AssertAreEqual(path1.IsValid, clone.IsValid);
AssertAreEqual(path1.IsEmpty, clone.IsEmpty);
AssertAreEqual(path1.GetNode(), clone.GetNode());
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone();
AssertAreEqual(path2, clone);
AssertAreEqual(path2.RootNode, clone.RootNode);
AssertAreEqual(path2.IsValid, clone.IsValid);
AssertAreEqual(path2.IsEmpty, clone.IsEmpty);
AssertAreEqual(path2.GetNode(), clone.GetNode());
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone();
AssertAreEqual(path3, clone);
AssertAreEqual(path3.RootNode, clone.RootNode);
AssertAreEqual(path3.IsValid, clone.IsValid);
AssertAreEqual(path3.IsEmpty, clone.IsEmpty);
AssertAreEqual(path3.GetNode(), clone.GetNode());
}
public void TestCloneNewRoot()
{
var obj1 = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var obj2 = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var newRoot = nodeContainer.GetOrCreateNode(obj2);
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj1));
var clone = path1.Clone(newRoot);
Assert.AreNotEqual(newRoot, path1.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path1.IsValid, clone.IsValid);
Assert.AreEqual(path1.IsEmpty, clone.IsEmpty);
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone(newRoot);
Assert.AreNotEqual(newRoot, path2.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path2.IsValid, clone.IsValid);
Assert.AreEqual(path2.IsEmpty, clone.IsEmpty);
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone(newRoot);
Assert.AreNotEqual(newRoot, path3.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path3.IsValid, clone.IsValid);
Assert.AreEqual(path3.IsEmpty, clone.IsEmpty);
}
public void TestPushIndexAndMember()
{
var obj = new Class {
ListMember = { new Class(), new Class(), new Class() }
};
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode);
path.PushMember(nameof(Class.ListMember));
path.PushTarget();
path.PushIndex(new NodeIndex(1));
path.PushMember(nameof(Class.IntMember));
var targetNode = nodeContainer.GetNode(obj.ListMember[1]);
var intNode = targetNode[nameof(Class.IntMember)];
var nodes = new IGraphNode[] { rootNode, rootNode[nameof(Class.ListMember)], rootNode[nameof(Class.ListMember)].Target, targetNode, intNode };
Assert.NotNull(targetNode);
Assert.NotNull(intNode);
Assert.False(path.IsEmpty);
AssertAreEqual(rootNode, path.RootNode);
AssertAreEqual(intNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
AssertAreEqual(nodes[i++], node);
}
AssertAreEqual(nodes.Length, i);
}
public void TestCloneNewRoot()
{
var obj1 = new Class {
ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() }
};
var obj2 = new Class {
ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() }
};
var nodeContainer = new NodeContainer();
var newRoot = nodeContainer.GetOrCreateNode(obj2);
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj1));
var clone = path1.Clone(newRoot);
Assert.AreNotEqual(newRoot, path1.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path1.IsValid, clone.IsValid);
Assert.AreEqual(path1.IsEmpty, clone.IsEmpty);
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone(newRoot);
Assert.AreNotEqual(newRoot, path2.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path2.IsValid, clone.IsValid);
Assert.AreEqual(path2.IsEmpty, clone.IsEmpty);
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone(newRoot);
Assert.AreNotEqual(newRoot, path3.RootNode);
Assert.AreEqual(newRoot, clone.RootNode);
Assert.AreEqual(path3.IsValid, clone.IsValid);
Assert.AreEqual(path3.IsEmpty, clone.IsEmpty);
}
public void TestChangeStructListItemMember()
{
var nodeContainer = new NodeContainer();
var obj = new[] { "aa", "bb", "cc" };
var instance = new ComplexClass {
Member7 = new List <Struct> {
new Struct(), new Struct {
Member1 = obj[0]
}
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7)).PushIndex(new Index(1)).PushMember(nameof(SimpleClass.Member1));
Assert.AreEqual(obj[0], node.Content.Retrieve());
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty));
Assert.AreEqual(obj[1], node.Content.Retrieve());
// TODO: would be nice to be able to keep the same boxed node!
//Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty));
Assert.AreEqual(obj[2], node.Content.Retrieve());
//Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)));
}
public void TestChangePrimitiveList()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new List <string> {
"aa"
}, new List <string> {
"bb"
}, new List <string> {
"cc"
} };
var instance = new ComplexClass {
Member5 = obj[0]
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member5));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member5));
Assert.AreEqual("aa", node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1]));
Assert.AreEqual("bb", node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2]));
Assert.AreEqual("cc", node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), "cc", "dd", path, () => node.Content.Update("dd", new Index(0)));
Assert.AreEqual("dd", node.Content.Retrieve(new Index(0)));
}
public void TestChangeReferenceList()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new List <SimpleClass> {
new SimpleClass()
}, new List <SimpleClass> {
new SimpleClass()
}, new List <SimpleClass> {
new SimpleClass()
} };
var instance = new ComplexClass {
Member6 = obj[0]
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member6));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member6));
Assert.AreEqual(obj[0][0], node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1]));
Assert.AreEqual(obj[1][0], node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2]));
Assert.AreEqual(obj[2][0], node.Content.Retrieve(new Index(0)));
var newItem = new SimpleClass();
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[2][0], newItem, path, () => node.Content.Update(newItem, new Index(0)));
Assert.AreEqual(newItem, node.Content.Retrieve(new Index(0)));
}
public void TestObjectWithPrimitiveList()
{
var nodeContainer = new NodeContainer();
var instance = new PrimitiveListClass {
Member1 = 3, Member2 = new List <string> {
"aaa", "bbb", "ccc"
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IGraphNode[]
{
rootNode,
rootNode[nameof(PrimitiveListClass.Member1)],
rootNode[nameof(PrimitiveListClass.Member2)],
rootNode[nameof(PrimitiveListClass.Member2)].Target,
};
var expectedPaths = new GraphNodePath[4];
expectedPaths[0] = new GraphNodePath(rootNode);
expectedPaths[1] = expectedPaths[0].Clone();
expectedPaths[1].PushMember(nameof(PrimitiveListClass.Member1));
expectedPaths[2] = expectedPaths[0].Clone();
expectedPaths[2].PushMember(nameof(PrimitiveListClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void TestChangeStruct()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new Struct {
Member1 = "aa"
}, new Struct {
Member1 = "bb"
}, new Struct {
Member1 = "cc"
} };
var instance = new ComplexClass {
Member4 = obj[0]
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member4));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member4));
Assert.AreEqual("aa", node.GetChild(nameof(Struct.Member1)).Content.Retrieve());
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1]));
Assert.AreEqual("bb", node.GetChild(nameof(Struct.Member1)).Content.Retrieve());
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2]));
Assert.AreEqual("cc", node.GetChild(nameof(Struct.Member1)).Content.Retrieve());
TestContentChange(listener, node.GetChild(nameof(Struct.Member1)), ContentChangeType.ValueChange, Index.Empty, "cc", "dd", path.PushMember(nameof(Struct.Member1)), () => node.GetChild(nameof(Struct.Member1)).Content.Update("dd"));
Assert.AreEqual("dd", node.GetChild(nameof(Struct.Member1)).Content.Retrieve());
}
public void TestSimpleObject()
{
var nodeContainer = new NodeContainer();
var instance = new SimpleClass {
Member1 = 3, Member2 = new SimpleClass()
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IGraphNode[]
{
rootNode,
rootNode[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass.Member2)],
rootNode[nameof(SimpleClass.Member2)].Target,
rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member1)],
rootNode[nameof(SimpleClass.Member2)].Target[nameof(SimpleClass.Member2)],
};
var expectedPaths = new GraphNodePath[6];
expectedPaths[0] = new GraphNodePath(rootNode);
expectedPaths[1] = new GraphNodePath(rootNode);
expectedPaths[1].PushMember(nameof(SimpleClass.Member1));
expectedPaths[2] = new GraphNodePath(rootNode);
expectedPaths[2].PushMember(nameof(SimpleClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
expectedPaths[4] = expectedPaths[3].Clone();
expectedPaths[4].PushMember(nameof(SimpleClass.Member1));
expectedPaths[5] = expectedPaths[3].Clone();
expectedPaths[5].PushMember(nameof(SimpleClass.Member2));
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public void TestClone()
{
var obj = new Class { ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj));
var clone = path1.Clone();
AssertAreEqual(path1, clone);
AssertAreEqual(path1.GetHashCode(), clone.GetHashCode());
AssertAreEqual(path1.RootNode, clone.RootNode);
AssertAreEqual(path1.IsValid, clone.IsValid);
AssertAreEqual(path1.IsEmpty, clone.IsEmpty);
AssertAreEqual(path1.GetNode(), clone.GetNode());
var path2 = path1.PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
clone = path2.Clone();
AssertAreEqual(path2, clone);
AssertAreEqual(path2.RootNode, clone.RootNode);
AssertAreEqual(path2.IsValid, clone.IsValid);
AssertAreEqual(path2.IsEmpty, clone.IsEmpty);
AssertAreEqual(path2.GetNode(), clone.GetNode());
var path3 = path1.PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
clone = path3.Clone();
AssertAreEqual(path3, clone);
AssertAreEqual(path3.RootNode, clone.RootNode);
AssertAreEqual(path3.IsValid, clone.IsValid);
AssertAreEqual(path3.IsEmpty, clone.IsEmpty);
AssertAreEqual(path3.GetNode(), clone.GetNode());
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableModelNode"/> class.
/// </summary>
/// <param name="ownerViewModel">The <see cref="ObservableViewModel"/> that owns the new <see cref="ObservableModelNode"/>.</param>
/// <param name="baseName">The base name of this node. Can be null if <see cref="index"/> is not. If so a name will be automatically generated from the index.</param>
/// <param name="isPrimitive">Indicate whether this node should be considered as a primitive node.</param>
/// <param name="sourceNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="graphNodePath">The <see cref="GraphNodePath"/> corresponding to the given <see cref="sourceNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <see cref="Index.Empty"/> must be passed otherwise</param>
protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IGraphNode sourceNode, GraphNodePath graphNodePath, Index index)
: base(ownerViewModel, baseName, index)
{
if (sourceNode == null)
{
throw new ArgumentNullException(nameof(sourceNode));
}
if (baseName == null && index == null)
{
throw new ArgumentException("baseName and index can't be both null.");
}
this.isPrimitive = isPrimitive;
SourceNode = sourceNode;
// By default we will always combine items of list of primitive items.
CombineMode = !index.IsEmpty && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll;
SourceNodePath = graphNodePath;
// Override display name if available
var memberDescriptor = GetMemberDescriptor() as MemberDescriptorBase;
if (memberDescriptor != null)
{
if (index.IsEmpty)
{
var displayAttribute = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute <DisplayAttribute>(memberDescriptor.MemberInfo);
if (!string.IsNullOrEmpty(displayAttribute?.Name))
{
DisplayName = displayAttribute.Name;
}
IsReadOnly = !memberDescriptor.HasSet;
}
}
}
public void TestPushStructMember()
{
var obj = new Class {
StructMember = { StringMember = "aa" }
};
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode);
path.PushMember(nameof(Class.StructMember));
path.PushTarget();
path.PushMember(nameof(Struct.StringMember));
var structNode = rootNode[nameof(Class.StructMember)];
var targetNode = rootNode[nameof(Class.StructMember)].Target;
var memberNode = rootNode[nameof(Class.StructMember)].Target[nameof(Struct.StringMember)];
var nodes = new IGraphNode[] { rootNode, structNode, targetNode, memberNode };
Assert.NotNull(targetNode);
Assert.NotNull(memberNode);
Assert.False(path.IsEmpty);
AssertAreEqual(rootNode, path.RootNode);
AssertAreEqual(memberNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
AssertAreEqual(nodes[i++], node);
}
AssertAreEqual(nodes.Length, i);
}
public void TestChangeStructListItem()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new Struct {
Member1 = "aa"
}, new Struct {
Member1 = "bb"
}, new Struct {
Member1 = "cc"
} };
var instance = new ComplexClass {
Member7 = new List <Struct> {
obj[0]
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member7));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7));
Assert.AreEqual(obj[0], node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[0], obj[1], path, () => node.Content.Update(obj[1], new Index(0)));
Assert.AreEqual(obj[1], node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[1], obj[2], path, () => node.Content.Update(obj[2], new Index(0)));
Assert.AreEqual(obj[2], node.Content.Retrieve(new Index(0)));
}
public void TestPushTargetAndMember()
{
var obj = new Class {
ClassMember = new Class()
};
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
var targetNode = nodeContainer.GetNode(obj.ClassMember);
var intNode = targetNode.GetChild(nameof(Class.IntMember));
var nodes = new[] { rootNode, rootNode.GetChild(nameof(Class.ClassMember)), targetNode, intNode };
Assert.NotNull(targetNode);
Assert.NotNull(intNode);
Assert.True(path.IsValid);
Assert.False(path.IsEmpty);
Assert.AreEqual(rootNode, path.RootNode);
Assert.AreEqual(intNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
Assert.AreEqual(nodes[i++], node);
}
Assert.AreEqual(nodes.Length, i);
}
/// <inheritdoc/>
public override GraphNodePath GetNodePath()
{
var path = new GraphNodePath(Editor.NodeContainer.GetNode(Asset.Asset));
path.PushMember(nameof(UIAsset.Hierarchy));
path.PushTarget();
return(path);
}
/// <inheritdoc />
protected override GraphNodePath GetNodePath()
{
var path = new GraphNodePath(Editor.Session.AssetNodeContainer.GetNode(Editor.Asset.Asset));
path.PushMember(nameof(GraphicsCompositorAsset.Cameras));
path.PushTarget();
path.PushIndex(new Index(Editor.Asset.Asset.Cameras.IndexOf(CameraSlot)));
return(path);
}
GraphNodePath IAssetPropertyProviderViewModel.GetAbsolutePathToRootNode()
{
var path = new GraphNodePath(Editor.Session.AssetNodeContainer.GetNode(Editor.Asset.Asset));
path.PushMember(nameof(SpriteSheetAsset.Sprites));
path.PushIndex(new NodeIndex(Index));
path.PushTarget();
return(path);
}
/// <inheritdoc />
protected override GraphNodePath GetNodePath()
{
var path = new GraphNodePath(Editor.Session.AssetNodeContainer.GetNode(Editor.Asset.Asset));
path.PushMember(nameof(GraphicsCompositorAsset.SharedRenderers));
path.PushTarget();
path.PushIndex(new NodeIndex(Editor.Asset.Asset.SharedRenderers.IndexOf(sharedRenderer)));
return(path);
}
public void TestConstructor()
{
var obj = new Class();
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode);
Assert.True(path.IsValid);
Assert.True(path.IsEmpty);
Assert.AreEqual(rootNode, path.RootNode);
}
public void TestConstructor()
{
var obj = new Class();
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode);
Assert.True(path.IsEmpty);
AssertAreEqual(rootNode, path.RootNode);
}
public ModelNodeCommandWrapper(IViewModelServiceProvider serviceProvider, INodeCommand nodeCommand, GraphNodePath nodePath)
: base(serviceProvider)
{
if (nodeCommand == null)
{
throw new ArgumentNullException(nameof(nodeCommand));
}
NodePath = nodePath;
NodeCommand = nodeCommand;
Service = serviceProvider.Get <ObservableViewModelService>();
}
public void TestChangePrimitiveMember()
{
var nodeContainer = new NodeContainer();
var instance = new ComplexClass { Member1 = 3 };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member1));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member1));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 3, 4, path, () => node.Content.Update(4));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 4, 5, path, () => node.Content.Update(5));
}
public ModelNodeCommandWrapper(IViewModelServiceProvider serviceProvider, INodeCommand nodeCommand, GraphNodePath nodePath, Index index)
: base(serviceProvider)
{
if (nodeCommand == null)
{
throw new ArgumentNullException(nameof(nodeCommand));
}
NodePath = nodePath;
Index = index;
NodeCommand = nodeCommand;
}
public void TestChangeReferenceMember()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new SimpleClass(), new SimpleClass(), new SimpleClass() };
var instance = new ComplexClass { Member2 = obj[0] };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member2));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member2));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1]));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2]));
}
public static YamlAssetPath ConvertPath(GraphNodePath path, int inNonIdentifiableType)
{
var currentNode = (AssetNode)path.RootNode;
var result = new YamlAssetPath();
var i = 0;
foreach (var item in path.Path)
{
switch (item.Type)
{
case GraphNodePath.ElementType.Member:
var member = (string)item.Value;
result.PushMember(member);
currentNode = (AssetNode)((IGraphNode)currentNode).TryGetChild(member);
break;
case GraphNodePath.ElementType.Target:
if (i < path.Path.Count - 1)
{
currentNode = (AssetNode)((IGraphNode)currentNode).Target;
}
break;
case GraphNodePath.ElementType.Index:
var index = (Index)item.Value;
if (inNonIdentifiableType > 0 || currentNode.IsNonIdentifiableCollectionContent)
{
result.PushIndex(index.Value);
}
else
{
var id = currentNode.IndexToId(index);
// Create a new id if we don't have any so far
if (id == ItemId.Empty)
{
id = ItemId.New();
}
result.PushItemId(id);
}
if (i < path.Path.Count - 1)
{
currentNode = (AssetNode)((IGraphNode)currentNode).IndexedTarget(index);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
++i;
}
return(result);
}
/// <inheritdoc/>
public override GraphNodePath GetNodePath()
{
var path = new GraphNodePath(Editor.NodeContainer.GetNode(Asset.Asset));
path.PushMember(nameof(EntityHierarchy.Hierarchy));
path.PushTarget();
path.PushMember(nameof(EntityHierarchy.Hierarchy.Parts));
path.PushTarget();
path.PushIndex(new NodeIndex(Id.ObjectId));
path.PushMember(nameof(EntityDesign.Entity));
path.PushTarget();
return(path);
}
/// <inheritdoc/>
GraphNodePath IAssetPropertyProviderViewModel.GetAbsolutePathToRootNode()
{
var asset = Method.Editor.Asset.Asset;
var path = new GraphNodePath(Method.Editor.Session.AssetNodeContainer.GetNode(asset));
path.PushMember(nameof(VisualScriptAsset.Methods));
path.PushTarget();
path.PushIndex(new NodeIndex(asset.Methods.IndexOf(Method.Method.Method)));
path.PushMember(nameof(Scripts.Method.Links));
path.PushTarget();
path.PushIndex(new NodeIndex(link.Id));
path.PushTarget();
return(path);
}
public void TestChangePrimitiveMember()
{
var nodeContainer = new NodeContainer();
var instance = new ComplexClass {
Member1 = 3
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member1));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member1));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 3, 4, path, () => node.Content.Update(4));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, 4, 5, path, () => node.Content.Update(5));
}
public void TestObjectWithStructList()
{
var nodeContainer = new NodeContainer();
// We also test a null item in the list
var instance = new StructListClass {
Member1 = 3, Member2 = new List <Struct> {
new Struct(), new Struct()
}
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var visitor = new TestVisitor();
visitor.Visit(rootNode);
var expectedNodes = new IGraphNode[]
{
rootNode,
rootNode[nameof(StructListClass.Member1)],
rootNode[nameof(StructListClass.Member2)],
rootNode[nameof(StructListClass.Member2)].Target,
rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(0)),
rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(0))[nameof(StructListClass.Member1)],
rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(0))[nameof(StructListClass.Member2)],
rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(1)),
rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(1))[nameof(StructListClass.Member1)],
rootNode[nameof(StructListClass.Member2)].Target.IndexedTarget(new NodeIndex(1))[nameof(StructListClass.Member2)],
};
var expectedPaths = new GraphNodePath[10];
expectedPaths[0] = new GraphNodePath(rootNode);
expectedPaths[1] = expectedPaths[0].Clone();
expectedPaths[1].PushMember(nameof(StructListClass.Member1));
expectedPaths[2] = expectedPaths[0].Clone();
expectedPaths[2].PushMember(nameof(StructListClass.Member2));
expectedPaths[3] = expectedPaths[2].Clone();
expectedPaths[3].PushTarget();
expectedPaths[4] = expectedPaths[3].Clone();
expectedPaths[4].PushIndex(new NodeIndex(0));
expectedPaths[5] = expectedPaths[4].Clone();
expectedPaths[5].PushMember(nameof(StructListClass.Member1));
expectedPaths[6] = expectedPaths[4].Clone();
expectedPaths[6].PushMember(nameof(StructListClass.Member2));
expectedPaths[7] = expectedPaths[3].Clone();
expectedPaths[7].PushIndex(new NodeIndex(1));
expectedPaths[8] = expectedPaths[7].Clone();
expectedPaths[8].PushMember(nameof(StructListClass.Member1));
expectedPaths[9] = expectedPaths[7].Clone();
expectedPaths[9].PushMember(nameof(StructListClass.Member2));
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
public INodePresenter CreateNodeHierarchy(IObjectNode rootNode, GraphNodePath rootNodePath, IPropertyProviderViewModel propertyProvider)
{
if (rootNode == null)
{
throw new ArgumentNullException(nameof(rootNode));
}
buildingNodes.Value = true;
var rootPresenter = CreateRootPresenter(propertyProvider, rootNode);
GenerateChildren(rootPresenter, rootNode, propertyProvider);
RunUpdaters(rootPresenter);
buildingNodes.Value = false;
FinalizeTree(rootPresenter);
return(rootPresenter);
}
public void TestChangeReferenceMemberToNull()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new SimpleClass(), null, new SimpleClass() };
var instance = new ComplexClass {
Member2 = obj[0]
};
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member2));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member2));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1]));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2]));
}
protected override void VisitNode(IContentNode node, GraphNodePath currentPath)
{
var assetNode = (IAssetNode)node;
bool localInNonIdentifiableType = false;
if ((node.Descriptor as ObjectDescriptor)?.Attributes.OfType <NonIdentifiableCollectionItemsAttribute>().Any() ?? false)
{
localInNonIdentifiableType = true;
inNonIdentifiableType++;
}
var path = ConvertPath(currentPath, inNonIdentifiableType);
var memberNode = assetNode as AssetMemberNode;
if (memberNode != null)
{
if (memberNode.IsContentOverridden())
{
Result.Add(path, memberNode.GetContentOverride());
}
foreach (var index in memberNode.GetOverriddenItemIndices())
{
var id = memberNode.IndexToId(index);
var itemPath = path.Clone();
itemPath.PushItemId(id);
Result.Add(itemPath, memberNode.GetItemOverride(index));
}
foreach (var index in memberNode.GetOverriddenKeyIndices())
{
var id = memberNode.IndexToId(index);
var itemPath = path.Clone();
itemPath.PushIndex(id);
Result.Add(itemPath, memberNode.GetKeyOverride(index));
}
}
base.VisitNode(node, currentPath);
if (localInNonIdentifiableType)
{
inNonIdentifiableType--;
}
}
public void TestEquals()
{
var obj = new Class { StructMember = { StringMember = "aa" }, ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.IntMember));
var path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.IntMember));
AssertAreEqual(path1, path2);
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember));
AssertAreNotEqual(path1, path2);
AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode());
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember));
AssertAreEqual(path1, path2);
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget();
AssertAreNotEqual(path1, path2);
AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode());
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget();
AssertAreEqual(path1, path2);
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
AssertAreNotEqual(path1, path2);
AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode());
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
AssertAreEqual(path1, path2);
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
path1 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ListMember)).PushIndex(new Index(0));
AssertAreNotEqual(path1, path2);
AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode());
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ListMember)).PushIndex(new Index(0));
AssertAreEqual(path1, path2);
AssertAreEqual(path1.GetHashCode(), path2.GetHashCode());
path2 = new GraphNodePath(nodeContainer.GetOrCreateNode(obj)).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1));
AssertAreNotEqual(path1, path2);
AssertAreNotEqual(path1.GetHashCode(), path2.GetHashCode());
}
public void TestSimpleObjectInitialPath()
{
var nodeContainer = new NodeContainer();
var instance = new SimpleClass { Member1 = 3, Member2 = new SimpleClass() };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var container = new SimpleClass { Member2 = instance };
var containerNode = nodeContainer.GetOrCreateNode(container);
var initialPath = new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget();
var visitor = new TestVisitor();
visitor.Visit(rootNode, initialPath);
var expectedNodes = new[]
{
rootNode,
rootNode.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target,
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)),
rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)),
};
var expectedPaths = new[]
{
new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget(),
new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)),
new GraphNodePath(containerNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)),
};
VerifyNodesAndPath(expectedNodes, expectedPaths, visitor);
}
protected override void VisitNode(IGraphNode node, GraphNodePath currentPath)
{
Result.Add(Tuple.Create(node, currentPath));
base.VisitNode(node, currentPath);
}
public override void Visit(IGraphNode node, GraphNodePath initialPath = null)
{
Result.Clear();
base.Visit(node, initialPath);
}
private static void TestContentChange(GraphNodeChangeListener listener, IGraphNode contentOwner, ContentChangeType type, Index index, object oldValue, object newValue, GraphNodePath path, Action change)
{
var i = 0;
var prepareChange = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(0, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, false); ++i; });
var changing = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(1, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, false); ++i; });
var changed = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(2, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, true); ++i; });
var finalizeChange = new EventHandler<GraphContentChangeEventArgs>((sender, e) => { Assert.AreEqual(3, i); VerifyListenerEvent(e, contentOwner, type, index, oldValue, newValue, path, true); ++i; });
listener.PrepareChange += prepareChange;
listener.Changing += changing;
listener.Changed += changed;
listener.FinalizeChange += finalizeChange;
change();
Assert.AreEqual(4, i);
listener.PrepareChange -= prepareChange;
listener.Changing -= changing;
listener.Changed -= changed;
listener.FinalizeChange -= finalizeChange;
}
public void TestPushMember()
{
var obj = new Class();
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode).PushMember(nameof(Class.IntMember));
var intNode = rootNode.GetChild(nameof(Class.IntMember));
var nodes = new[] { rootNode, intNode };
Assert.NotNull(intNode);
Assert.True(path.IsValid);
Assert.False(path.IsEmpty);
Assert.AreEqual(rootNode, path.RootNode);
Assert.AreEqual(intNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
Assert.AreEqual(nodes[i++], node);
}
Assert.AreEqual(nodes.Length, i);
}
public void TestChangePrimitiveList()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new List<string> { "aa" }, new List<string> { "bb" }, new List<string> { "cc" } };
var instance = new ComplexClass { Member5 = obj[0] };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member5));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member5));
Assert.AreEqual("aa", node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1]));
Assert.AreEqual("bb", node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2]));
Assert.AreEqual("cc", node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), "cc", "dd", path, () => node.Content.Update("dd", new Index(0)));
Assert.AreEqual("dd", node.Content.Retrieve(new Index(0)));
}
public void TestChangeStructListItem()
{
var nodeContainer = new NodeContainer();
var obj = new[] { new Struct { Member1 = "aa" }, new Struct { Member1 = "bb" }, new Struct { Member1 = "cc" } };
var instance = new ComplexClass { Member7 = new List<Struct> { obj[0] } };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member7));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7));
Assert.AreEqual(obj[0], node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[0], obj[1], path, () => node.Content.Update(obj[1], new Index(0)));
Assert.AreEqual(obj[1], node.Content.Retrieve(new Index(0)));
TestContentChange(listener, node, ContentChangeType.ValueChange, new Index(0), obj[1], obj[2], path, () => node.Content.Update(obj[2], new Index(0)));
Assert.AreEqual(obj[2], node.Content.Retrieve(new Index(0)));
}
public void TestChangeStructMember()
{
var nodeContainer = new NodeContainer();
var obj = new[] { "aa", "bb", "cc" };
var instance = new ComplexClass { Member4 = new Struct { Member1 = obj[0] } };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member4)).GetChild(nameof(Struct.Member1));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member4)).PushMember(nameof(Struct.Member1));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty));
Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member4)).GetChild(nameof(Struct.Member1)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty));
Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member4)).GetChild(nameof(Struct.Member1)));
}
public void TestGetParent()
{
var obj = new Class { StructMember = { StringMember = "aa" }, ClassMember = new Class(), ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode).PushMember(nameof(Class.IntMember));
var parentPath = new GraphNodePath(rootNode);
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember)).PushMember(nameof(Struct.StringMember));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember));
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget();
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember));
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget().PushMember(nameof(Class.IntMember));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ClassMember)).PushTarget();
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember));
AssertAreEqual(parentPath, path.GetParent());
path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1)).PushMember(nameof(Class.IntMember));
parentPath = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1));
AssertAreEqual(parentPath, path.GetParent());
}
private static void VerifyListenerEvent(GraphContentChangeEventArgs e, IGraphNode contentOwner, ContentChangeType type, Index index, object oldValue, object newValue, GraphNodePath path, bool changeApplied)
{
Assert.NotNull(e);
Assert.NotNull(contentOwner);
Assert.NotNull(path);
Assert.AreEqual(type, e.ChangeType);
Assert.AreEqual(contentOwner.Content, e.Content);
Assert.AreEqual(index, e.Index);
Assert.AreEqual(newValue, e.NewValue);
Assert.AreEqual(oldValue, e.OldValue);
Assert.AreEqual(path, e.Path);
if (type == ContentChangeType.ValueChange)
{
Assert.AreEqual(changeApplied ? newValue : oldValue, contentOwner.Content.Retrieve(index));
}
}
public void TestPushIndex()
{
var obj = new Class { ListMember = { new Class(), new Class(), new Class() } };
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode).PushMember(nameof(Class.ListMember)).PushIndex(new Index(1));
var targetNode = nodeContainer.GetNode(obj.ListMember[1]);
var nodes = new[] { rootNode, rootNode.GetChild(nameof(Class.ListMember)), targetNode };
Assert.NotNull(targetNode);
Assert.True(path.IsValid);
Assert.False(path.IsEmpty);
Assert.AreEqual(rootNode, path.RootNode);
Assert.AreEqual(targetNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
Assert.AreEqual(nodes[i++], node);
}
Assert.AreEqual(nodes.Length, i);
}
public void TestChangeReferenceListItemMember()
{
var nodeContainer = new NodeContainer();
var obj = new[] { 3, 4, 5 };
var instance = new ComplexClass { Member6 = new List<SimpleClass> { new SimpleClass(), new SimpleClass { Member1 = obj[0] } } };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member6)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member6)).PushIndex(new Index(1)).PushMember(nameof(SimpleClass.Member1));
Assert.AreEqual(obj[0], node.Content.Retrieve());
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty));
Assert.AreEqual(obj[1], node.Content.Retrieve());
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty));
Assert.AreEqual(obj[2], node.Content.Retrieve());
}
/// <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)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphContentChangeEventArgs"/> class.
/// </summary>
/// <param name="content">The content that has changed.</param>
/// <param name="index">The index in the content where the change occurred.</param>
/// <param name="changeType">The type of change that occurred.</param>
/// <param name="oldValue">The old value of the content.</param>
/// <param name="newValue">The new value of the content.</param>
/// <param name="path">The path to the node of content that has been modified.</param>
public GraphContentChangeEventArgs(IContent content, Index index, ContentChangeType changeType, object oldValue, object newValue, GraphNodePath path)
: base(content, index, changeType, oldValue, newValue)
{
Path = path;
}
public void TestPushStructMember()
{
var obj = new Class { StructMember = { StringMember = "aa" } };
var nodeContainer = new NodeContainer();
var rootNode = nodeContainer.GetOrCreateNode(obj);
var path = new GraphNodePath(rootNode).PushMember(nameof(Class.StructMember)).PushMember(nameof(Struct.StringMember));
var structNode = rootNode.TryGetChild(nameof(Class.StructMember));
var memberNode = rootNode.TryGetChild(nameof(Class.StructMember)).TryGetChild(nameof(Struct.StringMember));
var nodes = new[] { rootNode, structNode, memberNode };
Assert.NotNull(memberNode);
Assert.True(path.IsValid);
Assert.False(path.IsEmpty);
AssertAreEqual(rootNode, path.RootNode);
AssertAreEqual(memberNode, path.GetNode());
var i = 0;
foreach (var node in path)
{
AssertAreEqual(nodes[i++], node);
}
AssertAreEqual(nodes.Length, i);
}
public void TestChangeStructListItemMember()
{
var nodeContainer = new NodeContainer();
var obj = new[] { "aa", "bb", "cc" };
var instance = new ComplexClass { Member7 = new List<Struct> { new Struct(), new Struct { Member1 = obj[0] } } };
var rootNode = nodeContainer.GetOrCreateNode(instance);
var listener = new GraphNodeChangeListener(rootNode);
var node = rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1));
var path = new GraphNodePath(rootNode).PushMember(nameof(ComplexClass.Member7)).PushIndex(new Index(1)).PushMember(nameof(SimpleClass.Member1));
Assert.AreEqual(obj[0], node.Content.Retrieve());
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[0], obj[1], path, () => node.Content.Update(obj[1], Index.Empty));
Assert.AreEqual(obj[1], node.Content.Retrieve());
// TODO: would be nice to be able to keep the same boxed node!
//Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)));
TestContentChange(listener, node, ContentChangeType.ValueChange, Index.Empty, obj[1], obj[2], path, () => node.Content.Update(obj[2], Index.Empty));
Assert.AreEqual(obj[2], node.Content.Retrieve());
//Assert.AreEqual(node, rootNode.GetChild(nameof(ComplexClass.Member7)).GetTarget(new Index(1)).GetChild(nameof(SimpleClass.Member1)));
}
