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;
}
ShapeClassNode node = e.ModelElement as ShapeClassNode;
if (node != null)
{
if (node.ShapeClass != null)
{
node.ShapeClass.DomainClass = null;
}
}
}
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;
ShapeClassReferencesDomainClass shapeCon = e.ElementLink as ShapeClassReferencesDomainClass;
if (shapeCon != null)
{
PresentationDomainClassElement shapeClass = shapeCon.ShapeClass;
ShapeClassNode node = shapeClass.ShapeClassNode;
// delete old
DomainClass domainClass = e.OldRolePlayer as DomainClass;
if (node != null)
{
foreach (TreeNode n in domainClass.DomainModelTreeNodes)
{
if (n.IsElementHolder)
{
if (n.ShapeClassNodes.Contains(node))
n.ShapeClassNodes.Remove(node);
break;
}
}
}
// add new
domainClass = e.NewRolePlayer as DomainClass;
foreach (TreeNode n in domainClass.DomainModelTreeNodes)
{
if (n.IsElementHolder)
{
ShapeClassNode shapeNode = new ShapeClassNode(shapeCon.Store);
shapeClass.ShapeClassNode = shapeNode;
n.ShapeClassNodes.Add(shapeNode);
domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode);
break;
}
}
if( node != null )
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;
}
ShapeClassReferencesDomainClass shapeCon = e.ModelElement as ShapeClassReferencesDomainClass;
if (shapeCon != null)
{
PresentationDomainClassElement shapeClass = shapeCon.ShapeClass;
ShapeClassNode node = shapeClass.ShapeClassNode;
if (node != null)
{
// delete
DomainClass domainClass = shapeCon.DomainClass;
foreach (TreeNode n in domainClass.DomainModelTreeNodes)
{
if (n.IsElementHolder)
{
if (n.ShapeClassNodes.Contains(node))
{
n.ShapeClassNodes.Remove(node);
}
break;
}
}
node.Delete();
}
}
}
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;
}
ShapeClassReferencesDomainClass shapeCon = e.ModelElement as ShapeClassReferencesDomainClass;
if (shapeCon != null)
{
DomainClass domainClass = shapeCon.DomainClass;
PresentationDomainClassElement shapeClass = shapeCon.ShapeClass;
foreach (TreeNode node in domainClass.DomainModelTreeNodes)
{
if (node.IsElementHolder)
{
ShapeClassNode shapeNode = new ShapeClassNode(shapeCon.Store);
shapeNode.ShapeClass = shapeClass;
node.ShapeClassNodes.Add(shapeNode);
domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode);
break;
}
}
}
}
/// <summary>
/// Deletes the shape class view model that is hosting the given shape class node.
/// </summary>
/// <param name="node">Shape class node.</param>
public void DeleteShapeClassNode(ShapeClassNode node)
{
for (int i = this.shapeClassNodeVMs.Count - 1; i >= 0; i--)
if (this.shapeClassNodeVMs[i].ShapeClassNode.Id == node.Id)
{
this.shapeClassNodeVMs[i].Dispose();
this.shapeClassNodeVMs.RemoveAt(i);
}
foreach (ShapeClassNodeViewModel viewModel in this.shapeClassNodeVMs)
viewModel.UpdateNodePosition();
OnPropertyChanged("HasShapeMappingNodes");
}
/// <summary>
/// Adds a new shape class view model for the given shape class node.
/// </summary>
/// <param name="node">Shape class node.</param>
public void AddShapeClassNode(ShapeClassNode node)
{
// verify that node hasnt been added yet
foreach (ShapeClassNodeViewModel viewModel in this.shapeClassNodeVMs)
if (viewModel.ShapeClassNode.Id == node.Id)
return;
ShapeClassNodeViewModel vm = new ShapeClassNodeViewModel(this.ViewModelStore, node, this);
this.shapeClassNodeVMs.Add(vm);
foreach (ShapeClassNodeViewModel viewModel in this.shapeClassNodeVMs)
viewModel.UpdateNodePosition();
OnPropertyChanged("HasShapeMappingNodes");
}
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;
}
ShapeClassReferencesDomainClass shapeCon = e.ElementLink as ShapeClassReferencesDomainClass;
if (shapeCon != null)
{
PresentationDomainClassElement shapeClass = shapeCon.ShapeClass;
ShapeClassNode node = shapeClass.ShapeClassNode;
// delete old
DomainClass domainClass = e.OldRolePlayer as DomainClass;
if (node != null)
{
foreach (TreeNode n in domainClass.DomainModelTreeNodes)
{
if (n.IsElementHolder)
{
if (n.ShapeClassNodes.Contains(node))
{
n.ShapeClassNodes.Remove(node);
}
break;
}
}
}
// add new
domainClass = e.NewRolePlayer as DomainClass;
foreach (TreeNode n in domainClass.DomainModelTreeNodes)
{
if (n.IsElementHolder)
{
ShapeClassNode shapeNode = new ShapeClassNode(shapeCon.Store);
shapeClass.ShapeClassNode = shapeNode;
n.ShapeClassNodes.Add(shapeNode);
domainClass.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode);
break;
}
}
if (node != null)
{
node.Delete();
}
}
}
/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="shapeClassNode">ShapeClassNode.</param>
/// <param name="parent">Parent.</param>
public ShapeClassNodeViewModel(ViewModelStore viewModelStore, ShapeClassNode shapeClassNode, TreeNodeViewModel parent)
: base(viewModelStore, shapeClassNode.ShapeClass)
{
this.shapeClassNode = shapeClassNode;
this.parentTreeNode = parent;
}
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;
}
}
}
}
}
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;
}
}
}
}
