{ /// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="serializedRelationship">SerializedRelationship.</param>
/// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param>
public SerializedReferenceRelationshipViewModel(ViewModelStore viewModelStore, SerializedReferenceRelationship serializedRelationship, SerializationClassViewModel parent)
: base(viewModelStore, serializedRelationship, serializedRelationship.ReferenceRelationship, parent)
{
if( this.SerializationElement != null )
if (this.SerializationElement.ReferenceRelationship != null)
this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.SerializationElement.ReferenceRelationship.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializedReferenceRelationshipPropertyChanged));
}
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;
}
SerializedReferenceRelationship serializedReferenceRelationship = e.ModelElement as SerializedReferenceRelationship;
if (serializedReferenceRelationship != null)
{
if (serializedReferenceRelationship.IsSerializationNameTracking == TrackingEnum.True)
{
serializedReferenceRelationship.IsSerializationNameTracking = TrackingEnum.False;
}
else if (serializedReferenceRelationship.IsSerializationNameTracking == TrackingEnum.IgnoreOnce)
{
serializedReferenceRelationship.IsSerializationNameTracking = TrackingEnum.True;
}
if (serializedReferenceRelationship.ReferenceRelationship.SerializationName != serializedReferenceRelationship.SerializationName)
{
serializedReferenceRelationship.ReferenceRelationship.SerializationName = serializedReferenceRelationship.SerializationName;
serializedReferenceRelationship.ReferenceRelationship.IsSerializationNameTracking = serializedReferenceRelationship.IsSerializationNameTracking;
}
}
}
/// <summary>
/// Updates the domain roles of the given element. (Roles from derived elements are included here).
/// </summary>
/// <param name="store">Store containing the domain model.</param>
/// <param name="serializationElement"></param>
/// <param name="domainClass"></param>
public static void UpdateSerializationDomainRoles(Store store, SerializedDomainClass serializationElement, DomainClass domainClass)
{
if (serializationElement == null || domainClass == null)
{
return;
}
//if (!serializationElement.DomainClass.ParentModelContext.MetaModel.IsTopMost)
// return;
List <SerializationElement> handledRS = new List <SerializationElement>();
// get roles
DomainClass temp = domainClass;
SerializedDomainClass tempElement = serializationElement;
while (temp != null && tempElement != null)
{
foreach (SerializationElement sP in tempElement.Children)
{
if (sP is SerializedReferenceRelationship || sP is SerializedEmbeddingRelationship)
{
// see whether the relationship is abstract or not. If it is abstract, than we dont
// need to add its role players
DomainRelationship relationship = null;
SerializedReferenceRelationship s = sP as SerializedReferenceRelationship;
if (s != null)
{
relationship = s.ReferenceRelationship;
if (s.ReferenceRelationship.InheritanceModifier == InheritanceModifier.Abstract && s.ReferenceRelationship.Source.RolePlayer != domainClass)
{
continue;
}
}
SerializedEmbeddingRelationship sE = sP as SerializedEmbeddingRelationship;
if (sE != null)
{
relationship = sE.EmbeddingRelationship;
if (sE.EmbeddingRelationship.InheritanceModifier == InheritanceModifier.Abstract && sE.EmbeddingRelationship.Source.RolePlayer != domainClass)
{
continue;
}
}
// see if the current element is still active
bool bActive = false;
foreach (DomainRole role in temp.RolesPlayed)
{
if (role.Relationship.Source == role && role.Relationship == relationship)
{
bActive = true;
continue;
}
}
if (!bActive)
{
continue;
}
handledRS.Add(sP);
if (tempElement != serializationElement)
{
// see if we already have this element embedded
bool bAdd = true;
foreach (SerializationElement elem in serializationElement.Children)
{
if (elem == sP)
{
bAdd = false;
break;
}
}
if (bAdd)
{
serializationElement.Children.Add(sP);
}
}
}
}
temp = temp.BaseClass;
if (temp != null)
{
tempElement = temp.SerializedDomainClass;
}
else
{
tempElement = null;
}
}
// remove unneded rs
List <SerializationElement> toRemove = new List <SerializationElement>();
foreach (SerializationElement sP in serializationElement.Children)
{
if (sP is SerializedReferenceRelationship || sP is SerializedEmbeddingRelationship)
{
if (!handledRS.Contains(sP))
{
toRemove.Add(sP);
}
}
}
foreach (SerializationElement sP in toRemove)
{
serializationElement.Children.Remove(sP);
}
}
public override void ModelProcessMergeCopy(CopyPaste.ModelProtoElement protoElement, CopyPaste.ModelProtoGroup protoGroup)
{
base.ModelProcessMergeCopy(protoElement, protoGroup);
// copy rs and target elements if required
if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyEmbeddingTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyReferenceTree)
{
foreach (DomainRole role in this.RolesPlayed)
{
if (role.Relationship is EmbeddingRelationship && role.Relationship.Source == role)
{
if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyEmbeddingTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree)
{
ModelProtoElement e = (role.Relationship as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
protoGroup.AddNewRootElement(e);
// continue with target element
if (ImmutabilityExtensionMethods.GetLocks(role.Relationship.Target.RolePlayer) == Locks.None)
{
if (!protoGroup.HasProtoElementFor(role.Relationship.Target.RolePlayer.Id, this.Partition))
{
ModelProtoElement d = (role.Relationship.Target.RolePlayer as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
protoGroup.InsertNewRootElement(d, 0);
}
}
}
}
else if (role.Relationship is ReferenceRelationship && role.Relationship.Source == role)
{
if (CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyAllTree ||
CopyPaste.CopyAndPasteOperations.Operation == CopyPaste.CopyAndPasteOperation.CopyReferenceTree)
{
ModelProtoElement e = (role.Relationship as IModelMergeElements).ModelCreateMergeCopy(protoGroup);
protoGroup.AddNewRootElement(e);
}
}
}
// sort proto elements: bring domain classes to the top
protoGroup.SortProtoElements(SortProtoElements);
}
// copy order of attributes and children
DomainClassSerializationInfo info = new DomainClassSerializationInfo(
this.SerializedDomainClass.Children.Count,
this.SerializedDomainClass.Attributes.Count);
for (int i = 0; i < this.SerializedDomainClass.Attributes.Count; i++)
{
SerializationAttributeElement aatr = this.SerializedDomainClass.Attributes[i];
if (aatr is SerializedDomainProperty)
{
SerializedDomainProperty sP = aatr as SerializedDomainProperty;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sP.DomainProperty.Name, sP.DomainProperty.Id);
if (sP.OmitProperty)
{
sInfo.OmitElement = true;
}
info.AttributesOrder.Add(sInfo);
}
else if (aatr is SerializedIdProperty)
{
SerializedIdProperty sI = aatr as SerializedIdProperty;
ElementSerializationInfo sInfo = new ElementSerializationInfo("SerializedIdProperty", Guid.Empty);
if (sI.OmitIdProperty)
{
sInfo.OmitElement = true;
}
info.AttributesOrder.Add(sInfo);
}
}
for (int i = 0; i < this.SerializedDomainClass.Children.Count; i++)
{
SerializationElement sE = this.SerializedDomainClass.Children[i];
if (sE is SerializedReferenceRelationship)
{
SerializedReferenceRelationship sDomainRel = sE as SerializedReferenceRelationship;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sDomainRel.ReferenceRelationship.Name, sDomainRel.ReferenceRelationship.Id);
if (sDomainRel.OmitRelationship)
{
sInfo.OmitElement = true;
}
info.ChildrenOrder.Add(sInfo);
}
else if (sE is SerializedEmbeddingRelationship)
{
SerializedEmbeddingRelationship sDomainRel = sE as SerializedEmbeddingRelationship;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sDomainRel.EmbeddingRelationship.Name, sDomainRel.EmbeddingRelationship.Id);
if (sDomainRel.OmitRelationship)
{
sInfo.OmitElement = true;
}
info.ChildrenOrder.Add(sInfo);
}
else if (sE is SerializedDomainProperty)
{
SerializedDomainProperty sP = sE as SerializedDomainProperty;
ElementSerializationInfo sInfo = new ElementSerializationInfo(
sP.DomainProperty.Name, sP.DomainProperty.Id);
if (sP.OmitProperty)
{
sInfo.OmitElement = true;
}
info.ChildrenOrder.Add(sInfo);
}
}
protoElement.CustomArguments = info;
}
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);
}
public static void SetLocks(MetaModel metaModel, Locks locks)
{
if (metaModel == null)
{
return;
}
ImmutabilityExtensionMethods.SetLocks(metaModel, locks);
foreach (PropertyGridEditor p in metaModel.PropertyGridEditors)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
}
foreach (DomainType p in metaModel.DomainTypes)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
}
foreach (BaseModelContext p in metaModel.ModelContexts)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
if (p is LibraryModelContext)
{
foreach (DiagramClass d in (p as LibraryModelContext).DiagramClasses)
{
ImmutabilityExtensionMethods.SetLocks(d, locks);
foreach (PresentationElementClass pe in d.PresentationElements)
{
ImmutabilityExtensionMethods.SetLocks(pe, locks);
}
}
LibraryModelContext lib = p as LibraryModelContext;
if (lib.SerializationModel != null)
{
ImmutabilityExtensionMethods.SetLocks(lib.SerializationModel, locks);
foreach (SerializationClass s in lib.SerializationModel.Children)
{
if (s == null)
{
continue;
}
ImmutabilityExtensionMethods.SetLocks(s, locks);
foreach (SerializationAttributeElement attr in s.Attributes)
{
if (attr != null)
{
ImmutabilityExtensionMethods.SetLocks(attr, locks);
}
}
foreach (SerializationElement element in s.Children)
{
if (element is SerializationAttributeElement)
{
ImmutabilityExtensionMethods.SetLocks(element, locks);
}
}
if (s is SerializedReferenceRelationship)
{
SerializedReferenceRelationship sRef = s as SerializedReferenceRelationship;
foreach (SerializedDomainRole role in sRef.SerializedDomainRoles)
{
ImmutabilityExtensionMethods.SetLocks(role, locks);
}
}
}
}
}
}
if (metaModel.AdditionalInformation != null)
{
ImmutabilityExtensionMethods.SetLocks(metaModel.AdditionalInformation, locks);
if (metaModel.AdditionalInformation.FurtherInformation != null)
{
ImmutabilityExtensionMethods.SetLocks(metaModel.AdditionalInformation.FurtherInformation, locks);
foreach (InformationItem p in metaModel.AdditionalInformation.FurtherInformation.InformationItems)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
}
}
if (metaModel.AdditionalInformation.Credits != null)
{
ImmutabilityExtensionMethods.SetLocks(metaModel.AdditionalInformation.Credits, locks);
foreach (CreditItem p in metaModel.AdditionalInformation.Credits.CreditItems)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
}
}
}
foreach (DomainClass p in metaModel.AllClasses)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
foreach (DomainProperty prop in p.Properties)
{
ImmutabilityExtensionMethods.SetLocks(prop, locks);
}
}
foreach (DomainRelationship p in metaModel.AllRelationships)
{
ImmutabilityExtensionMethods.SetLocks(p, locks);
foreach (DomainProperty prop in p.Properties)
{
ImmutabilityExtensionMethods.SetLocks(prop, locks);
}
foreach (DomainRole prop in p.Roles)
{
ImmutabilityExtensionMethods.SetLocks(prop, locks);
}
}
if (metaModel.Validation != null)
{
ImmutabilityExtensionMethods.SetLocks(metaModel.Validation, locks);
}
}
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();
}
}
}
private void FinalizeDomainClassMerge(ModelProtoElement protoElement, ModelProtoGroupMerger groupMerger)
{
DomainClass domainClass = this.Store.ElementDirectory.FindElement(groupMerger.GetIdMapping(protoElement.ElementId)) as DomainClass;
if (domainClass == null)
{
return;
}
if (protoElement.CustomArguments != null)
{
if (protoElement.CustomArguments is DomainClassSerializationInfo)
{
DomainClassSerializationInfo info = (DomainClassSerializationInfo)protoElement.CustomArguments;
if (info != null)
{
for (int i = 0; i < info.AttributesOrder.Count; i++)
{
#region Attributes
ElementSerializationInfo eInfo = info.AttributesOrder[i] as ElementSerializationInfo;
Guid newId = Guid.Empty;
if (eInfo.ElementName != "SerializedIdProperty")
{
try
{
newId = groupMerger.GetIdMapping(eInfo.ElementId);
}
catch
{
newId = Guid.Empty;
}
if (newId == Guid.Empty)
{
ModelElement m = this.Store.ElementDirectory.FindElement(eInfo.ElementId);
if (m != null)
{
newId = m.Id;
}
}
}
for (int y = 0; y < domainClass.SerializedDomainClass.Attributes.Count; y++)
{
if (domainClass.SerializedDomainClass.Attributes[y] is SerializedIdProperty && eInfo.ElementName == "SerializedIdProperty")
{
(domainClass.SerializedDomainClass.Attributes[y] as SerializedIdProperty).OmitIdProperty = eInfo.OmitElement;
if (y != i)
{
domainClass.SerializedDomainClass.Attributes.Move(y, i);
}
break;
}
else if (eInfo.ElementName != "SerializedIdProperty" && !(domainClass.SerializedDomainClass.Attributes[y] is SerializedIdProperty))
{
SerializedDomainProperty p = domainClass.SerializedDomainClass.Attributes[y] as SerializedDomainProperty;
p.OmitProperty = eInfo.OmitElement;
if (p.DomainProperty.Id == newId && y != i)
{
domainClass.SerializedDomainClass.Attributes.Move(y, i);
break;
}
}
}
#endregion
}
for (int i = 0; i < info.ChildrenOrder.Count; i++)
{
#region Children
ElementSerializationInfo eInfo = info.ChildrenOrder[i] as ElementSerializationInfo;
Guid newId = Guid.Empty;
try
{
newId = groupMerger.GetIdMapping(eInfo.ElementId);
}
catch
{
newId = Guid.Empty;
}
if (newId == Guid.Empty)
{
ModelElement m = this.Store.ElementDirectory.FindElement(eInfo.ElementId);
if (m != null)
{
newId = m.Id;
}
}
for (int y = i; y < domainClass.SerializedDomainClass.Children.Count; y++)
{
if (domainClass.SerializedDomainClass.Children[y] is SerializedReferenceRelationship)
{
SerializedReferenceRelationship sDomainRel = domainClass.SerializedDomainClass.Children[y] as SerializedReferenceRelationship;
if (sDomainRel.ReferenceRelationship.Id == newId)
{
sDomainRel.OmitRelationship = eInfo.OmitElement;
if (y != i)
{
domainClass.SerializedDomainClass.Children.Move(y, i);
}
break;
}
}
else if (domainClass.SerializedDomainClass.Children[y] is SerializedEmbeddingRelationship)
{
SerializedEmbeddingRelationship sDomainRel = domainClass.SerializedDomainClass.Children[y] as SerializedEmbeddingRelationship;
if (sDomainRel.EmbeddingRelationship.Id == newId)
{
sDomainRel.OmitRelationship = eInfo.OmitElement;
if (y != i)
{
domainClass.SerializedDomainClass.Children.Move(y, i);
}
break;
}
}
else if (domainClass.SerializedDomainClass.Children[y] is SerializedDomainProperty)
{
SerializedDomainProperty p = domainClass.SerializedDomainClass.Children[y] as SerializedDomainProperty;
if (p.DomainProperty.Id == newId)
{
p.OmitProperty = eInfo.OmitElement;
if (y != i)
{
domainClass.SerializedDomainClass.Children.Move(y, i);
}
break;
}
}
}
#endregion
}
}
}
}
}
{ /// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="serializedRelationship">SerializedRelationship.</param>
/// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param>
public SerializedReferenceRelationshipViewModel(ViewModelStore viewModelStore, SerializedReferenceRelationship serializedRelationship, SerializationClassViewModel parent)
: base(viewModelStore, serializedRelationship, serializedRelationship.ReferenceRelationship, parent)
{
if (this.SerializationElement != null)
{
if (this.SerializationElement.ReferenceRelationship != null)
{
this.EventManager.GetEvent <ModelElementPropertyChangedEvent>().Subscribe(this.SerializationElement.ReferenceRelationship.Id, new Action <ElementPropertyChangedEventArgs>(OnSerializedReferenceRelationshipPropertyChanged));
}
}
}
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;
}
}
}
}
