private void Paste(AssetPropertyGraph propertyGraph, string copiedText, Type deserializedType, Type expectedType, Func <IObjectNode, IGraphNode> targetNodeResolver, NodeIndex index, bool replace)
{
var asset = propertyGraph.RootNode.Retrieve();
Assert.True(service.CanPaste(copiedText, asset.GetType(), expectedType));
var result = service.DeserializeCopiedData(copiedText, asset, expectedType);
Assert.NotNull(result);
Assert.NotNull(result.Items);
Assert.Equal(1, result.Items.Count);
var item = result.Items[0];
Assert.NotNull(item);
Assert.NotNull(item.Data);
Assert.Equal(deserializedType, item.Data.GetType());
Assert.NotNull(item.Processor);
var targetNode = targetNodeResolver(propertyGraph.RootNode);
var nodeAccessor = new NodeAccessor(targetNode, index);
var propertyContainer = new PropertyContainer {
{ AssetPropertyPasteProcessor.IsReplaceKey, replace }
};
item.Processor.Paste(item, propertyGraph, ref nodeAccessor, ref propertyContainer);
}
public void CopyForVersion(VersionHandle newversion)
{
var me = FatNode.Slots.Find(this);
var old = (Node)MemberwiseClone();
old.TemporaryAccessor = null;
if (!(PermanentAccessor is null))
{
// We assume that permanent accessor for newly created version is not set yet.
PermanentAccessor.Node = old;
PermanentAccessor = null;
}
FatNode.Slots.AddBefore(me, old);
var undo = (Node)MemberwiseClone();
undo.Version = newversion.GetSuccessor();
undo.TemporaryAccessor = null;
FatNode.Slots.AddAfter(me, undo);
Version = newversion;
// Schedule to check invariant.
FatNode.CheckScheduled.Add(FatNode);
}
public bool IsObjectReference(NodeAccessor nodeAccessor, object value)
{
if (nodeAccessor.IsMember)
{
return(IsMemberTargetObjectReference((IMemberNode)nodeAccessor.Node, value));
}
if (nodeAccessor.IsItem)
{
return(IsTargetItemObjectReference((IObjectNode)nodeAccessor.Node, nodeAccessor.Index, value));
}
return(false);
}
public SharedRendererOutputSlotViewModel(GraphicsCompositorBlockViewModel block, string name, SharedRendererReferenceKey slotKey)
: base(block, name)
{
this.slotKey = slotKey;
Accessor = slotKey.Path.GetAccessor();
if (Accessor.Index != NodeIndex.Empty)
{
((IObjectNode)Accessor.Node).ItemChanged += ItemChanged;
}
else
{
((IMemberNode)Accessor.Node).ValueChanged += ValueChanged;
}
}
private static void Paste([NotNull] ICopyPasteService service, string text, [NotNull] EntityHierarchyPropertyGraph assetGraph, EntityDesign target, string folderName)
{
var data = service.DeserializeCopiedData(text, assetGraph.Asset, typeof(Entity));
Assert.NotNull(data);
Assert.NotNull(data.Items);
Assert.Equal(1, data.Items.Count);
var item = data.Items[0];
Assert.NotNull(item);
Assert.NotNull(item.Data);
Assert.NotNull(item.Processor);
var targetNode = target != null?assetGraph.Container.NodeContainer.GetNode(target.Entity) : assetGraph.RootNode;
var nodeAccessor = new NodeAccessor(targetNode, NodeIndex.Empty);
var propertyContainer = new PropertyContainer {
{ EntityHierarchyPasteProcessor.TargetFolderKey, folderName }
};
item.Processor.Paste(item, assetGraph, ref nodeAccessor, ref propertyContainer);
}
/// <summary>
/// Registers an <see cref="IGraphNode"/> object to this virtual node so when the node vakye is modified, it will raise the
/// <see cref="NodePresenterBase.ValueChanging"/> and <see cref="NodePresenterBase.ValueChanged"/> events.
/// </summary>
/// <param name="associatedNodeAccessor">An accessor to the node to register.</param>
/// <remarks>Events subscriptions are cleaned when this virtual node is disposed.</remarks>
public virtual void RegisterAssociatedNode(NodeAccessor associatedNodeAccessor)
{
if (AssociatedNode.Node != null)
{
throw new InvalidOperationException("A content has already been registered to this virtual node");
}
AssociatedNode = associatedNodeAccessor;
var memberNode = AssociatedNode.Node as IMemberNode;
if (memberNode != null)
{
memberNode.ValueChanging += AssociatedNodeChanging;
memberNode.ValueChanged += AssociatedNodeChanged;
}
var objectNode = AssociatedNode.Node as IObjectNode;
if (objectNode != null)
{
objectNode.ItemChanging += AssociatedNodeChanging;
objectNode.ItemChanged += AssociatedNodeChanged;
}
}
/// <inheritdoc />
public virtual Task Paste(IPasteItem pasteResultItem, AssetPropertyGraph propertyGraph, ref NodeAccessor nodeAccessor, ref PropertyContainer propertyContainer)
{
// default implementation does nothing
return(Task.CompletedTask);
}
/// <inheritdoc />
public override Task Paste(IPasteItem pasteResultItem, AssetPropertyGraph propertyGraph, ref NodeAccessor nodeAccessor, ref PropertyContainer propertyContainer)
{
propertyContainer.TryGetValue(IsReplaceKey, out bool replace);
Paste(pasteResultItem, nodeAccessor.Node, nodeAccessor.Index, replace);
return(Task.CompletedTask);
}
public override Task Paste(IPasteItem pasteResultItem, AssetPropertyGraph assetPropertyGraph, ref NodeAccessor nodeAccessor, ref PropertyContainer propertyContainer)
{
if (pasteResultItem == null)
{
throw new ArgumentNullException(nameof(pasteResultItem));
}
var propertyGraph = (EntityHierarchyPropertyGraph)assetPropertyGraph;
var parentEntity = nodeAccessor.RetrieveValue() as Entity;
string targetFolder;
propertyContainer.TryGetValue(TargetFolderKey, out targetFolder);
var hierarchy = pasteResultItem.Data as AssetCompositeHierarchyData <EntityDesign, Entity>;
if (hierarchy != null)
{
foreach (var rootEntity in hierarchy.RootParts)
{
var insertIndex = parentEntity?.Transform.Children.Count ?? propertyGraph.Asset.Hierarchy.RootParts.Count;
var entityDesign = hierarchy.Parts[rootEntity.Id];
var folder = targetFolder;
if (!string.IsNullOrEmpty(entityDesign.Folder))
{
if (!string.IsNullOrEmpty(targetFolder))
{
folder = folder + "/" + entityDesign.Folder;
}
else
{
folder = entityDesign.Folder;
}
}
entityDesign.Folder = folder ?? string.Empty;
propertyGraph.AddPartToAsset(hierarchy.Parts, entityDesign, parentEntity, insertIndex);
}
}
return(Task.CompletedTask);
}
public override void RegisterAssociatedNode(NodeAccessor associatedNodeAccessor)
{
base.RegisterAssociatedNode(associatedNodeAccessor);
((IAssetNode)AssociatedNode.Node).OverrideChanging += OnOverrideChanging;
((IAssetNode)AssociatedNode.Node).OverrideChanged += OnOverrideChanged;
}
public override Task Paste(IPasteItem pasteResultItem, AssetPropertyGraph assetPropertyGraph, ref NodeAccessor nodeAccessor, ref PropertyContainer container)
{
if (pasteResultItem == null)
{
throw new ArgumentNullException(nameof(pasteResultItem));
}
var propertyGraph = (UIAssetPropertyGraph)assetPropertyGraph;
var parentElement = nodeAccessor.RetrieveValue() as UIElement;
// 1. try to paste as hierarchy
var hierarchy = pasteResultItem.Data as AssetCompositeHierarchyData <UIElementDesign, UIElement>;
if (hierarchy != null)
{
// Note: check that adding or inserting is supported is done in CanPaste()
foreach (var rootUIElement in hierarchy.RootParts)
{
var asset = (UIAssetBase)propertyGraph.Asset;
var insertIndex = parentElement == null ? asset.Hierarchy.RootParts.Count : ((parentElement as Panel)?.Children.Count ?? 0);
propertyGraph.AddPartToAsset(hierarchy.Parts, hierarchy.Parts[rootUIElement.Id], parentElement, insertIndex);
}
}
return(Task.CompletedTask);
}
