/// <summary>
/// Constuctor.
/// </summary>
/// <param name="viewModelStore">The store this view model belongs to.</param>
/// <param name="referenceRSNode">ReferenceRSNode.</param>
/// <param name="parent">Parent.</param>
public ReferenceRSNodeViewModel(ViewModelStore viewModelStore, ReferenceRSNode referenceRSNode, TreeNodeViewModel parent)
: base(viewModelStore, referenceRSNode.ReferenceRelationship, parent)
{
this.referenceRSNode = referenceRSNode;
this.referenceNodeVMs = new ObservableCollection <ReferenceNodeViewModel>();
this.referenceNodeVMsRO = new ReadOnlyObservableCollection <ReferenceNodeViewModel>(referenceNodeVMs);
this.shapeNodeVMs = new ObservableCollection <ShapeRelationshipNodeViewModel>();
this.shapeNodeVMsRO = new ReadOnlyObservableCollection <ShapeRelationshipNodeViewModel>(shapeNodeVMs);
if (referenceRSNode != null)
{
if (referenceRSNode.ReferenceNode != null)
{
AddReferenceNode(referenceRSNode.ReferenceNode);
}
foreach (ShapeRelationshipNode node in referenceRSNode.ShapeRelationshipNodes)
{
if (node != null)
{
AddShapeNode(node);
}
}
Subscribe();
}
this.collapseExpandRelationshipShapeMappingCommand = new DelegateCommand(CollapseExpandRelationshipShapeMappingCommand_Executed);
}
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;
}
RelationshipShapeClassReferencesReferenceRelationship con = e.ModelElement as RelationshipShapeClassReferencesReferenceRelationship;
if (con != null)
{
if (con.DomainRelationship is ReferenceRelationship)
{
ReferenceRelationship rel = con.DomainRelationship as ReferenceRelationship;
ReferenceRSNode node = rel.ReferenceRSNode;
// create new shape relationship node
ShapeRelationshipNode shapeNode = new ShapeRelationshipNode(con.Store);
shapeNode.RelationshipShapeClass = con.RelationshipShapeClass;
node.ShapeRelationshipNodes.Add(shapeNode);
rel.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode);
if (rel.SerializedReferenceRelationship != null)
{
if (!rel.SerializedReferenceRelationship.IsInFullSerialization)
{
if (System.Windows.MessageBox.Show("Shape mapping has been defined for the ReferenceRelationship '" +
rel.Name + "'. The Relationship is not serialized in full form. Would you like to change the serialization of this relationship to full form (strongly adviced)?",
"Serialization",
System.Windows.MessageBoxButton.YesNo,
System.Windows.MessageBoxImage.Question) == System.Windows.MessageBoxResult.Yes)
{
rel.SerializedReferenceRelationship.IsInFullSerialization = true;
}
}
}
}
}
}
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;
}
RelationshipShapeClassReferencesReferenceRelationship con = e.ModelElement as RelationshipShapeClassReferencesReferenceRelationship;
if (con != null)
{
if (con.DomainRelationship is ReferenceRelationship)
{
RelationshipShapeClass shape = con.RelationshipShapeClass;
ShapeRelationshipNode node = shape.ShapeRelationshipNode;
if (node != null)
{
// delete
ReferenceRelationship rel = con.DomainRelationship as ReferenceRelationship;
ReferenceRSNode n = rel.ReferenceRSNode;
if (n != null)
{
if (n.ShapeRelationshipNodes.Contains(node))
{
n.ShapeRelationshipNodes.Remove(node);
}
}
node.Delete();
}
}
}
}
/// <summary>
/// Adds a new referece relationship instance.
/// </summary>
/// <param name="source">Domain class representing the source.</param>
/// <param name="target">Domain class representing the target.</param>
public static void AddNewReferenceRelationship(ReferenceRelationship refRel, DomainClass source, AttributedDomainElement target)
{
// tree nodes
// 1. find the element holder node for source
// 2. add new ReferenceRSNode, connect to rs
// 3. add new ReferenceNode for target
TreeNode elementHolderNode = null;
foreach (TreeNode node in source.DomainModelTreeNodes)
{
if (node.IsElementHolder)
{
elementHolderNode = node;
break;
}
}
if (elementHolderNode == null)
{
throw new ArgumentNullException("elementHolderNode");
}
ReferenceRSNode rsNode = new ReferenceRSNode(source.Store);
rsNode.ReferenceRelationship = refRel;
ReferenceNode refNode = new ReferenceNode(source.Store);
refNode.DomainElement = target;
refNode.IsElementHolder = false;
refNode.IsExpanded = false;
elementHolderNode.ReferenceRSNodes.Add(rsNode);
rsNode.ReferenceNode = refNode;
source.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(rsNode);
source.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(refNode);
}
/// <summary>
/// Deletes the rs view model that is hosting the given rs node.
/// </summary>
/// <param name="node">Rs node.</param>
public void DeleteReferenceRSNode(ReferenceRSNode node)
{
for (int i = this.referenceRSNodeVMs.Count - 1; i >= 0; i--)
if (this.referenceRSNodeVMs[i].ReferenceRSNode.Id == node.Id)
{
this.referenceRSNodeVMs[i].Dispose();
this.referenceRSNodeVMs.RemoveAt(i);
}
foreach (ReferenceRSNodeViewModel viewModel in this.referenceRSNodeVMs)
viewModel.UpdateNodePosition();
OnPropertyChanged("HasReferenceNodes");
}
/// <summary>
/// Adds a new reference rs view model for the given rs node.
/// </summary>
/// <param name="node">Rs node.</param>
public void AddReferenceRSNode(ReferenceRSNode node)
{
// verify that node hasnt been added yet
foreach (ReferenceRSNodeViewModel viewModel in this.referenceRSNodeVMs)
if (viewModel.ReferenceRSNode.Id == node.Id)
return;
ReferenceRSNodeViewModel vm = new ReferenceRSNodeViewModel(this.ViewModelStore, node, this);
this.referenceRSNodeVMs.Add(vm);
foreach (ReferenceRSNodeViewModel viewModel in this.referenceRSNodeVMs)
viewModel.UpdateNodePosition();
OnPropertyChanged("HasReferenceNodes");
}
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 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;
}
RelationshipShapeClassReferencesReferenceRelationship con = e.ElementLink as RelationshipShapeClassReferencesReferenceRelationship;
if (con != null)
{
RelationshipShapeClass shape = con.RelationshipShapeClass;
ShapeRelationshipNode node = shape.ShapeRelationshipNode;
// delete old
ReferenceRelationship relOld = e.OldRolePlayer as ReferenceRelationship;
if (relOld != null)
{
ReferenceRSNode nodeOld = relOld.ReferenceRSNode;
if (nodeOld != null)
{
node.RelationshipShapeClass = null;
if (nodeOld.ShapeRelationshipNodes.Contains(node))
{
nodeOld.ShapeRelationshipNodes.Remove(node);
}
}
node.Delete();
}
// create new
ReferenceRelationship rel = e.NewRolePlayer as ReferenceRelationship;
if (rel != null)
{
ReferenceRSNode n = rel.ReferenceRSNode;
// create new shape relationship node
ShapeRelationshipNode shapeNode = new ShapeRelationshipNode(con.Store);
shape.ShapeRelationshipNode = shapeNode;
n.ShapeRelationshipNodes.Add(shapeNode);
rel.ModelContext.ViewContext.DomainModelTreeView.ModelTreeNodes.Add(shapeNode);
if (rel.SerializedReferenceRelationship != null)
{
if (!rel.SerializedReferenceRelationship.IsInFullSerialization)
{
if (System.Windows.MessageBox.Show("Shape mapping has been defined for the ReferenceRelationship '" +
rel.Name + "'. The Relationship is not serialized in full form. Would you like to change the serialization of this relationship to full form (strongly adviced)?",
"Serialization",
System.Windows.MessageBoxButton.YesNo,
System.Windows.MessageBoxImage.Question) == System.Windows.MessageBoxResult.Yes)
{
rel.SerializedReferenceRelationship.IsInFullSerialization = true;
}
}
}
}
}
}
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;
}
TreeNodeReferencesReferenceRSNodes con = e.ModelElement as TreeNodeReferencesReferenceRSNodes;
if (con != null)
{
ReferenceRSNode rsNode = con.ReferenceRSNode;
if (rsNode != null)
{
ReferenceNode node = rsNode.ReferenceNode;
if (node != null)
{
// since this node still exists, it isnt included in the deletion process
// --> move to root node if this node is the element holder, as its parent has been deleted
if (node.IsElementHolder)
{
RootNode rootNode = new RootNode(node.Store);
rootNode.DomainElement = node.DomainElement;
node.EmbeddingModelTreeViewModel.RootNodes.Add(rootNode);
node.EmbeddingModelTreeViewModel.ModelTreeNodes.Add(rootNode);
// copy sub tree
for (int i = node.EmbeddingRSNodes.Count - 1; i >= 0; i--)
{
node.EmbeddingRSNodes[i].TreeNode = rootNode;
}
for (int i = node.ReferenceRSNodes.Count - 1; i >= 0; i--)
{
node.ReferenceRSNodes[i].TreeNode = rootNode;
}
for (int i = node.InheritanceNodes.Count - 1; i >= 0; i--)
{
node.InheritanceNodes[i].TreeNode = rootNode;
}
for (int i = node.ShapeClassNodes.Count - 1; i >= 0; i--)
{
node.ShapeClassNodes[i].TreeNode = rootNode;
}
rootNode.IsElementHolder = true;
rootNode.IsEmbeddingTreeExpanded = node.IsEmbeddingTreeExpanded;
rootNode.IsExpanded = true;
rootNode.IsInheritanceTreeExpanded = node.IsInheritanceTreeExpanded;
rootNode.IsReferenceTreeExpanded = node.IsReferenceTreeExpanded;
rootNode.IsShapeMappingTreeExpanded = node.IsShapeMappingTreeExpanded;
}
node.Delete();
}
rsNode.Delete();
}
}
}
