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();
}
