/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="referenceRSNode">ReferenceRSNode.</param> /// <param name="parent">Parent.</param> public ReferenceRSNodeViewModel(ViewModelStore viewModelStore, ReferenceRSNode referenceRSNode, TreeNodeViewModel parent) : base(viewModelStore, referenceRSNode.ReferenceRelationship, parent) { this.referenceRSNode = referenceRSNode; this.referenceNodeVMs = new ObservableCollection <ReferenceNodeViewModel>(); this.referenceNodeVMsRO = new ReadOnlyObservableCollection <ReferenceNodeViewModel>(referenceNodeVMs); this.shapeNodeVMs = new ObservableCollection <ShapeRelationshipNodeViewModel>(); this.shapeNodeVMsRO = new ReadOnlyObservableCollection <ShapeRelationshipNodeViewModel>(shapeNodeVMs); if (referenceRSNode != null) { if (referenceRSNode.ReferenceNode != null) { AddReferenceNode(referenceRSNode.ReferenceNode); } foreach (ShapeRelationshipNode node in referenceRSNode.ShapeRelationshipNodes) { if (node != null) { AddShapeNode(node); } } Subscribe(); } this.collapseExpandRelationshipShapeMappingCommand = new DelegateCommand(CollapseExpandRelationshipShapeMappingCommand_Executed); }
public override void ElementAdded(ElementAddedEventArgs e) { if (e.ModelElement != null) { if (e.ModelElement.Store.TransactionManager.CurrentTransaction != null) { if (e.ModelElement.Store.TransactionManager.CurrentTransaction.IsSerializing) { return; } } } if (e.ModelElement == null) { return; } if (ImmutabilityExtensionMethods.GetLocks(e.ModelElement) != Locks.None) { return; } RelationshipShapeClassReferencesReferenceRelationship con = e.ModelElement as RelationshipShapeClassReferencesReferenceRelationship; if (con != null) { if (con.DomainRelationship is ReferenceRelationship) { ReferenceRelationship rel = con.DomainRelationship as ReferenceRelationship; ReferenceRSNode node = rel.ReferenceRSNode; // create new shape relationship node ShapeRelationshipNode shapeNode = new ShapeRelationshipNode(con.Store); shapeNode.RelationshipShapeClass = con.RelationshipShapeClass; node.ShapeRelationshipNodes.Add(shapeNode); rel.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode); if (rel.SerializedReferenceRelationship != null) { if (!rel.SerializedReferenceRelationship.IsInFullSerialization) { if (System.Windows.MessageBox.Show("Shape mapping has been defined for the ReferenceRelationship '" + rel.Name + "'. The Relationship is not serialized in full form. Would you like to change the serialization of this relationship to full form (strongly adviced)?", "Serialization", System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxImage.Question) == System.Windows.MessageBoxResult.Yes) { rel.SerializedReferenceRelationship.IsInFullSerialization = true; } } } } } }
public override void ElementDeleting(ElementDeletingEventArgs e) { if (e.ModelElement != null) { if (e.ModelElement.Store.TransactionManager.CurrentTransaction != null) { if (e.ModelElement.Store.TransactionManager.CurrentTransaction.IsSerializing) { return; } } } if (e.ModelElement == null) { return; } if (ImmutabilityExtensionMethods.GetLocks(e.ModelElement) != Locks.None) { return; } RelationshipShapeClassReferencesReferenceRelationship con = e.ModelElement as RelationshipShapeClassReferencesReferenceRelationship; if (con != null) { if (con.DomainRelationship is ReferenceRelationship) { RelationshipShapeClass shape = con.RelationshipShapeClass; ShapeRelationshipNode node = shape.ShapeRelationshipNode; if (node != null) { // delete ReferenceRelationship rel = con.DomainRelationship as ReferenceRelationship; ReferenceRSNode n = rel.ReferenceRSNode; if (n != null) { if (n.ShapeRelationshipNodes.Contains(node)) { n.ShapeRelationshipNodes.Remove(node); } } node.Delete(); } } } }
/// <summary> /// Adds a new referece relationship instance. /// </summary> /// <param name="source">Domain class representing the source.</param> /// <param name="target">Domain class representing the target.</param> public static void AddNewReferenceRelationship(ReferenceRelationship refRel, DomainClass source, AttributedDomainElement target) { // tree nodes // 1. find the element holder node for source // 2. add new ReferenceRSNode, connect to rs // 3. add new ReferenceNode for target TreeNode elementHolderNode = null; foreach (TreeNode node in source.DomainModelTreeNodes) { if (node.IsElementHolder) { elementHolderNode = node; break; } } if (elementHolderNode == null) { throw new ArgumentNullException("elementHolderNode"); } ReferenceRSNode rsNode = new ReferenceRSNode(source.Store); rsNode.ReferenceRelationship = refRel; ReferenceNode refNode = new ReferenceNode(source.Store); refNode.DomainElement = target; refNode.IsElementHolder = false; refNode.IsExpanded = false; elementHolderNode.ReferenceRSNodes.Add(rsNode); rsNode.ReferenceNode = refNode; source.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(rsNode); source.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(refNode); }
/// <summary> /// Deletes the rs view model that is hosting the given rs node. /// </summary> /// <param name="node">Rs node.</param> public void DeleteReferenceRSNode(ReferenceRSNode node) { for (int i = this.referenceRSNodeVMs.Count - 1; i >= 0; i--) if (this.referenceRSNodeVMs[i].ReferenceRSNode.Id == node.Id) { this.referenceRSNodeVMs[i].Dispose(); this.referenceRSNodeVMs.RemoveAt(i); } foreach (ReferenceRSNodeViewModel viewModel in this.referenceRSNodeVMs) viewModel.UpdateNodePosition(); OnPropertyChanged("HasReferenceNodes"); }
/// <summary> /// Adds a new reference rs view model for the given rs node. /// </summary> /// <param name="node">Rs node.</param> public void AddReferenceRSNode(ReferenceRSNode node) { // verify that node hasnt been added yet foreach (ReferenceRSNodeViewModel viewModel in this.referenceRSNodeVMs) if (viewModel.ReferenceRSNode.Id == node.Id) return; ReferenceRSNodeViewModel vm = new ReferenceRSNodeViewModel(this.ViewModelStore, node, this); this.referenceRSNodeVMs.Add(vm); foreach (ReferenceRSNodeViewModel viewModel in this.referenceRSNodeVMs) viewModel.UpdateNodePosition(); OnPropertyChanged("HasReferenceNodes"); }
private static void FixUpDomainModelTreeView(LibraryModelContext model) { // create root nodes and embedding rs foreach (DomainClass domainClass in model.Classes) { if (!domainClass.HasParent()) { RootNode node = new RootNode(model.Store); node.DomainElement = domainClass; node.IsElementHolder = true; domainClass.ModelContext.ViewContext.DomainModelTreeView.RootNodes.Add(node); domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(node); node.IsEmbeddingTreeExpanded = true; node.IsReferenceTreeExpanded = true; node.IsInheritanceTreeExpanded = true; node.IsShapeMappingTreeExpanded = true; FixUpDomainClassInTreeView(domainClass); } } // reference relationships + shapes foreach (DomainRelationship relationship in model.Relationships) { if (relationship is ReferenceRelationship) { ReferenceRelationship rel = relationship as ReferenceRelationship; ModelTreeHelper.AddNewReferenceRelationship(rel, rel.Source.RolePlayer as DomainClass, rel.Target.RolePlayer); // shape foreach (RelationshipShapeClass s in rel.RelationshipShapeClasses) { ReferenceRSNode node = rel.ReferenceRSNode; // create new shape relationship node ShapeRelationshipNode shapeNode = new ShapeRelationshipNode(rel.Store); shapeNode.RelationshipShapeClass = s; node.ShapeRelationshipNodes.Add(shapeNode); rel.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode); } } } // inheritance foreach (DomainClass domainClass in model.Classes) { if (domainClass.BaseClass != null) { DomainClassReferencesBaseClass refBase = DomainClassReferencesBaseClass.GetLink(domainClass, domainClass.BaseClass); if (refBase != null) { if (domainClass.DomainModelTreeNodes.Count > 0) { ModelTreeHelper.AddNewInheritanceRelationship(refBase, domainClass, domainClass.BaseClass, false); } else { ModelTreeHelper.AddNewInheritanceRelationship(refBase, domainClass, domainClass.BaseClass, true); } } } } // shapes foreach (DomainClass domainClass in model.Classes) { foreach (PresentationDomainClassElement p in domainClass.ShapeClasses) { foreach (TreeNode node in domainClass.DomainModelTreeNodes) { if (node.IsElementHolder) { ShapeClassNode shapeNode = new ShapeClassNode(domainClass.Store); shapeNode.ShapeClass = p; node.ShapeClassNodes.Add(shapeNode); domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode); break; } } } } }
public override void RolePlayerChanged(RolePlayerChangedEventArgs e) { if (e.ElementLink != null) { if (e.ElementLink.Store.TransactionManager.CurrentTransaction != null) { if (e.ElementLink.Store.TransactionManager.CurrentTransaction.IsSerializing) { return; } } } if (e.ElementLink == null) { return; } if (ImmutabilityExtensionMethods.GetLocks(e.ElementLink) != Locks.None) { return; } RelationshipShapeClassReferencesReferenceRelationship con = e.ElementLink as RelationshipShapeClassReferencesReferenceRelationship; if (con != null) { RelationshipShapeClass shape = con.RelationshipShapeClass; ShapeRelationshipNode node = shape.ShapeRelationshipNode; // delete old ReferenceRelationship relOld = e.OldRolePlayer as ReferenceRelationship; if (relOld != null) { ReferenceRSNode nodeOld = relOld.ReferenceRSNode; if (nodeOld != null) { node.RelationshipShapeClass = null; if (nodeOld.ShapeRelationshipNodes.Contains(node)) { nodeOld.ShapeRelationshipNodes.Remove(node); } } node.Delete(); } // create new ReferenceRelationship rel = e.NewRolePlayer as ReferenceRelationship; if (rel != null) { ReferenceRSNode n = rel.ReferenceRSNode; // create new shape relationship node ShapeRelationshipNode shapeNode = new ShapeRelationshipNode(con.Store); shape.ShapeRelationshipNode = shapeNode; n.ShapeRelationshipNodes.Add(shapeNode); rel.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode); if (rel.SerializedReferenceRelationship != null) { if (!rel.SerializedReferenceRelationship.IsInFullSerialization) { if (System.Windows.MessageBox.Show("Shape mapping has been defined for the ReferenceRelationship '" + rel.Name + "'. The Relationship is not serialized in full form. Would you like to change the serialization of this relationship to full form (strongly adviced)?", "Serialization", System.Windows.MessageBoxButton.YesNo, System.Windows.MessageBoxImage.Question) == System.Windows.MessageBoxResult.Yes) { rel.SerializedReferenceRelationship.IsInFullSerialization = true; } } } } } }
public override void ElementDeleting(ElementDeletingEventArgs e) { if (e.ModelElement != null) { if (e.ModelElement.Store.TransactionManager.CurrentTransaction != null) { if (e.ModelElement.Store.TransactionManager.CurrentTransaction.IsSerializing) { return; } } } if (e.ModelElement == null) { return; } if (ImmutabilityExtensionMethods.GetLocks(e.ModelElement) != Locks.None) { return; } TreeNodeReferencesReferenceRSNodes con = e.ModelElement as TreeNodeReferencesReferenceRSNodes; if (con != null) { ReferenceRSNode rsNode = con.ReferenceRSNode; if (rsNode != null) { ReferenceNode node = rsNode.ReferenceNode; if (node != null) { // since this node still exists, it isnt included in the deletion process // --> move to root node if this node is the element holder, as its parent has been deleted if (node.IsElementHolder) { RootNode rootNode = new RootNode(node.Store); rootNode.DomainElement = node.DomainElement; node.EmbeddingModelTreeViewModel.RootNodes.Add(rootNode); node.EmbeddingModelTreeViewModel.ModelTreeNodes.Add(rootNode); // copy sub tree for (int i = node.EmbeddingRSNodes.Count - 1; i >= 0; i--) { node.EmbeddingRSNodes[i].TreeNode = rootNode; } for (int i = node.ReferenceRSNodes.Count - 1; i >= 0; i--) { node.ReferenceRSNodes[i].TreeNode = rootNode; } for (int i = node.InheritanceNodes.Count - 1; i >= 0; i--) { node.InheritanceNodes[i].TreeNode = rootNode; } for (int i = node.ShapeClassNodes.Count - 1; i >= 0; i--) { node.ShapeClassNodes[i].TreeNode = rootNode; } rootNode.IsElementHolder = true; rootNode.IsEmbeddingTreeExpanded = node.IsEmbeddingTreeExpanded; rootNode.IsExpanded = true; rootNode.IsInheritanceTreeExpanded = node.IsInheritanceTreeExpanded; rootNode.IsReferenceTreeExpanded = node.IsReferenceTreeExpanded; rootNode.IsShapeMappingTreeExpanded = node.IsShapeMappingTreeExpanded; } node.Delete(); } rsNode.Delete(); } } }