public static void OnEmbeddingRelationshipAdded(EmbeddingRelationship embeddingRelationship) { #region Check Paramaters if (embeddingRelationship.Source == null) { throw new ArgumentNullException("embeddingRelationship.Source"); } if (embeddingRelationship.Target == null) { throw new ArgumentNullException("embeddingRelationship.Target"); } if (!(embeddingRelationship.Source.RolePlayer is DomainClass)) { throw new ArgumentNullException("embeddingRelationship.Source.RolePlayer needs to be DomainClass"); } if (!(embeddingRelationship.Target.RolePlayer is DomainClass)) { throw new ArgumentNullException("embeddingRelationship.Target.RolePlayer needs to be DomainClass"); } #endregion // add serialization info SerializedDomainClass child; if ((embeddingRelationship.Target.RolePlayer as DomainClass).SerializedDomainClass == null) { child = new SerializedDomainClass(embeddingRelationship.Store); child.DomainClass = embeddingRelationship.Target.RolePlayer as DomainClass; (embeddingRelationship.Target.RolePlayer as DomainClass).ModelContext.SerializationModel.Children.Add(child); SerializationHelper.AddSerializationDomainProperties(embeddingRelationship.Store, embeddingRelationship.Target.RolePlayer); } else { child = (embeddingRelationship.Target.RolePlayer as DomainClass).SerializedDomainClass; } // Add properties and id attribute and set serialization form for embedding relationship. SerializedEmbeddingRelationship embChild = new SerializedEmbeddingRelationship(embeddingRelationship.Store); embChild.EmbeddingRelationship = embeddingRelationship; embChild.IsInFullSerialization = false; embChild.SerializationName = embeddingRelationship.SerializationName; SerializationHelper.AddSerializationDomainProperties(embeddingRelationship.Store, embeddingRelationship); embeddingRelationship.ModelContext.SerializationModel.Children.Add(embChild); embChild.Children.Add(child); // Add connection between roleplayers, to reflect it onto the serialization model. SerializationClass sourceSerializationClass = (embeddingRelationship.Source.RolePlayer as DomainClass).SerializedDomainClass; sourceSerializationClass.Children.Add(embChild); // update derived roles SerializationHelper.UpdateDerivedElementsSerializationDomainRoles(embeddingRelationship.Source.RolePlayer); }
public static void OnDomainClassAdded(DomainClass domainClass) { if (domainClass.SerializedDomainClass == null) { SerializedDomainClass child = new SerializedDomainClass(domainClass.Store); child.DomainClass = domainClass; child.SerializationName = domainClass.SerializationName; domainClass.ModelContext.SerializationModel.Children.Add(child); SerializationHelper.AddSerializationDomainProperties(domainClass.Store, domainClass); } }
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; } SerializedDomainClass serializedDomainClass = e.ModelElement as SerializedDomainClass; if (serializedDomainClass != null) { if (e.DomainProperty.Id == SerializedDomainClass.SerializationNameDomainPropertyId) { if (serializedDomainClass.IsSerializationNameTracking == TrackingEnum.True) { serializedDomainClass.IsSerializationNameTracking = TrackingEnum.False; } else if (serializedDomainClass.IsSerializationNameTracking == TrackingEnum.IgnoreOnce) { serializedDomainClass.IsSerializationNameTracking = TrackingEnum.True; } if (serializedDomainClass.DomainClass.SerializationName != serializedDomainClass.SerializationName) { serializedDomainClass.DomainClass.SerializationName = serializedDomainClass.SerializationName; serializedDomainClass.DomainClass.IsSerializationNameTracking = serializedDomainClass.IsSerializationNameTracking; } } } }
/// <summary> /// Adds a new SerializationClass view model for the given element. /// </summary> /// <param name="element">ModelContext.</param> public void AddChild(SerializationClass element) { if (!(element is SerializedDomainClass)) { return; } SerializedDomainClass dc = element as SerializedDomainClass; /*if (dc.ParentEmbeddedElements.Count > 0) * return;*/ // verify that node hasnt been added yet foreach (SerializedDomainModelViewModel viewModel in this.allVMs) { if (viewModel.SerializationElement.Id == element.Id) { return; } } SerializedDomainModelViewModel vm = new SerializedDomainModelViewModel(this.ViewModelStore, dc); this.allVMs.Add(vm); IOrderedEnumerable <SerializedDomainModelViewModel> items = null; items = this.allVMs.OrderBy <SerializedDomainModelViewModel, string>((x) => (x.DomainElementName)); ObservableCollection <SerializedDomainModelViewModel> temp = new ObservableCollection <SerializedDomainModelViewModel>(); foreach (SerializedDomainModelViewModel item in items) { temp.Add(item); } this.allVMs = temp; OnPropertyChanged("AllVMs"); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializationClass">SerializationClass.</param> public SerializedDomainClassViewModel(ViewModelStore viewModelStore, SerializedDomainClass serializationClass, SerializationClassViewModel parent) : base(viewModelStore, serializationClass, serializationClass.DomainClass, parent) { }
/// <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); } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializationClass">SerializationClass.</param> public SerializedDomainModelViewModel(ViewModelStore viewModelStore, SerializedDomainClass serializationClass) : base(viewModelStore, serializationClass, null) { }
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; } DomainClass domainClass = e.ModelElement as DomainClass; if (domainClass != null) { if (e.DomainProperty.Id == DomainClass.SerializationNameDomainPropertyId) { SerializedDomainClass c = domainClass.SerializedDomainClass; if (c != null) { if (c.SerializationName != domainClass.SerializationName) { c.SerializationName = domainClass.SerializationName; if (domainClass.IsSerializationNameTracking != TrackingEnum.False) { c.IsSerializationNameTracking = TrackingEnum.IgnoreOnce; } else { c.IsSerializationNameTracking = TrackingEnum.False; } } } } else if (e.DomainProperty.Id == DomainClass.NameDomainPropertyId) { foreach (DomainRole role in domainClass.RolesPlayed) { if (ImmutabilityExtensionMethods.GetLocks(role) != Locks.None) { continue; } if (role.IsNameTracking == TrackingEnum.True) { if (role.Name != domainClass.Name) { if (role.RolePlayer == role.Opposite.RolePlayer) { if (role.Relationship.Source == role) { role.Name = domainClass.Name + "Source"; } else { role.Name = domainClass.Name + "Target"; } } else { role.Name = domainClass.Name; } role.IsNameTracking = TrackingEnum.IgnoreOnce; } } } } } }