/// <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 ReferenceRelationship AddNewReferenceRelationship(DomainClass source, AttributedDomainElement target) { // create rs ReferenceRelationship refRel = new ReferenceRelationship(source.Store); source.ModelContext.Relationships.Add(refRel); // create roles DomainRole sourceRole = new DomainRole(source.Store); sourceRole.PropagatesDelete = false; DomainRole targetRole = new DomainRole(source.Store); targetRole.PropagatesDelete = false; sourceRole.RolePlayer = source; targetRole.RolePlayer = target; sourceRole.Opposite = targetRole; targetRole.Opposite = sourceRole; // assign roles to rs refRel.Roles.Add(sourceRole); refRel.Roles.Add(targetRole); refRel.Source = sourceRole; refRel.Target = targetRole; // properties + names if (refRel.Source.RolePlayer.Name == refRel.Target.RolePlayer.Name) { sourceRole.Name = source.Name + "Source"; } else { sourceRole.Name = source.Name; } sourceRole.IsNameTracking = TrackingEnum.IgnoreOnce; if (refRel.Source.RolePlayer.Name == refRel.Target.RolePlayer.Name) { targetRole.Name = target.Name + "Target"; } else { targetRole.Name = target.Name; } targetRole.IsNameTracking = TrackingEnum.IgnoreOnce; refRel.SerializationSourceName = sourceRole.Name + "Ref"; refRel.IsSerializationSourceNameTracking = TrackingEnum.IgnoreOnce; refRel.SerializationTargetName = targetRole.Name + "Ref"; refRel.IsSerializationTargetNameTracking = TrackingEnum.IgnoreOnce; AddNewReferenceRelationship(refRel, source, target); return(refRel); }
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; } } } } } }
private void FinalizeReferenceRelationshipMerge(ModelProtoElement protoElement, ModelProtoGroupMerger groupMerger, bool bCreateSInfo) { ReferenceRelationship refRel = this.Store.ElementDirectory.FindElement(groupMerger.GetIdMapping(protoElement.ElementId)) as ReferenceRelationship; if (bCreateSInfo) { SerializationDomainRelationshipAddRule.OnReferenceRelationshipAdded(refRel); } if (refRel == null) { return; } ModelTreeHelper.AddNewReferenceRelationship(refRel, refRel.Source.RolePlayer as DomainClass, refRel.Target.RolePlayer); }
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(); } } } }
private static void FixUpDerivedRelationships(DomainRelationship domainClass, MetaModel model) { if (domainClass.ModelContext.MetaModel == model) { if (domainClass is EmbeddingRelationship) { EmbeddingRelationship con = domainClass as EmbeddingRelationship; SerializationHelper.UpdateSerializationDomainProperties(domainClass.Store, con.SerializedEmbeddingRelationship, domainClass); } if (domainClass is ReferenceRelationship) { ReferenceRelationship con = domainClass as ReferenceRelationship; SerializationHelper.UpdateSerializationDomainProperties(domainClass.Store, con.SerializedReferenceRelationship, domainClass); } } foreach (DomainRelationship derivedClass in domainClass.DerivedRelationships) { FixUpDerivedRelationships(derivedClass, model); } }
/// <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); }
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; } ReferenceRelationship referenceRelationship = e.ModelElement as ReferenceRelationship; if (referenceRelationship != null) { if (referenceRelationship.ReferenceRSNode != null) { referenceRelationship.ReferenceRSNode.Delete(); } } EmbeddingRelationship embeddingRelationship = e.ModelElement as EmbeddingRelationship; if (embeddingRelationship != null) { if (embeddingRelationship.EmbeddingRSNode != null) { embeddingRelationship.EmbeddingRSNode.Delete(); } } DomainClassReferencesBaseClass inhRelationship = e.ModelElement as DomainClassReferencesBaseClass; if (inhRelationship != null) { InheritanceNode node = inhRelationship.Store.ElementDirectory.FindElement(inhRelationship.InhNodeId) as InheritanceNode; if (node != null) { if (node.IsElementHolder) { RootNode rootNode = new RootNode(node.Store); rootNode.DomainElement = node.DomainElement; rootNode.IsElementHolder = true; rootNode.IsEmbeddingTreeExpanded = node.IsEmbeddingTreeExpanded; rootNode.IsExpanded = true; rootNode.IsInheritanceTreeExpanded = node.IsInheritanceTreeExpanded; rootNode.IsReferenceTreeExpanded = node.IsReferenceTreeExpanded; rootNode.IsShapeMappingTreeExpanded = node.IsShapeMappingTreeExpanded; // 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; } node.DomainElement.ParentModelContext.ViewContext.DomainModelTreeView.RootNodes.Add(rootNode); node.DomainElement.ParentModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(rootNode); } // connection was deleted using the property window and not the menu item, so delete the rs and the // node here //if (inhNode.IsElementHolder) // TreeOperations.SplitTree(inhNode); node.Delete(); } } }
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; } ReferenceRelationship referenceRelationship = e.ModelElement as ReferenceRelationship; if (referenceRelationship != null) { if (referenceRelationship.SerializedReferenceRelationship != null) { referenceRelationship.SerializedReferenceRelationship.Delete(); } if (referenceRelationship.Source != null) { if (referenceRelationship.Source.RolePlayer != null) { SerializationHelper.UpdateDerivedElementsSerializationProperties(referenceRelationship.Source.RolePlayer); SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(referenceRelationship.Source.RolePlayer); } } if (referenceRelationship.Target != null) { if (referenceRelationship.Target.RolePlayer != null) { SerializationHelper.UpdateDerivedElementsSerializationProperties(referenceRelationship.Target.RolePlayer); SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(referenceRelationship.Target.RolePlayer); } } } EmbeddingRelationship embeddingRelationship = e.ModelElement as EmbeddingRelationship; if (embeddingRelationship != null) { if (embeddingRelationship.SerializedEmbeddingRelationship != null) { embeddingRelationship.SerializedEmbeddingRelationship.Delete(); } if (embeddingRelationship.Source != null) { if (embeddingRelationship.Source.RolePlayer != null) { SerializationHelper.UpdateDerivedElementsSerializationProperties(embeddingRelationship.Source.RolePlayer); SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(embeddingRelationship.Source.RolePlayer); } } if (embeddingRelationship.Target != null) { if (embeddingRelationship.Target.RolePlayer != null) { SerializationHelper.UpdateDerivedElementsSerializationProperties(embeddingRelationship.Target.RolePlayer); SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(embeddingRelationship.Target.RolePlayer); } } } DomainClassReferencesBaseClass inhRelationship = e.ModelElement as DomainClassReferencesBaseClass; if (inhRelationship != null) { inhRelationship.DerivedClass.BaseClass = null; SerializationHelper.UpdateDerivedElementsSerializationProperties(inhRelationship.DerivedClass); SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(inhRelationship.DerivedClass); } DomainRelationshipReferencesBaseRelationship inhRelationshipRel = e.ModelElement as DomainRelationshipReferencesBaseRelationship; if (inhRelationshipRel != null) { inhRelationshipRel.DerivedRelationship.BaseRelationship = null; SerializationHelper.UpdateDerivedElementsSerializationProperties(inhRelationshipRel.DerivedRelationship); } }
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; } AttributedDomainElement attributedDomainElement = e.ModelElement as AttributedDomainElement; if (attributedDomainElement != null) { if (attributedDomainElement.IsDeleted || attributedDomainElement.IsDeleting) { return; } if (attributedDomainElement is DomainRelationship) { string name; if (attributedDomainElement is EmbeddingRelationship) { name = EmbeddingRelationship.GenerateDomainRelationshipName((attributedDomainElement as DomainRelationship)); } else { name = ReferenceRelationship.GenerateDomainRelationshipName((attributedDomainElement as DomainRelationship)); } if (attributedDomainElement.Name == "") { attributedDomainElement.Name = name; (attributedDomainElement as DomainRelationship).IsNameTracking = TrackingEnum.IgnoreOnce; } } //if (attributedDomainElement.SerializationName != attributedDomainElement.Name) if (attributedDomainElement.SerializationName == "" || attributedDomainElement.SerializationName == null) { attributedDomainElement.SerializationName = attributedDomainElement.Name; attributedDomainElement.IsSerializationNameTracking = TrackingEnum.IgnoreOnce; } attributedDomainElement.Namespace = attributedDomainElement.ParentModelContext.MetaModel.Namespace; } }
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs 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; } DomainRole domainRole = e.ModelElement as DomainRole; if (domainRole != null) { if (domainRole.IsDeleted || domainRole.IsDeleting) { return; } if (domainRole.Relationship.IsDeleted || domainRole.Relationship.IsDeleting) { return; } if (e.DomainProperty.Id == DomainRole.NameDomainPropertyId) { // display name tracking is already handled by NamedDomainElement if (domainRole.IsNameTracking == TrackingEnum.True) { domainRole.IsNameTracking = TrackingEnum.False; } else if (domainRole.IsNameTracking == TrackingEnum.IgnoreOnce) { domainRole.IsNameTracking = TrackingEnum.True; } if (domainRole.Opposite != null) { if (domainRole.Opposite.IsPropertyNameTracking == TrackingEnum.True) { if (domainRole.Opposite.PropertyName != domainRole.Name) { domainRole.Opposite.PropertyName = domainRole.Name; domainRole.Opposite.IsPropertyNameTracking = TrackingEnum.IgnoreOnce; } } } if (domainRole.Relationship.IsNameTracking == TrackingEnum.True) { string name; if (domainRole.Relationship is EmbeddingRelationship) { name = EmbeddingRelationship.GenerateDomainRelationshipName(domainRole.Relationship); } else { name = ReferenceRelationship.GenerateDomainRelationshipName(domainRole.Relationship); } if (domainRole.Relationship.Name != name) { domainRole.Relationship.Name = name; domainRole.Relationship.IsNameTracking = TrackingEnum.IgnoreOnce; } } if (domainRole.Relationship is ReferenceRelationship) { ReferenceRelationship r = domainRole.Relationship as ReferenceRelationship; if (domainRole == domainRole.Relationship.Source) { if (r.IsSerializationSourceNameTracking == TrackingEnum.True) { string name = domainRole.Name + "Ref"; if (domainRole.Name == domainRole.Opposite.Name) { name = domainRole.Name + "Source" + "Ref"; } if (name != r.SerializationSourceName) { r.SerializationSourceName = name; r.IsSerializationSourceNameTracking = TrackingEnum.IgnoreOnce; } } } else { if (r.IsSerializationTargetNameTracking == TrackingEnum.True) { string name = domainRole.Name + "Ref"; if (domainRole.Name == domainRole.Opposite.Name) { name = domainRole.Name + "Target" + "Ref"; } if (name != r.SerializationTargetName) { r.SerializationTargetName = name; r.IsSerializationTargetNameTracking = TrackingEnum.IgnoreOnce; } } } } } else if (e.DomainProperty.Id == DomainRole.PropertyNameDomainPropertyId) { if (domainRole.IsPropertyNameTracking == TrackingEnum.True) { domainRole.IsPropertyNameTracking = TrackingEnum.False; } else if (domainRole.IsPropertyNameTracking == TrackingEnum.IgnoreOnce) { domainRole.IsPropertyNameTracking = TrackingEnum.True; } if (domainRole.IsPropertyDisplayNameTracking == TrackingEnum.True) { if (domainRole.PropertyDisplayName != StringHelper.BreakUpper(domainRole.PropertyName)) { domainRole.PropertyDisplayName = StringHelper.BreakUpper(domainRole.PropertyName); domainRole.IsPropertyDisplayNameTracking = TrackingEnum.IgnoreOnce; } } } else if (e.DomainProperty.Id == DomainRole.PropertyDisplayNameDomainPropertyId) { if (domainRole.IsPropertyDisplayNameTracking == TrackingEnum.True) { domainRole.IsPropertyDisplayNameTracking = TrackingEnum.False; } else if (domainRole.IsPropertyDisplayNameTracking == TrackingEnum.IgnoreOnce) { domainRole.IsPropertyDisplayNameTracking = TrackingEnum.True; } } } }
private static void FixUpSerializedDomainModel(ModelContext model) { foreach (DomainClass domainClass in model.Classes) { if (domainClass.IsDomainModel) { SerializedDomainModel child = new SerializedDomainModel(domainClass.Store); child.DomainClass = domainClass; child.SerializationName = domainClass.SerializationName; model.SerializationModel.SerializedDomainModel = child; SerializationHelper.AddSerializationDomainProperties(domainClass.Store, domainClass); } else { SerializationDomainClassAddRule.OnDomainClassAdded(domainClass); domainClass.SerializedDomainClass.SerializationName = domainClass.SerializationName; } } foreach (DomainRelationship relationship in model.Relationships) { if (relationship is EmbeddingRelationship) { SerializationDomainRelationshipAddRule.OnEmbeddingRelationshipAdded(relationship as EmbeddingRelationship); (relationship as EmbeddingRelationship).SerializedEmbeddingRelationship.SerializationName = relationship.SerializationName; } else { SerializationDomainRelationshipAddRule.OnReferenceRelationshipAdded(relationship as ReferenceRelationship); (relationship as ReferenceRelationship).SerializedReferenceRelationship.SerializationName = relationship.SerializationName; } } foreach (DomainClass domainClass in model.Classes) { SerializationHelper.UpdateSerializationDomainProperties(domainClass.Store, domainClass.SerializedDomainClass, domainClass); SerializationHelper.UpdateSerializationDomainRoles(domainClass.Store, domainClass.SerializedDomainClass, domainClass); foreach (DomainProperty p in domainClass.Properties) { p.SerializedDomainProperty.IsSerializationNameTracking = TrackingEnum.True; } } foreach (DomainRelationship relationship in model.Relationships) { if (relationship is EmbeddingRelationship) { SerializationHelper.UpdateSerializationDomainProperties(relationship.Store, (relationship as EmbeddingRelationship).SerializedEmbeddingRelationship, relationship); } else { SerializationHelper.UpdateSerializationDomainProperties(relationship.Store, (relationship as ReferenceRelationship).SerializedReferenceRelationship, relationship); } foreach (DomainProperty p in relationship.Properties) { p.SerializedDomainProperty.IsSerializationNameTracking = TrackingEnum.True; } } // correct IsSerializationNameTracking values foreach (DomainClass domainClass in model.Classes) { if (domainClass.SerializationName != domainClass.Name) { domainClass.IsSerializationNameTracking = TrackingEnum.False; } domainClass.SerializedDomainClass.IsSerializationNameTracking = domainClass.IsSerializationNameTracking; foreach (DomainProperty p in domainClass.Properties) { if (p.Name != p.SerializationName) { p.IsSerializationNameTracking = TrackingEnum.False; } p.SerializedDomainProperty.IsSerializationNameTracking = p.IsSerializationNameTracking; if (p.Name == "DomainFilePath") { p.SerializedDomainProperty.OmitProperty = true; } } } foreach (DomainRelationship relationship in model.Relationships) { if (relationship is EmbeddingRelationship) { EmbeddingRelationship emb = relationship as EmbeddingRelationship; if (emb.SerializationName != emb.Name) { emb.IsSerializationNameTracking = TrackingEnum.False; } emb.SerializedEmbeddingRelationship.IsSerializationNameTracking = emb.IsSerializationNameTracking; } else { ReferenceRelationship refRel = relationship as ReferenceRelationship; if (refRel.SerializationName != refRel.Name) { refRel.IsSerializationNameTracking = TrackingEnum.False; } refRel.SerializedReferenceRelationship.IsSerializationNameTracking = refRel.IsSerializationNameTracking; } foreach (DomainProperty p in relationship.Properties) { if (p.Name != p.SerializationName) { p.IsSerializationNameTracking = TrackingEnum.True; } p.SerializedDomainProperty.IsSerializationNameTracking = p.IsSerializationNameTracking; } } }
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; } DomainClassReferencesBaseClass con = e.ModelElement as DomainClassReferencesBaseClass; if (con != null) { if (con.BaseClass != null) { InheritanceNode inhNode = con.Store.ElementDirectory.FindElement(con.InhNodeId) as InheritanceNode; if (inhNode == null && ImmutabilityExtensionMethods.GetLocks(con.BaseClass) == Locks.None) { // connection was created using the property window and not the menu item, so create a new // inheritance node to display the inheritance relationship TreeNode elementHolderNode = null; foreach (TreeNode node in con.BaseClass.DomainModelTreeNodes) { if (node.IsElementHolder) { elementHolderNode = node; break; } } if (elementHolderNode == null) { throw new ArgumentNullException("elementHolderNode"); } // create new inheritance node inhNode = new InheritanceNode(con.Store); inhNode.DomainElement = con.DerivedClass; inhNode.IsElementHolder = false; inhNode.IsExpanded = false; inhNode.InhRelationshipId = con.Id; con.InhNodeId = inhNode.Id; elementHolderNode.InheritanceNodes.Add(inhNode); con.DerivedClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(inhNode); } } } DomainRelationshipReferencesBaseRelationship conRef = e.ModelElement as DomainRelationshipReferencesBaseRelationship; if (conRef != null) { if (conRef.BaseRelationship is ReferenceRelationship && conRef.DerivedRelationship is ReferenceRelationship) { ReferenceRelationship rBase = conRef.BaseRelationship as ReferenceRelationship; ReferenceRelationship rDer = conRef.DerivedRelationship as ReferenceRelationship; if (rBase.SerializedReferenceRelationship != null && rDer.SerializedReferenceRelationship != null) { if (rBase.SerializedReferenceRelationship.IsInFullSerialization) { if (!rDer.SerializedReferenceRelationship.IsInFullSerialization) { // we have to automatically change the serialization mode of the derived class to full serialization mode rDer.SerializedReferenceRelationship.IsInFullSerialization = true; } } } } else if (conRef.BaseRelationship is EmbeddingRelationship && conRef.DerivedRelationship is EmbeddingRelationship) { EmbeddingRelationship rBase = conRef.BaseRelationship as EmbeddingRelationship; EmbeddingRelationship rDer = conRef.DerivedRelationship as EmbeddingRelationship; if (rBase.SerializedEmbeddingRelationship != null && rDer.SerializedEmbeddingRelationship != null) { if (rBase.SerializedEmbeddingRelationship.IsInFullSerialization) { if (!rDer.SerializedEmbeddingRelationship.IsInFullSerialization) { // we have to automatically change the serialization mode of the derived class to full serialization mode rDer.SerializedEmbeddingRelationship.IsInFullSerialization = true; } } } } } }
public void ValidateDomainClass(ValidationContext context) { List <DomainRole> embeddingRoles = new List <DomainRole>(); List <string> names = new List <string>(); List <string> refRSTargetSerializationNames = new List <string>(); bool bLogEmbedded = false; foreach (DomainRole role in this.RolesPlayed) { if (!role.IsPropertyGenerator) { continue; } if (names.Contains(role.PropertyName)) { context.LogError("PropertyName of Relationship " + role.Relationship.Name + " on " + this.Name + " is already used and needs to be altered.", "PropertyNameAlreadyUsed", null); //this); } else { names.Add(role.PropertyName); } if (role.Relationship is EmbeddingRelationship && role.Relationship.Target.RolePlayer == this) { embeddingRoles.Add(role); if (role.Multiplicity == Multiplicity.One || role.Multiplicity == Multiplicity.OneMany) { bLogEmbedded = true; } } if (role.Relationship is ReferenceRelationship) { if (role.Relationship.Source == role) { ReferenceRelationship r = role.Relationship as ReferenceRelationship; if (r.SerializedReferenceRelationship != null) { if (!r.SerializedReferenceRelationship.IsInFullSerialization) { if (refRSTargetSerializationNames.Contains(r.SerializationTargetName)) { context.LogError("SerializationTargetName of Relationship " + role.Relationship.Name + " on " + this.Name + " is already used and needs to be altered.", "PropertyNameAlreadyUsed", null); //this); } else { refRSTargetSerializationNames.Add(r.SerializationTargetName); } } } } } } if (bLogEmbedded && embeddingRoles.Count > 1) { string message = "The domain class " + this.Name + " is embedded at multiple places. The following relationships need to have their target role multiplicities set to '0:1' or '0:n' :"; foreach (DomainRole role in embeddingRoles) { message += role.Relationship.Name + "; "; } context.LogError(message, "", null); } List <string> shapeNames = new List <string>(); foreach (PresentationElementClass shape in this.ShapeClasses) { if (shape is ShapeClass) { if ((shape as ShapeClass).UseInDependencyView) { shapeNames.Add(shape.Name); } } } if (shapeNames.Count > 1) { string message = "The domain class " + this.Name + " has multiple shape classes with UseInDependencyView='true' :"; foreach (string n in shapeNames) { message += n + "; "; } context.LogError(message, "", null); } }
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; } if (e.ModelElement.IsDeleting || e.ModelElement.IsDeleted) { return; } ReferenceRelationship referenceRelationship = e.ModelElement as ReferenceRelationship; if (referenceRelationship != null) { if (referenceRelationship.SerializedReferenceRelationship == null) { OnReferenceRelationshipAdded(referenceRelationship); } } EmbeddingRelationship embeddingRelationship = e.ModelElement as EmbeddingRelationship; if (embeddingRelationship != null) { if (embeddingRelationship.SerializedEmbeddingRelationship == null) { OnEmbeddingRelationshipAdded(embeddingRelationship); } } DomainClassReferencesBaseClass inhRelationship = e.ModelElement as DomainClassReferencesBaseClass; if (inhRelationship != null) { SerializationHelper.UpdateDerivedElementsSerializationProperties(inhRelationship.DerivedClass); SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(inhRelationship.DerivedClass); } DomainRelationshipReferencesBaseRelationship inhRelationshipRel = e.ModelElement as DomainRelationshipReferencesBaseRelationship; if (inhRelationshipRel != null) { // update derived properties SerializationHelper.UpdateDerivedElementsSerializationProperties(inhRelationshipRel.DerivedRelationship); } }
public static void PostProcessModelLoad(MetaModel model) { // package and custom editor GUIDs if (model.PackageGuid == null || model.PackageGuid == Guid.Empty) { model.PackageGuid = Guid.NewGuid(); } if (model.CustomExtensionGuid == null || model.CustomExtensionGuid == Guid.Empty) { model.CustomExtensionGuid = Guid.NewGuid(); } #region relationship targets fixup ReadOnlyCollection <DomainRelationship> rels = model.AllRelationships; foreach (DomainRelationship rel in rels) { if (rel.Target.RolePlayer == null) { ReferenceRelationship referenceRelationship = rel as ReferenceRelationship; if (referenceRelationship != null) { if (referenceRelationship.ReferenceRSNode != null) { referenceRelationship.ReferenceRSNode.Delete(); } if (referenceRelationship.SerializedReferenceRelationship != null) { referenceRelationship.SerializedReferenceRelationship.Delete(); } } EmbeddingRelationship embeddingRelationship = rel as EmbeddingRelationship; if (embeddingRelationship != null) { if (embeddingRelationship.EmbeddingRSNode != null) { embeddingRelationship.EmbeddingRSNode.Delete(); } if (embeddingRelationship.SerializedEmbeddingRelationship != null) { embeddingRelationship.SerializedEmbeddingRelationship.Delete(); } } rel.Delete(); } } #endregion #region inconsistent serialization elements foreach (BaseModelContext context in model.ModelContexts) { if (context is LibraryModelContext) { LibraryModelContext lib = context as LibraryModelContext; if (lib.SerializationModel != null) { for (int i = lib.SerializationModel.Children.Count - 1; i >= 0; i--) { SerializationClass c = lib.SerializationModel.Children[i]; if (c is SerializedDomainClass) { SerializedDomainClass s = c as SerializedDomainClass; if (s.DomainClass == null) { s.Delete(); } continue; } else if (c is SerializedEmbeddingRelationship) { SerializedEmbeddingRelationship s = c as SerializedEmbeddingRelationship; if (s.EmbeddingRelationship == null) { s.Delete(); } continue; } else if (c is SerializedReferenceRelationship) { SerializedReferenceRelationship s = c as SerializedReferenceRelationship; if (s.ReferenceRelationship == null) { s.Delete(); } continue; } // element has not been deleted, see if its properties are ok for (int y = c.Properties.Count - 1; y >= 0; y--) { if (c.Properties[y] == null) { c.Properties[y].Delete(); } } } } } } #endregion #region derived classes serialization items fixup if (model.MetaModelLibraries.Count > 0) { ReadOnlyCollection <ModelElement> elements = model.Store.ElementDirectory.FindElements(DomainClassReferencesBaseClass.DomainClassId); foreach (ModelElement m in elements) { DomainClassReferencesBaseClass con = m as DomainClassReferencesBaseClass; if (con != null) { if (con.BaseClass != null) { if (con.BaseClass.ModelContext.MetaModel != model) { foreach (DomainClass derivedClass in con.BaseClass.DerivedClasses) { FixUpDerivedClasses(derivedClass, model); } } } } } ReadOnlyCollection <ModelElement> elementsCon = model.Store.ElementDirectory.FindElements(DomainRelationshipReferencesBaseRelationship.DomainClassId); foreach (ModelElement m in elementsCon) { DomainRelationshipReferencesBaseRelationship con = m as DomainRelationshipReferencesBaseRelationship; if (con != null) { if (con.BaseRelationship != null) { if (con.BaseRelationship.ModelContext.MetaModel != model) { foreach (DomainRelationship derivedClass in con.BaseRelationship.DerivedRelationships) { FixUpDerivedRelationships(derivedClass, model); } } } } } } #endregion #region check if model contains all required elements // property grid editors if (model.PropertyGridEditors.Count == 0) { FixUpPropertyGridEditors(model); } // domain types if (model.DomainTypes.Count == 0) { FixUpDomainTypes(model); } // model context if (model.ModelContexts.Count == 0) { FixUpModelContext(model); } // validation if (model.Validation == null) { model.Validation = new Validation(model.Store); } if (model.View == null) { model.View = new View(model.Store); } if (model.View.ModelTree == null) { model.View.ModelTree = new ModelTree(model.Store); } foreach (BaseModelContext mContext in model.ModelContexts) { if (mContext is LibraryModelContext) { LibraryModelContext m = mContext as LibraryModelContext; if (m.DiagramClasses.Count == 0 && m is ModelContext) { DesignerDiagramClass ddC = new DesignerDiagramClass(model.Store); ddC.Name = "DesignerDiagram"; ddC.Title = "Designer"; m.DiagramClasses.Add(ddC); } if (m.ViewContext == null) { m.ViewContext = new ViewContext(model.Store); m.ViewContext.DomainModelTreeView = new DomainModelTreeView(model.Store); m.ViewContext.DiagramView = new DiagramView(model.Store); model.View.ViewContexts.Add(m.ViewContext); FixUpDomainModelTreeView(m); FixUpDiagramView(m); } if (m.ViewContext.DiagramView == null || m.ViewContext.DomainModelTreeView == null) { if (m.ViewContext.DomainModelTreeView == null) { m.ViewContext.DomainModelTreeView = new DomainModelTreeView(model.Store); FixUpDomainModelTreeView(m); } if (m.ViewContext.DiagramView == null) { m.ViewContext.DiagramView = new DiagramView(model.Store); FixUpDiagramView(m); } } // diagram class view for designer diagram if (m.ViewContext.DiagramView.DiagramClassViews.Count == 0 && m is ModelContext) { DiagramClassView vm = new DiagramClassView(model.Store); vm.IsExpanded = true; foreach (DiagramClass d in m.DiagramClasses) { if (d is DesignerDiagramClass) { vm.DiagramClass = d; break; } } m.ViewContext.DiagramView.DiagramClassViews.Add(vm); } // serialization if (m.SerializationModel == null) { m.SerializationModel = new SerializationModel(model.Store); } // serialized domain model if (m is ModelContext) { if (m.SerializationModel.SerializedDomainModel == null) { FixUpSerializedDomainModel(m as ModelContext); } } } } #endregion // view ids. if (model.View != null) { if (model.View.ModelTreeId == null || model.View.ModelTreeId == Guid.Empty) { model.View.ModelTreeId = Guid.NewGuid(); } if (model.View.DependenciesViewId == null || model.View.DependenciesViewId == Guid.Empty) { model.View.DependenciesViewId = Guid.NewGuid(); } if (model.View.ErrorListId == null || model.View.ErrorListId == Guid.Empty) { model.View.ErrorListId = Guid.NewGuid(); } if (model.View.PropertyGridId == null || model.View.PropertyGridId == Guid.Empty) { model.View.PropertyGridId = Guid.NewGuid(); } if (model.View.SearchId == null || model.View.SearchId == Guid.Empty) { model.View.SearchId = Guid.NewGuid(); } if (model.View.SearchResultId == null || model.View.SearchResultId == Guid.Empty) { model.View.SearchResultId = Guid.NewGuid(); } if (model.View.PluginWindowId == null || model.View.PluginWindowId == Guid.Empty) { model.View.PluginWindowId = Guid.NewGuid(); } } }
public override void ElementPropertyChanged(ElementPropertyChangedEventArgs 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; } ReferenceRelationship referenceRelationship = e.ModelElement as ReferenceRelationship; if (referenceRelationship != null) { if (e.DomainProperty.Id == ReferenceRelationship.SerializationNameDomainPropertyId) { SerializedReferenceRelationship c = referenceRelationship.SerializedReferenceRelationship; if (c.SerializationName != referenceRelationship.SerializationName) { c.SerializationName = referenceRelationship.SerializationName; if (referenceRelationship.IsSerializationNameTracking != TrackingEnum.False) { c.IsSerializationNameTracking = TrackingEnum.IgnoreOnce; } else { c.IsSerializationNameTracking = TrackingEnum.False; } } } else if (e.DomainProperty.Id == ReferenceRelationship.SerializationAttributeNameDomainPropertyId) { SerializedReferenceRelationship r = referenceRelationship.SerializedReferenceRelationship; foreach (SerializedDomainRole domainRole in r.SerializedDomainRoles) { domainRole.SerializationAttributeName = referenceRelationship.SerializationAttributeName; } } else if (e.DomainProperty.Id == ReferenceRelationship.SerializationSourceNameDomainPropertyId) { if (referenceRelationship.IsSerializationSourceNameTracking == TrackingEnum.True) { referenceRelationship.IsSerializationSourceNameTracking = TrackingEnum.False; } else if (referenceRelationship.IsSerializationSourceNameTracking == TrackingEnum.IgnoreOnce) { referenceRelationship.IsSerializationSourceNameTracking = TrackingEnum.True; } foreach (SerializedDomainRole r in referenceRelationship.Source.SerializedDomainRoles) { r.SerializationName = referenceRelationship.SerializationSourceName; } } else if (e.DomainProperty.Id == ReferenceRelationship.SerializationTargetNameDomainPropertyId) { if (referenceRelationship.IsSerializationTargetNameTracking == TrackingEnum.True) { referenceRelationship.IsSerializationTargetNameTracking = TrackingEnum.False; } else if (referenceRelationship.IsSerializationTargetNameTracking == TrackingEnum.IgnoreOnce) { referenceRelationship.IsSerializationTargetNameTracking = TrackingEnum.True; } foreach (SerializedDomainRole r in referenceRelationship.Target.SerializedDomainRoles) { r.SerializationName = referenceRelationship.SerializationTargetName; } } } }
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 static void OnReferenceRelationshipAdded(ReferenceRelationship referenceRelationship) { #region Check Paramaters if (referenceRelationship.Source == null) { throw new ArgumentNullException("referenceRelationship.Source"); } if (referenceRelationship.Target == null) { throw new ArgumentNullException("referenceRelationship.Target"); } if (!(referenceRelationship.Source.RolePlayer is DomainClass)) { throw new ArgumentNullException("referenceRelationship.Source.RolePlayer needs to be DomainClass"); } if (!(referenceRelationship.Target.RolePlayer is DomainClass) && !(referenceRelationship.Target.RolePlayer is ReferenceRelationship)) { throw new ArgumentNullException("referenceRelationship.Target.RolePlayer needs to be DomainClass or ReferenceRelationship"); } #endregion // Add properties and id attribute and set serialization form. SerializedReferenceRelationship child = new SerializedReferenceRelationship(referenceRelationship.Store); child.ReferenceRelationship = referenceRelationship; if (referenceRelationship.NeedsFullSerialization()) { child.IsInFullSerialization = true; } else { child.IsInFullSerialization = false; } child.SerializationName = referenceRelationship.SerializationName; SerializationHelper.AddSerializationDomainProperties(referenceRelationship.Store, referenceRelationship); referenceRelationship.ModelContext.SerializationModel.Children.Add(child); SerializationClass domainClassSource = (referenceRelationship.Source.RolePlayer as DomainClass).SerializedDomainClass; domainClassSource.Children.Add(child); // Add roles players. SerializedDomainRole roleSource = new SerializedDomainRole(referenceRelationship.Store); roleSource.DomainRole = referenceRelationship.Source; roleSource.SerializationAttributeName = referenceRelationship.SerializationAttributeName; roleSource.SerializationName = referenceRelationship.SerializationSourceName; child.Children.Add(roleSource); SerializedDomainRole roleTarget = new SerializedDomainRole(referenceRelationship.Store); roleTarget.DomainRole = referenceRelationship.Target; roleTarget.SerializationAttributeName = referenceRelationship.SerializationAttributeName; roleTarget.SerializationName = referenceRelationship.SerializationTargetName; child.Children.Add(roleTarget); child.SerializedDomainRoles.Add(roleSource); child.SerializedDomainRoles.Add(roleTarget); // update derived roles SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(referenceRelationship.Source.RolePlayer); }
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; } } } } }