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