/// <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="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="modelNodePath">The <see cref="ModelNodePath"/> corresponding to the given <see cref="modelNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IModelNode modelNode, ModelNodePath modelNodePath, object index = null)
: base(ownerViewModel, baseName, index)
{
if (modelNode == null)
{
throw new ArgumentNullException("modelNode");
}
if (baseName == null && index == null)
{
throw new ArgumentException("baseName and index can't be both null.");
}
this.isPrimitive = isPrimitive;
SourceNode = modelNode;
// By default we will always combine items of list of primitive items.
CombineMode = index != null && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll;
targetNode = GetTargetNode(modelNode, index);
SourceNodePath = modelNodePath;
// Override display name if available
if (index == null)
{
var memberDescriptor = GetMemberDescriptor() as MemberDescriptorBase;
if (memberDescriptor != null)
{
var displayAttribute = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute <DisplayAttribute>(memberDescriptor.MemberInfo);
if (displayAttribute != null && !string.IsNullOrEmpty(displayAttribute.Name))
{
DisplayName = displayAttribute.Name;
}
}
}
}
/// <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="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="graphNodePath">The <see cref="GraphNodePath"/> corresponding to the given <see cref="modelNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IGraphNode modelNode, GraphNodePath graphNodePath, object index = null)
: base(ownerViewModel, baseName, index)
{
if (modelNode == null) throw new ArgumentNullException(nameof(modelNode));
if (baseName == null && index == null)
throw new ArgumentException("baseName and index can't be both null.");
this.isPrimitive = isPrimitive;
SourceNode = modelNode;
// By default we will always combine items of list of primitive items.
CombineMode = index != null && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll;
SourceNodePath = graphNodePath;
// Override display name if available
var memberDescriptor = GetMemberDescriptor() as MemberDescriptorBase;
if (memberDescriptor != null)
{
if (index == null)
{
var displayAttribute = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute<DisplayAttribute>(memberDescriptor.MemberInfo);
if (!string.IsNullOrEmpty(displayAttribute?.Name))
{
DisplayName = displayAttribute.Name;
}
IsReadOnly = !memberDescriptor.HasSet;
}
}
}
/// <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 static ObservableViewModel CombineViewModels(IViewModelServiceProvider serviceProvider, ModelContainer modelContainer, IEnumerable <ObservableViewModel> viewModels)
{
var combinedViewModel = new ObservableViewModel(serviceProvider, modelContainer);
var rootNodes = new List <ObservableModelNode>();
foreach (var viewModel in viewModels)
{
if (!(viewModel.RootNode is SingleObservableNode))
{
throw new ArgumentException(@"The view models to combine must contains SingleObservableNode.", "viewModels");
}
foreach (var dirtiableViewModel in viewModel.dirtiableViewModels)
{
combinedViewModel.dirtiableViewModels.Add(dirtiableViewModel.Key, dirtiableViewModel.Value.ToList());
}
var rootNode = (ObservableModelNode)viewModel.RootNode;
rootNodes.Add(rootNode);
}
if (rootNodes.Count < 2)
{
throw new ArgumentException(@"Called CombineViewModels with a collection of view models that is either empty or containt just a single item.", "viewModels");
}
CombinedObservableNode rootCombinedNode = CombinedObservableNode.Create(combinedViewModel, "Root", null, typeof(object), rootNodes, null);
combinedViewModel.Identifier = new ObservableViewModelIdentifier(rootNodes.Select(x => x.ModelGuid));
rootCombinedNode.Initialize();
combinedViewModel.RootNode = rootCombinedNode;
return(combinedViewModel);
}
protected VirtualObservableNode(ObservableViewModel ownerViewModel, string name, SingleObservableNode parentNode, int?order, NodeCommandWrapperBase valueChangedCommand)
: base(ownerViewModel, name, parentNode, null)
{
this.order = order;
Name = name;
ValueChangedCommand = valueChangedCommand;
}
protected VirtualObservableNode(ObservableViewModel ownerViewModel, string name, int?order, bool isPrimitive, object index, NodeCommandWrapperBase valueChangedCommand)
: base(ownerViewModel, name, index)
{
Order = order;
IsPrimitive = isPrimitive;
Name = name;
ValueChangedCommand = valueChangedCommand;
}
protected VirtualObservableNode(ObservableViewModel ownerViewModel, string name, int? order, bool isPrimitive, object index, NodeCommandWrapperBase valueChangedCommand)
: base(ownerViewModel, name, index)
{
Order = order;
IsPrimitive = isPrimitive;
Name = name;
ValueChangedCommand = valueChangedCommand;
}
protected CombinedObservableNode(ObservableViewModel ownerViewModel, string name, IEnumerable <SingleObservableNode> combinedNodes, Index index)
: base(ownerViewModel, index)
{
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
DependentProperties.Add(nameof(Value), new[] { nameof(HasMultipleValues), nameof(IsPrimitive), nameof(HasList), nameof(HasDictionary) });
this.combinedNodes = new List <SingleObservableNode>(combinedNodes);
Name = name;
DisplayName = this.combinedNodes.First().DisplayName;
combinedNodeInitialValues = new List <object>();
distinctCombinedNodeInitialValues = new HashSet <object>();
bool isReadOnly = false;
bool isVisible = false;
bool nullOrder = false;
foreach (var node in this.combinedNodes)
{
if (node.IsDisposed)
{
throw new InvalidOperationException("One of the combined node is already disposed.");
}
if (node.IsReadOnly)
{
isReadOnly = true;
}
if (node.IsVisible)
{
isVisible = true;
}
if (node.Order == null)
{
nullOrder = true;
}
if (order == node.Order || (!nullOrder && order == null))
{
order = node.Order;
}
combinedNodeInitialValues.Add(node.Value);
distinctCombinedNodeInitialValues.Add(node.Value);
}
IsReadOnly = isReadOnly;
IsVisible = isVisible;
ResetInitialValues = new AnonymousCommand(ServiceProvider, () =>
{
using (Owner.BeginCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path))
{
CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2);
Refresh();
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SingleObservableNode"/> class.
/// </summary>
/// <param name="ownerViewModel">The <see cref="ObservableViewModel"/> that owns the new <see cref="SingleObservableNode"/>.</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="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 SingleObservableNode(ObservableViewModel ownerViewModel, string baseName, Index index)
: base(ownerViewModel, index)
{
if (baseName == null && index == null)
throw new ArgumentException("baseName and index can't be both null.");
CombineMode = CombineMode.CombineOnlyForAll;
SetName(baseName);
}
protected ObservableNode(ObservableViewModel ownerViewModel, object index = null)
: base(ownerViewModel.ServiceProvider)
{
Owner = ownerViewModel;
Index = index;
Guid = Guid.NewGuid();
IsVisible = true;
IsReadOnly = false;
}
protected ObservableNode(ObservableViewModel ownerViewModel, Index index)
: base(ownerViewModel.ServiceProvider)
{
Owner = ownerViewModel;
Index = index;
Guid = Guid.NewGuid();
IsVisible = true;
IsReadOnly = false;
}
protected VirtualObservableNode(ObservableViewModel owner, string name, bool isPrimitive, int? order, Index index, Func<object> getter, Action<object> setter)
: base(owner, name, index)
{
if (getter == null) throw new ArgumentNullException(nameof(getter));
Getter = getter;
Setter = setter;
Order = order;
IsPrimitive = isPrimitive;
Name = name;
}
/// <summary>
/// Initializes a new instance of the <see cref="SingleObservableNode"/> class.
/// </summary>
/// <param name="ownerViewModel">The <see cref="ObservableViewModel"/> that owns the new <see cref="SingleObservableNode"/>.</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="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 SingleObservableNode(ObservableViewModel ownerViewModel, string baseName, Index index)
: base(ownerViewModel, index)
{
if (baseName == null && index == null)
{
throw new ArgumentException("baseName and index can't be both null.");
}
CombineMode = CombineMode.CombineOnlyForAll;
SetName(baseName);
}
public CombinedActionsContext(ObservableViewModel owner, string actionName, string observableNodePath)
{
if (owner == null) throw new ArgumentNullException(nameof(owner));
var service = owner.ServiceProvider.TryGet<IUndoRedoService>();
if (service != null)
{
transaction = service.CreateTransaction();
service.SetName(transaction, actionName);
}
this.owner = owner;
this.observableNodePath = observableNodePath;
}
public ModelNodeCommandWrapper(IViewModelServiceProvider serviceProvider, INodeCommand nodeCommand, string observableNodePath, ObservableViewModel owner, ModelNodePath nodePath, IEnumerable<IDirtiableViewModel> dirtiables)
: base(serviceProvider, dirtiables)
{
if (nodeCommand == null) throw new ArgumentNullException(nameof(nodeCommand));
if (owner == null) throw new ArgumentNullException(nameof(owner));
NodePath = nodePath;
// Note: the owner should not be stored in the command because we want it to be garbage collectable
Identifier = owner.Identifier;
ModelContainer = owner.ModelContainer;
NodeCommand = nodeCommand;
Service = serviceProvider.Get<ObservableViewModelService>();
ObservableNodePath = observableNodePath;
}
protected VirtualObservableNode(ObservableViewModel owner, string name, bool isPrimitive, int?order, Index index, Func <object> getter, Action <object> setter)
: base(owner, name, index)
{
if (getter == null)
{
throw new ArgumentNullException(nameof(getter));
}
Getter = getter;
Setter = setter;
Order = order;
IsPrimitive = isPrimitive;
Name = name;
}
protected CombinedObservableNode(ObservableViewModel ownerViewModel, string name, IEnumerable<SingleObservableNode> combinedNodes, Index index)
: base(ownerViewModel, index)
{
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
DependentProperties.Add(nameof(Value), new[] { nameof(HasMultipleValues), nameof(IsPrimitive), nameof(HasList), nameof(HasDictionary) });
this.combinedNodes = new List<SingleObservableNode>(combinedNodes);
Name = name;
DisplayName = this.combinedNodes.First().DisplayName;
combinedNodeInitialValues = new List<object>();
distinctCombinedNodeInitialValues = new HashSet<object>();
bool isReadOnly = false;
bool isVisible = false;
bool nullOrder = false;
foreach (var node in this.combinedNodes)
{
if (node.IsDestroyed)
throw new InvalidOperationException("One of the combined node is already disposed.");
if (node.IsReadOnly)
isReadOnly = true;
if (node.IsVisible)
isVisible = true;
if (node.Order == null)
nullOrder = true;
if (order == node.Order || (!nullOrder && order == null))
order = node.Order;
combinedNodeInitialValues.Add(node.Value);
distinctCombinedNodeInitialValues.Add(node.Value);
}
IsReadOnly = isReadOnly;
IsVisible = isVisible;
ResetInitialValues = new AnonymousCommand(ServiceProvider, () =>
{
using (Owner.BeginCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path))
{
CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2);
Refresh();
}
});
}
public CombinedActionsContext(ObservableViewModel owner, string actionName, string observableNodePath)
{
if (owner == null)
{
throw new ArgumentNullException(nameof(owner));
}
var service = owner.ServiceProvider.TryGet <IUndoRedoService>();
if (service != null)
{
transaction = service.CreateTransaction();
service.SetName(transaction, actionName);
}
this.owner = owner;
this.observableNodePath = observableNodePath;
}
public static ObservableViewModel CombineViewModels(IViewModelServiceProvider serviceProvider, IReadOnlyCollection <ObservableViewModel> viewModels)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (viewModels == null)
{
throw new ArgumentNullException(nameof(viewModels));
}
var combinedViewModel = new ObservableViewModel(serviceProvider);
var rootNodes = new List <ObservableModelNode>();
foreach (var viewModel in viewModels)
{
if (!(viewModel.RootNode is SingleObservableNode))
{
throw new ArgumentException(@"The view models to combine must contains SingleObservableNode.", nameof(viewModels));
}
viewModel.parent = combinedViewModel;
combinedViewModel.children.Add(viewModel);
var rootNode = (ObservableModelNode)viewModel.RootNode;
rootNodes.Add(rootNode);
}
if (rootNodes.Count < 2)
{
throw new ArgumentException(@"Called CombineViewModels with a collection of view models that is either empty or containt just a single item.", nameof(viewModels));
}
// Find best match for the root node type
var rootNodeType = rootNodes.First().Root.Type;
if (rootNodes.Skip(1).Any(x => x.Type != rootNodeType))
{
rootNodeType = typeof(object);
}
CombinedObservableNode rootCombinedNode = CombinedObservableNode.Create(combinedViewModel, "Root", null, rootNodeType, rootNodes, Index.Empty);
rootCombinedNode.Initialize();
combinedViewModel.RootNode = rootCombinedNode;
return(combinedViewModel);
}
protected CombinedObservableNode(ObservableViewModel ownerViewModel, string name, IEnumerable <SingleObservableNode> combinedNodes, object index)
: base(ownerViewModel, index)
{
this.combinedNodes = new List <SingleObservableNode>(combinedNodes);
Name = name;
DisplayName = this.combinedNodes.First().DisplayName;
combinedNodeInitialValues = new List <object>();
distinctCombinedNodeInitialValues = new HashSet <object>();
bool isReadOnly = false;
bool isVisible = false;
bool nullOrder = false;
foreach (var node in this.combinedNodes)
{
if (node.IsReadOnly)
{
isReadOnly = true;
}
if (node.IsVisible)
{
isVisible = true;
}
if (node.Order == null)
{
nullOrder = true;
}
if (order == node.Order || (!nullOrder && order == null))
{
order = node.Order;
}
combinedNodeInitialValues.Add(node.Value);
distinctCombinedNodeInitialValues.Add(node.Value);
node.PropertyChanged += NodePropertyChanged;
}
IsReadOnly = isReadOnly;
IsVisible = isVisible;
ResetInitialValues = new AnonymousCommand(ServiceProvider, () => { Owner.BeginCombinedAction(); CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2); Refresh(); Owner.EndCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path, null); });
}
/// <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="parentNode">The parent node of the new <see cref="ObservableModelNode"/>, or <c>null</c> if the node being created is the root node of the view model.</param>
/// <param name="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
protected ObservableModelNode(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, SingleObservableNode parentNode, IModelNode modelNode, object index = null)
: base(ownerViewModel, baseName, parentNode, index)
{
if (modelNode == null)
{
throw new ArgumentNullException("modelNode");
}
if (baseName == null && index == null)
{
throw new ArgumentException("baseName and index can't be both null.");
}
this.isPrimitive = isPrimitive;
sourceNode = modelNode;
// By default we will always combine items of list of primitive items.
CombineMode = index != null && isPrimitive ? CombineMode.AlwaysCombine : CombineMode.CombineOnlyForAll;
targetNode = GetTargetNode(modelNode, index);
}
protected CombinedObservableNode(ObservableViewModel ownerViewModel, string name, IEnumerable<SingleObservableNode> combinedNodes, object index)
: base(ownerViewModel, index)
{
this.combinedNodes = new List<SingleObservableNode>(combinedNodes);
Name = name;
DisplayName = this.combinedNodes.First().DisplayName;
combinedNodeInitialValues = new List<object>();
distinctCombinedNodeInitialValues = new HashSet<object>();
bool isReadOnly = false;
bool isVisible = false;
bool nullOrder = false;
foreach (var node in this.combinedNodes)
{
if (node.IsReadOnly)
isReadOnly = true;
if (node.IsVisible)
isVisible = true;
if (node.Order == null)
nullOrder = true;
if (order == node.Order || (!nullOrder && order == null))
order = node.Order;
combinedNodeInitialValues.Add(node.Value);
distinctCombinedNodeInitialValues.Add(node.Value);
node.PropertyChanged += NodePropertyChanged;
}
IsReadOnly = isReadOnly;
IsVisible = isVisible;
ResetInitialValues = new AnonymousCommand(ServiceProvider, () => { Owner.BeginCombinedAction(); CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2); Refresh(); Owner.EndCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path, null); });
}
protected abstract string GetDependencyPath(ObservableViewModel viewModel);
public ModelNodeCommandWrapper(IViewModelServiceProvider serviceProvider, INodeCommand nodeCommand, string observableNodePath, ObservableViewModel owner, ModelNodePath nodePath, IEnumerable <IDirtiableViewModel> dirtiables)
: base(serviceProvider, dirtiables)
{
if (nodeCommand == null)
{
throw new ArgumentNullException(nameof(nodeCommand));
}
if (owner == null)
{
throw new ArgumentNullException(nameof(owner));
}
NodePath = nodePath;
// Note: the owner should not be stored in the command because we want it to be garbage collectable
Identifier = owner.Identifier;
ModelContainer = owner.ModelContainer;
NodeCommand = nodeCommand;
Service = serviceProvider.Get <ObservableViewModelService>();
ObservableNodePath = observableNodePath;
}
/// <summary>
/// Create an <see cref="ObservableModelNode{T}"/> that matches the given content type.
/// </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="parentNode">The parent node of the new <see cref="ObservableModelNode"/>, or <c>null</c> if the node being created is the root node of the view model.</param>
/// <param name="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="contentType">The type of content contained by the new <see cref="ObservableModelNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
/// <returns>A new instance of <see cref="ObservableModelNode{T}"/> instanced with the given content type as generic argument.</returns>
internal static ObservableModelNode Create(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, SingleObservableNode parentNode, IModelNode modelNode, Type contentType, object index)
{
var node = (ObservableModelNode)Activator.CreateInstance(typeof(ObservableModelNode <>).MakeGenericType(contentType), ownerViewModel, baseName, isPrimitive, parentNode, modelNode, index);
return(node);
}
/// <summary>
/// Create an <see cref="ObservableModelNode{T}"/> that matches the given content type.
/// </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 node.</param>
/// <param name="contentType">The type of content contained by the new <see cref="ObservableModelNode"/>.</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>
/// <returns>A new instance of <see cref="ObservableModelNode{T}"/> instanced with the given content type as generic argument.</returns>
internal static ObservableModelNode Create(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IGraphNode sourceNode, GraphNodePath graphNodePath, Type contentType, Index index)
{
var node = (ObservableModelNode)Activator.CreateInstance(typeof(ObservableModelNode <>).MakeGenericType(contentType), ownerViewModel, baseName, isPrimitive, sourceNode, graphNodePath, index);
return(node);
}
public ObservableViewModelDirtinessUpdatedArgs(ObservableViewModel viewModel, string nodePath)
{
ViewModel = viewModel;
NodePath = nodePath;
}
internal static CombinedObservableNode Create(ObservableViewModel ownerViewModel, string name, CombinedObservableNode parent, Type contentType, IEnumerable<SingleObservableNode> combinedNodes, object index)
{
var node = (CombinedObservableNode)Activator.CreateInstance(typeof(CombinedObservableNode<>).MakeGenericType(contentType), ownerViewModel, name, combinedNodes, index);
return node;
}
public ObservableViewModelDirtinessUpdatedArgs(ObservableViewModel viewModel, string nodePath)
{
ViewModel = viewModel;
NodePath = nodePath;
}
internal static VirtualObservableNode Create(ObservableViewModel ownerViewModel, string name, int? order, bool isPrimitive, Type contentType, object initialValue, object index, NodeCommandWrapperBase valueChangedCommand)
{
var node = (VirtualObservableNode)Activator.CreateInstance(typeof(VirtualObservableNode<>).MakeGenericType(contentType), ownerViewModel, name, order, isPrimitive, initialValue, index, valueChangedCommand);
return node;
}
public static ObservableViewModel CombineViewModels(IViewModelServiceProvider serviceProvider, IReadOnlyCollection<ObservableViewModel> viewModels)
{
if (serviceProvider == null) throw new ArgumentNullException(nameof(serviceProvider));
if (viewModels == null) throw new ArgumentNullException(nameof(viewModels));
var combinedViewModel = new ObservableViewModel(serviceProvider);
var rootNodes = new List<ObservableModelNode>();
foreach (var viewModel in viewModels)
{
if (!(viewModel.RootNode is SingleObservableNode))
throw new ArgumentException(@"The view models to combine must contains SingleObservableNode.", nameof(viewModels));
viewModel.parent = combinedViewModel;
var rootNode = (ObservableModelNode)viewModel.RootNode;
rootNodes.Add(rootNode);
}
if (rootNodes.Count < 2)
throw new ArgumentException(@"Called CombineViewModels with a collection of view models that is either empty or containt just a single item.", nameof(viewModels));
// Find best match for the root node type
var rootNodeType = rootNodes.First().Root.Type;
if (rootNodes.Skip(1).Any(x => x.Type != rootNodeType))
rootNodeType = typeof(object);
CombinedObservableNode rootCombinedNode = CombinedObservableNode.Create(combinedViewModel, "Root", null, rootNodeType, rootNodes, Index.Empty);
rootCombinedNode.Initialize();
combinedViewModel.RootNode = rootCombinedNode;
return combinedViewModel;
}
private static ObservableModelNode DefaultCreateNode(ObservableViewModel viewModel, string baseName, bool isPrimitive, IGraphNode modelNode, GraphNodePath graphNodePath, Type contentType, Index index)
{
return ObservableModelNode.Create(viewModel, baseName, isPrimitive, modelNode, graphNodePath, contentType, index);
}
public NodeChangedArgs(ObservableViewModel viewModel, string nodePath)
{
ViewModel = viewModel;
NodePath = nodePath;
}
internal static VirtualObservableNode Create(ObservableViewModel owner, string name, Type contentType, bool isPrimitive, int? order, object index, Func<object> getter, Action<object> setter)
{
var node = (VirtualObservableNode)Activator.CreateInstance(typeof(VirtualObservableNode<>).MakeGenericType(contentType), owner, name, isPrimitive, order, index, getter, setter);
return node;
}
internal static VirtualObservableNode Create(ObservableViewModel ownerViewModel, string name, int?order, bool isPrimitive, Type contentType, object initialValue, object index, NodeCommandWrapperBase valueChangedCommand)
{
var node = (VirtualObservableNode)Activator.CreateInstance(typeof(VirtualObservableNode <>).MakeGenericType(contentType), ownerViewModel, name, order, isPrimitive, initialValue, index, valueChangedCommand);
return(node);
}
private static ObservableModelNode DefaultCreateNode(ObservableViewModel viewModel, string baseName, bool isPrimitive, IGraphNode modelNode, GraphNodePath graphNodePath, Type contentType, object index)
{
return(ObservableModelNode.Create(viewModel, baseName, isPrimitive, modelNode, graphNodePath, contentType, index));
}
protected override string GetDependencyPath(ObservableViewModel viewModel)
{
return viewModel.RootNode.GetChild(Instance).Path;
}
public ObservableViewModelNodeValueChangedArgs(ObservableViewModel viewModel, string nodePath)
{
ViewModel = viewModel;
NodePath = nodePath;
}
internal static VirtualObservableNode Create(ObservableViewModel owner, string name, Type contentType, bool isPrimitive, int?order, object index, Func <object> getter, Action <object> setter)
{
var node = (VirtualObservableNode)Activator.CreateInstance(typeof(VirtualObservableNode <>).MakeGenericType(contentType), owner, name, isPrimitive, order, index, getter, setter);
return(node);
}
internal static CombinedObservableNode Create(ObservableViewModel ownerViewModel, string name, CombinedObservableNode parent, Type contentType, IEnumerable <SingleObservableNode> combinedNodes, Index index)
{
var node = (CombinedObservableNode)Activator.CreateInstance(typeof(CombinedObservableNode <>).MakeGenericType(contentType), ownerViewModel, name, combinedNodes, index);
return(node);
}
/// <summary>
/// Create an <see cref="ObservableModelNode{T}"/> that matches the given content type.
/// </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="modelNode">The model node bound to the new <see cref="ObservableModelNode"/>.</param>
/// <param name="graphNodePath">The <see cref="GraphNodePath"/> corresponding to the given node.</param>
/// <param name="contentType">The type of content contained by the new <see cref="ObservableModelNode"/>.</param>
/// <param name="index">The index of this content in the model node, when this node represent an item of a collection. <c>null</c> must be passed otherwise</param>
/// <returns>A new instance of <see cref="ObservableModelNode{T}"/> instanced with the given content type as generic argument.</returns>
internal static ObservableModelNode Create(ObservableViewModel ownerViewModel, string baseName, bool isPrimitive, IGraphNode modelNode, GraphNodePath graphNodePath, Type contentType, object index)
{
var node = (ObservableModelNode)Activator.CreateInstance(typeof(ObservableModelNode<>).MakeGenericType(contentType), ownerViewModel, baseName, isPrimitive, modelNode, graphNodePath, index);
return node;
}
