public MemberGraphNodeBinding([NotNull] IMemberNode node, string propertyName, PropertyChangeDelegate propertyChanging, PropertyChangeDelegate propertyChanged, [NotNull] Func <TTargetType, TContentType> converter, IUndoRedoService actionService, bool notifyChangesOnly = true)
: base(propertyName, propertyChanging, propertyChanged, converter, actionService, notifyChangesOnly)
{
Node = node;
node.ValueChanged += ValueChanged;
node.ValueChanging += ValueChanging;
}
public MemberNodePresenter([NotNull] INodePresenterFactoryInternal factory, IPropertyProviderViewModel propertyProvider, [NotNull] INodePresenter parent, [NotNull] IMemberNode member)
: base(factory, propertyProvider, parent)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
Member = member ?? throw new ArgumentNullException(nameof(member));
Name = member.Name;
CombineKey = Name;
DisplayName = Name;
IsReadOnly = !Member.MemberDescriptor.HasSet;
memberAttributes.AddRange(TypeDescriptorFactory.Default.AttributeRegistry.GetAttributes(member.MemberDescriptor.MemberInfo));
member.ValueChanging += OnMemberChanging;
member.ValueChanged += OnMemberChanged;
if (member.Target != null)
{
member.Target.ItemChanging += OnItemChanging;
member.Target.ItemChanged += OnItemChanged;
}
var displayAttribute = memberAttributes.OfType <DisplayAttribute>().FirstOrDefault();
Order = displayAttribute?.Order ?? member.MemberDescriptor.Order;
AttachCommands();
}
public VisualScriptEditorViewModel(IVisualScriptViewModelService visualScriptViewModelService, VisualScriptViewModel visualScript) : base(visualScript)
{
// Create the service needed to manage observable view models
ViewModelService = new GraphViewModelService(Session.AssetNodeContainer);
// Update the service provider of this view model to contains the ObservableViewModelService we created.
ServiceProvider = new ViewModelServiceProvider(ServiceProvider, ViewModelService.Yield());
VisualScriptViewModelService = visualScriptViewModelService;
blockTemplateDescriptionCollection = new Lazy <BlockTemplateDescriptionCollectionViewModel>(() => new BlockTemplateDescriptionCollectionViewModel(this));
AddNewPropertyCommand = new AnonymousCommand(ServiceProvider, AddNewProperty);
RemoveSelectedPropertiesCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedProperties);
//ShowAddBlockDialogCommand = new AnonymousTaskCommand(ServiceProvider, ShowAddBlockDialog);
AddNewMethodCommand = new AnonymousCommand(ServiceProvider, AddNewMethod);
RemoveSelectedMethodCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedFunction);
var rootNode = Session.AssetNodeContainer.GetNode(visualScript.Asset);
baseTypeNodeBinding = new MemberGraphNodeBinding <string>(rootNode[nameof(VisualScriptAsset.BaseType)], nameof(BaseType), OnPropertyChanging, OnPropertyChanged, visualScript.UndoRedoService);
propertiesNode = rootNode[nameof(VisualScriptAsset.Properties)];
}
private void ProcessTypeModifiers(IMemberNode member, IEnumerable <IToken> modifiers)
{
AccessModifier? accessModifier = null;
InheritanceModifier?inheritanceModifier = null;
foreach (var modifier in modifiers)
{
switch (modifier.Type)
{
case MessageContractsLexer.KW_PUBLIC:
case MessageContractsLexer.KW_INTERNAL:
if (accessModifier == null)
{
accessModifier = modifier.Type switch
{
MessageContractsLexer.KW_PUBLIC => AccessModifier.Public,
MessageContractsLexer.KW_INTERNAL => AccessModifier.Internal,
_ => throw new InvalidOperationException($"Cannot map access modifier: {modifier.Text}")
};
}
else
{
_contracts.AddError(modifier, "An access modifier has already been provided");
}
break;
case MessageContractsLexer.KW_SEALED:
case MessageContractsLexer.KW_ABSTRACT:
if (inheritanceModifier == null)
{
if (!(member is IClassNode))
{
_contracts.AddError(modifier, "Cannot apply inheritance modifier to a non-class type");
}
inheritanceModifier = modifier.Type switch
{
MessageContractsLexer.KW_SEALED => InheritanceModifier.Sealed,
MessageContractsLexer.KW_ABSTRACT => InheritanceModifier.Abstract,
_ => throw new InvalidOperationException($"Cannot map inheritance modifier: {modifier.Text}")
};
}
else
{
_contracts.AddError(modifier, "An inheritance modifier has already been provided");
}
break;
}
}
member.AccessModifier = accessModifier ?? member.Options.GetAccessModifier();
if (inheritanceModifier != null && member is IClassNode classNode)
{
classNode.InheritanceModifier = inheritanceModifier.Value;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MemberNodeChangeEventArgs"/> class.
/// </summary>
/// <param name="member">The member that has changed.</param>
/// <param name="index">The index in the member where the change occurred.</param>
/// <param name="changeType">The type of change that occurred.</param>
/// <param name="oldValue">The old value of the member or the item of the member that has changed.</param>
/// <param name="newValue">The new value of the member or the item of the member that has changed.</param>
public MemberNodeChangeEventArgs([NotNull] IMemberNode member, Index index, ContentChangeType changeType, object oldValue, object newValue)
{
Member = member;
Index = index;
ChangeType = changeType;
OldValue = oldValue;
NewValue = newValue;
}
/// <summary>
/// Indicates whether the <see cref="IMemberNode.Target"/> of the given <see cref="IMemberNode"/> should be visited or not.
/// </summary>
/// <param name="memberNode">The member node to evaluate.</param>
/// <returns>True if the target of the member node should be visited, false otherwise.</returns>
/// <remarks>This method is invoked only when the given <see cref="IMemberNode"/> contains a target node.</remarks>
protected internal virtual bool ShouldVisitMemberTarget([NotNull] IMemberNode memberNode)
{
if (memberNode == null)
{
throw new ArgumentNullException(nameof(memberNode));
}
return(!visitedNodes.Contains(memberNode.Target));
}
private void UnregisterModelChanged()
{
if (modelContent != null)
{
modelContent.ValueChanging -= ModelChanging;
modelContent = null;
}
}
/// <inheritdoc />
protected override bool ShouldConstructPropertyMember(IMemberNode member)
{
// Hide child nodes of a compute curve.
if (member.Parent.Type.HasInterface(typeof(IComputeCurve <>)) && member.Name == nameof(ComputeAnimationCurve <int> .KeyFrames))
{
return(false);
}
return(base.ShouldConstructPropertyMember(member));
}
public override bool IsMemberTargetObjectReference(IMemberNode member, object value)
{
if (value is TAssetPart)
{
// Check if we're the part referenced by a part design - other cases are references
return(member.Parent.Type != typeof(TAssetPartDesign));
}
return(base.IsMemberTargetObjectReference(member, value));
}
protected override bool ShouldReconcileItem(IMemberNode member, IContentNode targetNode, object localValue, object baseValue, bool isReference)
{
// Always reconcile referenced parts
if (isReference && IsReferencedPart(member, targetNode))
{
return(true);
}
return(base.ShouldReconcileItem(member, targetNode, localValue, baseValue, isReference));
}
protected override bool ShouldCreateMemberPresenter(INodePresenter parent, IMemberNode member, IPropertyProviderViewModel propertyProvider)
{
// Don't construct members of object references
if (((IAssetNodePresenter)parent).IsObjectReference(parent.Value))
{
return(false);
}
return(base.ShouldCreateMemberPresenter(parent, member, propertyProvider));
}
/// <inheritdoc/>
public override void Destroy()
{
if (associatedContent != null)
{
associatedContent.Changing -= ContentChanging;
associatedContent.Changed -= ContentChanged;
associatedContent = null;
}
base.Destroy();
}
internal override void SetExprHost(IMemberNode memberExprHost, ObjectModelImpl reportObjectModel)
{
if (base.ExprHostID >= 0)
{
Global.Tracer.Assert(memberExprHost != null && reportObjectModel != null);
m_exprHost = (DataGroupExprHost)memberExprHost;
m_exprHost.SetReportObjectModel(reportObjectModel);
MemberNodeSetExprHost(m_exprHost, reportObjectModel);
}
}
private void CheckAndProcessIdentifiableMember([NotNull] IMemberNode member)
{
var identifiable = member.Retrieve() as IIdentifiable;
if (identifiable == null)
{
return;
}
ProcessIdentifiableMembers(identifiable, member);
}
/// <summary>
/// Registers an <see cref="IContentNode"/> object to this virtual node so when the content is modified, this node will trigger notifications
/// of property changes for the <see cref="VirtualNodeViewModel{T}.TypedValue"/> property.
/// </summary>
/// <param name="content">The content to register.</param>
/// <remarks>Events subscriptions are cleaned when this virtual node is disposed.</remarks>
public void RegisterContentForNotifications(IMemberNode content)
{
if (associatedContent != null)
{
throw new InvalidOperationException("A content has already been registered to this virtual node");
}
associatedContent = content;
associatedContent.Changing += ContentChanging;
associatedContent.Changed += ContentChanged;
}
private void RegisterModelChanged()
{
UnregisterModelChanged();
var modelComponent = entity.AssetSideEntity.Get <ModelComponent>();
if (modelComponent != null)
{
var modelNode = entity.Editor.NodeContainer.GetNode(modelComponent);
modelContent = modelNode[nameof(ModelComponent.Model)];
modelContent.ValueChanging += ModelChanging;
}
}
public SpriteBordersViewModel(SpriteInfoViewModel sprite, IObjectNode spriteNode)
: base(sprite)
{
textureRegionNode = spriteNode[nameof(SpriteInfo.TextureRegion)];
textureRegionNode.ValueChanged += OnTextureRegionValueChanged;
var spriteBordersNode = spriteNode[nameof(SpriteInfo.Borders)];
borderBinding = new MemberGraphNodeBinding <Vector4>(spriteBordersNode, nameof(Borders), OnPropertyChanging, OnPropertyChanged, UndoRedoService);
DependentProperties.Add(nameof(Borders), new[] { nameof(ActualBorders) });
DependentProperties.Add(nameof(ScaleFactor), new[] { nameof(ActualBorders) });
}
internal override void SetExprHost(IMemberNode memberExprHost, ObjectModelImpl reportObjectModel)
{
if (base.ExprHostID >= 0)
{
Global.Tracer.Assert(memberExprHost != null && reportObjectModel != null);
m_exprHost = (ChartMemberExprHost)memberExprHost;
m_exprHost.SetReportObjectModel(reportObjectModel);
MemberNodeSetExprHost(m_exprHost, reportObjectModel);
}
if (m_exprHost != null && m_exprHost.ChartSeriesHost != null)
{
GetChartSeries()?.SetExprHost(m_exprHost.ChartSeriesHost, reportObjectModel);
}
}
public override bool ShouldConstructMember(IMemberNode member)
{
if (!base.ShouldConstructMember(member))
{
return(false);
}
// Only allow entry point at the top level
if (member.Parent == graphicsCompositorNode && !entryPoints.Contains(member.MemberDescriptor.Name))
{
return(false);
}
return(true);
}
/// <inheritdoc/>
void IInitializingObjectNode.AddMember(IMemberNode member, bool allowIfReference)
{
if (IsSealed)
{
throw new InvalidOperationException("Unable to add a child to a GraphNode that has been sealed");
}
// ReSharper disable once HeuristicUnreachableCode - this code is reachable only at the specific moment we call this method!
if (ItemReferences != null && !allowIfReference)
{
throw new InvalidOperationException("A GraphNode cannot have children when its content hold a reference.");
}
childrenMap.Add(member.Name, (MemberNode)member);
}
/// <summary>
/// Visits the <see cref="ObjectReference"/> contained in the given node, if any.
/// </summary>
/// <param name="node">The node being visited.</param>
protected virtual void VisitMemberTarget([NotNull] IMemberNode node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (node.TargetReference?.TargetNode != null)
{
if (ShouldVisitMemberTarget(node))
{
CurrentPath.PushTarget();
VisitReference(node, node.TargetReference);
CurrentPath.Pop();
}
}
}
/// <inheritdoc />
protected override bool ShouldConstructPropertyMember(IMemberNode member)
{
// Don't construct properties of the Hierarchy object.
if (member.MemberDescriptor.DeclaringType == typeof(AssetCompositeHierarchyData <TAssetPartDesign, TAssetPart>))
{
return(false);
}
// Don't construct properties for member referencing child parts.
if (AssetHierarchyPropertyGraph.IsChildPartReference(member, NodeIndex.Empty))
{
return(false);
}
return(base.ShouldConstructPropertyMember(member));
}
public override bool IsReferencedPart(IMemberNode member, IContentNode targetNode)
{
// If we're not accessing the target node through a member (eg. the target node is the root node of the visit)
// or if we're visiting the member itself and not yet its target, then we're not a referenced part.
if (member == null || targetNode == null || member == targetNode)
{
return(false);
}
if (typeof(TAssetPart).IsAssignableFrom(targetNode.Type))
{
// Check if we're the part referenced by a part design - other cases are references
return(member.Parent.Type != typeof(TAssetPartDesign));
}
return(base.IsReferencedPart(member, targetNode));
}
public override bool IsMemberTargetObjectReference(IMemberNode member, object value)
{
if (value is SceneCameraSlot)
{
return(true);
}
if (value is RenderStage)
{
return(true);
}
if (value is ISharedRenderer)
{
return(true);
}
return(base.IsMemberTargetObjectReference(member, value));
}
public SceneViewModel([NotNull] AssetViewModelConstructionParameters parameters)
: base(parameters)
{
SetAsDefaultCommand = new AnonymousCommand(ServiceProvider, SetAsDefault);
assetCommands.Add(new MenuCommandInfo(ServiceProvider, SetAsDefaultCommand)
{
DisplayName = "Set as default", Tooltip = "Set as default scene"
});
UpdateCommands();
Session.SessionStateChanged += SessionStateChanged;
var assetNode = NodeContainer.GetNode(Asset);
childrenNode = assetNode[nameof(SceneAsset.ChildrenIds)].Target;
parentNode = assetNode[nameof(SceneAsset.Parent)];
}
public TextureRegionViewModel(SpriteInfoViewModel sprite, IMemberNode textureRegionNode)
: base(sprite)
{
if (sprite.Editor.Cache != null)
{
RefreshImageSize();
}
else
{
sprite.Editor.Initialized += EditorInitialized;
}
textureRegionBinding = new MemberGraphNodeBinding <RectangleF, Rectangle>(textureRegionNode, nameof(Region), OnPropertyChanging, OnPropertyChanged, x => (Rectangle)x, UndoRedoService);
DependentProperties.Add(nameof(Region), new[] { nameof(ActualLeft), nameof(ActualTop), nameof(ActualWidth), nameof(ActualHeight), nameof(ActualRightOffset), nameof(ActualBottomOffset) });
DependentProperties.Add(nameof(ScaleFactor), new[] { nameof(ActualLeft), nameof(ActualTop), nameof(ActualWidth), nameof(ActualHeight), nameof(ActualRightOffset), nameof(ActualBottomOffset) });
DependentProperties.Add(nameof(ImageWidth), new[] { nameof(ActualRightOffset), nameof(ActualBottomOffset) });
DependentProperties.Add(nameof(ImageHeight), new[] { nameof(ActualRightOffset), nameof(ActualBottomOffset) });
}
public override void SetExprHost(IMemberNode memberExprHost, ObjectModelImpl reportObjectModel)
{
if (base.ExprHostID >= 0)
{
Global.Tracer.Assert(memberExprHost != null && reportObjectModel != null);
this.m_exprHost = (ChartMemberExprHost)memberExprHost;
this.m_exprHost.SetReportObjectModel(reportObjectModel);
base.MemberNodeSetExprHost(this.m_exprHost, reportObjectModel);
}
if (this.m_exprHost != null && this.m_exprHost.ChartSeriesHost != null)
{
ChartSeries chartSeries = this.GetChartSeries();
if (chartSeries != null)
{
chartSeries.SetExprHost(this.m_exprHost.ChartSeriesHost, reportObjectModel);
}
}
}
protected virtual bool ShouldReconcileItem(IMemberNode member, IContentNode targetNode, object localValue, object baseValue, bool isReference)
{
if (isReference)
{
// Reference type, we check matches by type
return(baseValue?.GetType() != localValue?.GetType());
}
// Content reference (note: they are not treated as reference
if (AssetRegistry.IsContentType(localValue?.GetType()) || AssetRegistry.IsContentType(localValue?.GetType()))
{
var localRef = AttachedReferenceManager.GetAttachedReference(localValue);
var baseRef = AttachedReferenceManager.GetAttachedReference(baseValue);
return(localRef?.Id != baseRef?.Id || localRef?.Url != baseRef?.Url);
}
// Value type, we check for equality
return(!Equals(localValue, baseValue));
}
private static void VerifyItem(IMemberNode listMemberNode, int index, object expectedValue, bool isPrimitive)
{
var targetNode = listMemberNode.Target;
var enumRef = targetNode.ItemReferences;
var indexValue = new NodeIndex(index);
Assert.NotNull(enumRef);
Assert.NotNull(targetNode.Indices);
Assert.Equal(indexValue, targetNode.Indices.ToList()[index]);
Assert.Equal(indexValue, enumRef.Indices.ToList()[index]);
Assert.Equal(indexValue, enumRef.ToList()[index].Index);
Assert.Equal(expectedValue, enumRef.ToList()[index].ObjectValue);
Assert.NotNull(enumRef.ToList()[index].TargetNode);
Assert.Equal(expectedValue, enumRef.ToList()[index].TargetNode.Retrieve());
Assert.Equal(TypeDescriptorFactory.Default.Find(expectedValue.GetType()), enumRef.ToList()[index].TargetNode.Descriptor);
Assert.False(enumRef.ToList()[index].TargetNode.IsReference);
Assert.Equal(expectedValue.GetType(), enumRef.ToList()[index].TargetNode.Type);
Assert.Equal(expectedValue, enumRef.ToList()[index].TargetNode.Retrieve());
}
protected KeyFrameControlPointViewModel([NotNull] CurveViewModelBase curve, [NotNull] IMemberNode keyNode, [NotNull] IMemberNode valueNode, [NotNull] IMemberNode tangentTypeNode)
: base(curve)
{
if (keyNode == null)
{
throw new ArgumentNullException(nameof(keyNode));
}
if (valueNode == null)
{
throw new ArgumentNullException(nameof(valueNode));
}
if (tangentTypeNode == null)
{
throw new ArgumentNullException(nameof(tangentTypeNode));
}
keyBinding = CreateBinding <float>(keyNode, nameof(Key));
ValueBinding = CreateBinding <TValue>(valueNode, nameof(Value));
tangentTypeBinding = CreateBinding <AnimationKeyTangentType>(tangentTypeNode, nameof(TangentType));
}
