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; } LibraryModelContext libraryModelContext = e.ModelElement as LibraryModelContext; if (libraryModelContext != null) { if (libraryModelContext.ViewContext != null) { libraryModelContext.ViewContext.Delete(); } } }
private static void FixUpDiagramView(LibraryModelContext model) { foreach (DiagramClass diagramClass in model.DiagramClasses) { DiagramClassView vm = new DiagramClassView(model.Store); vm.IsExpanded = true; vm.DiagramClass = diagramClass; // add shapes views foreach (PresentationElementClass p in diagramClass.PresentationElements) { if (p is ShapeClass) { ShapeClass shapeClass = p as ShapeClass; if (shapeClass.Parent == null) { RootDiagramNode node = new RootDiagramNode(p.Store); node.PresentationElementClass = p; vm.RootDiagramNodes.Add(node); } else { EmbeddingDiagramNode newNode = new EmbeddingDiagramNode(model.Store); newNode.PresentationElementClass = p; } } else { RootDiagramNode node = new RootDiagramNode(p.Store); node.PresentationElementClass = p; vm.RootDiagramNodes.Add(node); } } foreach (PresentationElementClass p in diagramClass.PresentationElements) { if (p is ShapeClass) { ShapeClass shapeClass = p as ShapeClass; if (shapeClass.Parent != null) { EmbeddingDiagramNode source = shapeClass.Parent.DiagramTreeNode as EmbeddingDiagramNode; EmbeddingDiagramNode target = p.DiagramTreeNode as EmbeddingDiagramNode; if (source != null && target != null) { new EmbeddingDiagramNodeHasEmbeddingDiagramNodes(source, target); } } } } model.ViewContext.DiagramView.DiagramClassViews.Add(vm); } }
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; } LibraryModelContext modelContext = e.ModelElement as LibraryModelContext; if (modelContext != null && !(modelContext is ModelContext)) { ViewContext viewContext = new ViewContext(modelContext.Store); viewContext.DomainModelTreeView = new DomainModelTreeView(modelContext.Store); viewContext.DiagramView = new DiagramView(modelContext.Store); modelContext.ViewContext = viewContext; modelContext.MetaModel.View.ViewContexts.Add(viewContext); /* * DesignerDiagramClass ddC = new DesignerDiagramClass(modelContext.Store); * ddC.Name = NameHelper.GetUniqueName(modelContext.Store, DesignerDiagramClass.DomainClassId); * //ddC.Name = "DesignerDiagram"; * ddC.Title = "Designer"; * modelContext.DiagramClasses.Add(ddC); * * DiagramClassView vm = new DiagramClassView(modelContext.Store); * vm.IsExpanded = true; * vm.DiagramClass = ddC; * modelContext.ViewContext.DiagramView.DiagramClassViews.Add(vm); */ if (modelContext.SerializationModel == null) { modelContext.SerializationModel = new SerializationModel(modelContext.Store); } } }
public void ValidateMetaModel(ValidationContext context) { // names need to be unique List <ModelElement> namedElements = new List <ModelElement>(); List <string> names = new List <string>(); foreach (BaseModelContext m in this.ModelContexts) { if (m is LibraryModelContext) { LibraryModelContext ml = m as LibraryModelContext; namedElements.AddRange(ml.Classes); namedElements.AddRange(ml.Relationships); foreach (DiagramClass element in ml.DiagramClasses) { if (names.Contains(element.Name)) { context.LogError("A different diagram class is already named " + element.Name + ". Names are required to be unique.", "NameNeedsToBeUnique", null); //element); } else { names.Add(element.Name); } namedElements.AddRange(element.PresentationElements); } } } names.Clear(); foreach (GeneratedDomainElement element in namedElements) { if (names.Contains(element.Name)) { context.LogError("A different element is already named " + element.Name + ". Names are required to be unique.", "NameNeedsToBeUnique", null); //element); } else { names.Add(element.Name); } } names.Clear(); foreach (DomainType element in this.DomainTypes) { if (names.Contains(element.Name)) { context.LogError("A different type is already named " + element.Name + ". Names are required to be unique.", "NameNeedsToBeUnique", null); //element); } else { names.Add(element.Name); } } names.Clear(); foreach (PropertyGridEditor element in this.PropertyGridEditors) { if (names.Contains(element.Name)) { context.LogError("A different property grid editor is already named " + element.Name + ". Names are required to be unique.", "NameNeedsToBeUnique", null); //element); } else { names.Add(element.Name); } } bool bFoundDefaultMC = false; foreach (BaseModelContext m in this.ModelContexts) { if (m.IsDefault) { if (m is LibraryModelContext && !(m is ModelContext)) { context.LogError("Library Model Contexts can not have the property 'IsDefault' set to 'true': MetaModel '" + this.Name + "', Context '" + m.Name + "'", "NameNeedsToBeUnique", null); //element); } if (!bFoundDefaultMC) { bFoundDefaultMC = true; } else { context.LogError("Multiple Model Contexts have the property 'IsDefault' set to 'true': MetaModel '" + this.Name + "'.", "NameNeedsToBeUnique", null); //element); break; } } } //if( !bFoundDefaultMC ) // context.LogError("One Model Context needs to have the property 'IsDefault' set to 'true': MetaModel '" + this.Name + "'.", "NameNeedsToBeUnique", null); //element); }
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); } }
private static void FixUpDomainModelTreeView(LibraryModelContext model) { // create root nodes and embedding rs foreach (DomainClass domainClass in model.Classes) { if (!domainClass.HasParent()) { RootNode node = new RootNode(model.Store); node.DomainElement = domainClass; node.IsElementHolder = true; domainClass.ModelContext.ViewContext.DomainModelTreeView.RootNodes.Add(node); domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(node); node.IsEmbeddingTreeExpanded = true; node.IsReferenceTreeExpanded = true; node.IsInheritanceTreeExpanded = true; node.IsShapeMappingTreeExpanded = true; FixUpDomainClassInTreeView(domainClass); } } // reference relationships + shapes foreach (DomainRelationship relationship in model.Relationships) { if (relationship is ReferenceRelationship) { ReferenceRelationship rel = relationship as ReferenceRelationship; ModelTreeHelper.AddNewReferenceRelationship(rel, rel.Source.RolePlayer as DomainClass, rel.Target.RolePlayer); // shape foreach (RelationshipShapeClass s in rel.RelationshipShapeClasses) { ReferenceRSNode node = rel.ReferenceRSNode; // create new shape relationship node ShapeRelationshipNode shapeNode = new ShapeRelationshipNode(rel.Store); shapeNode.RelationshipShapeClass = s; node.ShapeRelationshipNodes.Add(shapeNode); rel.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode); } } } // inheritance foreach (DomainClass domainClass in model.Classes) { if (domainClass.BaseClass != null) { DomainClassReferencesBaseClass refBase = DomainClassReferencesBaseClass.GetLink(domainClass, domainClass.BaseClass); if (refBase != null) { if (domainClass.DomainModelTreeNodes.Count > 0) { ModelTreeHelper.AddNewInheritanceRelationship(refBase, domainClass, domainClass.BaseClass, false); } else { ModelTreeHelper.AddNewInheritanceRelationship(refBase, domainClass, domainClass.BaseClass, true); } } } } // shapes foreach (DomainClass domainClass in model.Classes) { foreach (PresentationDomainClassElement p in domainClass.ShapeClasses) { foreach (TreeNode node in domainClass.DomainModelTreeNodes) { if (node.IsElementHolder) { ShapeClassNode shapeNode = new ShapeClassNode(domainClass.Store); shapeNode.ShapeClass = p; node.ShapeClassNodes.Add(shapeNode); domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode); break; } } } } }
public 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(); } } }
protected override void ProcessOnMenuDeleteCommand() { if (this.SelectedElement is MetaModelLibrary) { if ((this.SelectedElement as MetaModelLibrary).ImportedLibrary == null) { using (Transaction transaction = this.ModelingDocData.Store.TransactionManager.BeginTransaction("Unload model library.")) { (this.SelectedElement as MetaModelLibrary).Delete(); transaction.Commit(); } return; } List <ModelElement> classes = new List <ModelElement>(); foreach (BaseModelContext mc in (this.SelectedElement as MetaModelLibrary).MetaModel.ModelContexts) { if (mc is LibraryModelContext) { LibraryModelContext m = mc as LibraryModelContext; foreach (DomainClass d in m.Classes) { classes.Add(d); classes.AddRange(d.Properties); } foreach (DomainRelationship r in m.Relationships) { classes.AddRange(r.Roles); } } if (mc is ExternModelContext) { classes.Add(mc); } } DependenciesViewModel vm = new DependenciesViewModel(LanguageDSLDocData.ViewModelStore, false); List <ModelElement> metaModels = new List <ModelElement>(); metaModels.Add((this.SelectedElement as MetaModelLibrary).MetaModel); System.Collections.ObjectModel.ReadOnlyCollection <ModelElement> libraries = this.SelectedElement.Store.ElementDirectory.FindElements(MetaModelLibrary.DomainClassId); foreach (ModelElement m in libraries) { if (m != this.SelectedElement) { if ((m as MetaModelLibrary).ImportedLibrary != null) { metaModels.Add((m as MetaModelLibrary).ImportedLibrary); } } } vm.Set(classes, metaModels, LanguageDSLDependenciesItemsProvider.GetAllCategories()); bool bDelete = true; if (vm.ActiveDependencies.Count > 0) { DeleteElementsPopup popup = new DeleteElementsPopup(); popup.DataContext = vm; if (popup.ShowDialog().Value != true) { bDelete = false; } } if (bDelete) { using (Transaction transaction = this.ModelingDocData.Store.TransactionManager.BeginTransaction("Unload model library.")) { (this.SelectedElement as MetaModelLibrary).FilePath = null; (this.SelectedElement as MetaModelLibrary).Delete(); transaction.Commit(); } } vm.Dispose(); GC.Collect(); return; } base.ProcessOnMenuDeleteCommand(); }