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