public void Initialize(IContainerNode firstNeighborNode, IContainerNode secondNeighborNode)
{
GoLayer defaultLayer = Document.DefaultLayer;
GoSubGraphBase.ReparentToCommonSubGraph(this, (GoObject)firstNeighborNode, (GoObject)secondNeighborNode, true, defaultLayer);
FirstNeighbor = firstNeighborNode;
SecondNeighbor = secondNeighborNode;
if (FirstNeighbor == null || SecondNeighbor == null)
{
throw new OSPSuiteException();
}
//Refresh Ports names and postions after connecting both neighbors, if MultiPortContainerNodes are uses
var multiPortFirstNeighbor = FirstNeighbor as MultiPortContainerNode;
var multiPortSecondNeighbor = SecondNeighbor as MultiPortContainerNode;
if (multiPortFirstNeighbor != null)
{
multiPortFirstNeighbor.RefreshPort(_neighbor1Link);
}
if (multiPortSecondNeighbor != null)
{
multiPortSecondNeighbor.RefreshPort(_neighbor2Link);
}
AdjustPosition();
}
public static TNode GetOrAddNode <TNodeType, TNode>(this IContainerNode <TNodeType> containerNode, TNodeType nodeType)
where TNode : Node <TNodeType>, new()
{
Contract.Requires(containerNode != null);
return(containerNode.GetOrAddNode <TNodeType, TNode>(nodeType, () => new TNode(), Node <TNodeType> .DefaultNodeTypeEqualityComarer));
}
// PUBLIC METHODS ///////////////////////////////////////////////////
#region Methods
public static TNode CreateAndAddNode <TNodeType, TNode>(this IContainerNode <TNodeType> containerNode)
where TNode : Node <TNodeType>, new()
{
Contract.Requires(containerNode != null);
return(containerNode.CreateAndAddNode(() => new TNode()));
}
private void insertExternalNeighborLinks(IContainerNode parentContainerNode, GoLayoutForceDirectedNetwork net)
{
foreach (var childContainerNode in parentContainerNode.GetDirectChildren <IContainerNode>())
{
foreach (var neighborhoodNode in childContainerNode.GetLinkedNodes <INeighborhoodNode>())
{
if (!parentContainerNode.ContainsChildNode(neighborhoodNode, true))
{
var otherContainerNode = neighborhoodNode.GetOtherContainerNode(childContainerNode);
var nodeOnBoundary = new GoLayoutForceDirectedNode();
var pos = neighborhoodNode.Location;
bool pointExists = GoObject.GetNearestIntersectionPoint(parentContainerNode.Bounds, otherContainerNode.Center, childContainerNode.Center, out pos);
if (!pointExists)
{
continue;
}
//to be not deleted due to invisible node, seems to set also the position
nodeOnBoundary.GoObject = neighborhoodNode as GoObject;
nodeOnBoundary.IsFixed = true;
nodeOnBoundary.UserFlags = NodeLayoutType.REMOTE_CONTAINER_BOUNDARY_NODE;
//set Position after setting GoObject, because setting GoObject seems to set position
nodeOnBoundary.Position = pos;
net.AddNode(nodeOnBoundary);
net.LinkNodes(net.FindNode(childContainerNode as GoObject), nodeOnBoundary, neighborhoodNode as GoObject);
}
}
}
}
public void Unfocus(IContainerNode containerBaseNode)
{
// Show all inside and neighbors of parent
containerBaseNode.GetParent().SetHiddenRecursive(false);
var parentContainerBaseNode = containerBaseNode.GetParent() as IContainerNode;
if (parentContainerBaseNode != null)
{
foreach (var neighborNode in parentContainerBaseNode.GetLinkedNodes <IBaseNode>(true))
{
neighborNode.Hidden = false;
}
}
//show all children of ancestors with IsExpandedByDefault
while (parentContainerBaseNode != null && parentContainerBaseNode.IsExpandedByDefault)
{
parentContainerBaseNode.SetHiddenRecursive(false);
parentContainerBaseNode = parentContainerBaseNode.GetParent() as IContainerNode;
}
// Collapse node and arrange its neighborhood nodes
containerBaseNode.Collapse(100);
containerBaseNode.PostLayoutStep();
_view.Refresh();
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
protected ResourceIdentifierBuilder(IServiceModel serviceModel, IContainerNode <DomNodeType> domContainerNode, Type clrResourceType, object clrResource)
{
Contract.Requires(serviceModel != null);
Contract.Requires(domContainerNode != null);
this.DomContainerNode = domContainerNode;
if (clrResourceType == null)
{
return;
}
this.BuildingResourceIdentifier = true;
var resourceType = serviceModel.GetResourceType(clrResourceType);
this.ResourceType = resourceType;
if (clrResource == null)
{
return;
}
this.CreateAndAddDomReadWriteResourceIdentifierIfNeeded();
this.DomReadWriteResourceIdentifier.SetDomIdFromClrResource(this.ResourceType, clrResource);
}
public void AdjustPositionForContainerInMove(IContainerNode node, SizeF offset)
{
if (!checkAdjustabilityAndRefreshPorts())
{
return;
}
NeighborLink neighborLinkToContainerInMove = null;
NeighborLink neighborLinkToOtherContainer = null;
if (node.ContainsChildNode(FirstNeighbor, true))
{
neighborLinkToContainerInMove = _neighbor1Link;
neighborLinkToOtherContainer = _neighbor2Link;
}
if (node.ContainsChildNode(SecondNeighbor, true))
{
neighborLinkToContainerInMove = _neighbor2Link;
neighborLinkToOtherContainer = _neighbor1Link;
}
if (neighborLinkToContainerInMove == null)
{
return;
}
Location = mean(neighborLinkToOtherContainer.ToArrowEndPoint, neighborLinkToContainerInMove.ToArrowEndPoint + offset);
}
// complement and update ViewModel from PkModel and couple ViewModel and PkModel
protected override void UpdateDiagramModel(IMoBiSimulation simulation, IDiagramModel diagramModel, bool coupleAll)
{
// create neighborhoodsContainerNode, because entities are only added
// for available parentContainerNodes
IContainerNode neighborhoodsContainerNode = AddAndCoupleNode <IContainer, MultiPortContainerNode>(diagramModel, simulation.Model.Neighborhoods, coupleAll);
foreach (var baseNode in neighborhoodsContainerNode.GetAllChildren <IBaseNode>())
{
baseNode.IsVisible = false;
}
neighborhoodsContainerNode.IsVisible = false;
foreach (var topContainer in simulation.Model.Root.GetAllContainersAndSelf <IContainer>())
{
if (topContainer.ContainerType == ContainerType.Organism ||
topContainer.ContainerType == ContainerType.Organ ||
topContainer.ContainerType == ContainerType.Compartment)
{
AddObjectBase(diagramModel, topContainer, true, coupleAll);
}
}
foreach (var neighborhood in simulation.Model.Neighborhoods.GetAllChildren <INeighborhood>())
{
AddNeighborhood(neighborhood);
}
DiagramModel.ClearUndoStack();
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
internal ResourceLinksBuilder(TParentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, TResource clrResource)
: base(parentBuilder, domContainerNode)
{
Contract.Requires(clrResource != null);
this.Builder = this;
this.ClrResource = clrResource;
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
internal RelationshipLinksBuilder(TParentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, string rel)
: base(parentBuilder, domContainerNode)
{
Contract.Requires(String.IsNullOrWhiteSpace(rel) == false);
this.Builder = this;
this.Rel = rel;
}
public static TNode GetOrAddNode <TNodeType, TNode>(this IContainerNode <TNodeType> containerNode, TNodeType nodeType, Func <TNode> nodeFactoryMethod)
where TNode : Node <TNodeType>
{
Contract.Requires(containerNode != null);
Contract.Requires(nodeFactoryMethod != null);
return(containerNode.GetOrAddNode <TNodeType, TNode>(nodeType, nodeFactoryMethod, Node <TNodeType> .DefaultNodeTypeEqualityComarer));
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
protected ResourceIdentifierCollectionBuilder(IServiceModel serviceModel, IContainerNode <DomNodeType> domContainerNode)
{
Contract.Requires(serviceModel != null);
Contract.Requires(domContainerNode != null);
this.ServiceModel = serviceModel;
this.DomContainerNode = domContainerNode;
}
public static TNode GetNode <TNodeType, TNode>(this IContainerNode <TNodeType> containerNode, TNodeType nodeType, IEqualityComparer <TNodeType> nodeTypeEqualityComparer)
where TNode : Node <TNodeType>
{
Contract.Requires(containerNode != null);
var node = containerNode.GetNode(nodeType, nodeTypeEqualityComparer);
return(node != null ? (TNode)node : null);
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
protected ResourceCollectionBuilder(DocumentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, IEnumerable <TResource> clrResourceCollection)
{
Contract.Requires(domContainerNode != null);
this.ParentBuilder = parentBuilder;
this.InitializeResourcePathContextBuilder();
this.InitializeResourceCollection(domContainerNode, clrResourceCollection);
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
protected ResourceBuilder(DocumentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, TResource clrResource)
{
Contract.Requires(parentBuilder != null);
Contract.Requires(domContainerNode != null);
this.ParentBuilder = parentBuilder;
this.InitializeResource(domContainerNode, clrResource);
}
public static Node <TNodeType> GetNode <TNodeType>(this IContainerNode <TNodeType> containerNode, TNodeType nodeType, IEqualityComparer <TNodeType> nodeTypeEqualityComparer)
{
Contract.Requires(containerNode != null);
var node = containerNode.Nodes()
.SingleOrDefault(x => nodeTypeEqualityComparer.Equals(x.NodeType, nodeType));
return(node);
}
public static bool ContainsNode <TNodeType>(this IContainerNode <TNodeType> containerNode, TNodeType nodeType, IEqualityComparer <TNodeType> nodeTypeEqualityComparer)
{
Contract.Requires(containerNode != null);
Contract.Requires(nodeTypeEqualityComparer != null);
var containsNode = containerNode.Nodes()
.Any(x => nodeTypeEqualityComparer.Equals(x.NodeType, nodeType));
return(containsNode);
}
protected void AdjustPositions(IContainerNode containerNode, SizeF offset)
{
var oldLocation = containerNode.Location;
foreach (var neighborhoodNode in containerNode.GetLinkedNodes <INeighborhoodNode>(true))
{
neighborhoodNode.AdjustPositionForContainerInMove(containerNode, offset);
}
containerNode.Location = oldLocation;
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
protected LinksBuilder(TParentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode)
{
Contract.Requires(parentBuilder != null);
Contract.Requires(domContainerNode != null);
this.ParentBuilder = parentBuilder;
var domReadWriteLinks = domContainerNode.GetOrAddNode(DomNodeType.Links, () => DomReadWriteLinks.Create());
this.DomReadWriteLinks = domReadWriteLinks;
}
public static TNode CreateAndAddNode <TNodeType, TNode>(this IContainerNode <TNodeType> containerNode, Func <TNode> nodeFactoryMethod)
where TNode : Node <TNodeType>
{
Contract.Requires(containerNode != null);
Contract.Requires(nodeFactoryMethod != null);
// Create and add new node to the container node.
var newNode = nodeFactoryMethod();
containerNode.Add(newNode);
return(newNode);
}
protected ResourceIdentifierBuilder(IServiceModel serviceModel, IContainerNode <DomNodeType> domContainerNode, TResource clrResource)
: this(serviceModel, domContainerNode)
{
if (clrResource == null)
{
return;
}
this.CreateAndAddDomReadWriteResourceIdentifierIfNeeded();
this.DomReadWriteResourceIdentifier.SetDomIdFromClrResource(this.ResourceType, clrResource);
}
// allows LayoutCopyService to copy node positions inside collapsed subgraphs
protected void CopySavedBoundsFrom(IContainerNode otherContainer)
{
try
{
var otherSubGraph = otherContainer as GoSubGraph;
if (otherSubGraph == null)
{
return;
}
// build Cache of GoNode children
ICache <string, GoNode> childNodes = new Cache <string, GoNode>(x => x.Text); //Text = Name
foreach (GoNode childNode in Enumerable.Where <GoObject>(this, child => ConversionExtensions.IsAnImplementationOf <GoNode>(child)))
{
if (!String.IsNullOrEmpty(childNode.Text))
{
addUnique(childNodes, childNode.Text, childNode);
}
else if (childNode.IsAnImplementationOf <INeighborhoodNode>()) //childNode.Text is empty and childNode is NeighborhoodNode
{
addUnique(childNodes, ((INeighborhoodNode)childNode).Name, childNode);
}
}
// store SavedBounds for each child GoNode with the same name
foreach (GoNode otherNode in otherSubGraph.SavedBounds.Keys.Where(child => child.IsAnImplementationOf <GoNode>()))
{
string name = otherNode.Text;
if (String.IsNullOrEmpty(name) && otherNode.IsAnImplementationOf <INeighborhoodNode>())
{
name = ((INeighborhoodNode)otherNode).Name;
}
if (!String.IsNullOrEmpty(name) && childNodes.Contains(name))
{
var childNode = childNodes[name];
if (SavedBounds.ContainsKey(childNode))
{
SavedBounds[childNode] = otherSubGraph.SavedBounds[otherNode];
}
else
{
SavedBounds.Add(childNode, otherSubGraph.SavedBounds[otherNode]);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
public IContainerNode GetOtherContainerNode(IContainerNode node)
{
if (node.Equals(FirstNeighbor))
{
return(SecondNeighbor);
}
if (node.Equals(SecondNeighbor))
{
return(FirstNeighbor);
}
throw new OSPSuiteException("ContainerNode " + node.Name + "(" + node.Id + ") is not linked to NeighborhoodNode " + Name + "(" + Id + ")");
}
private IEnumerable <IContainerNode> getNeighboredContainerNodes()
{
IList <IContainerNode> neighboredContainerNodes = new List <IContainerNode>();
foreach (var neighborhoodNode in GetLinkedNodes <INeighborhoodNode>())
{
IContainerNode neighboredContainerNode = neighborhoodNode.GetOtherContainerNode(this);
if (neighboredContainerNode != null)
{
neighboredContainerNodes.Add(neighboredContainerNode);
}
}
return(neighboredContainerNodes);
}
// INTERNAL CONSTRUCTORS ////////////////////////////////////////////
#region Constructors
internal RelationshipsBuilder(TParentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, TResource clrResource)
{
Contract.Requires(parentBuilder != null);
Contract.Requires(domContainerNode != null);
Contract.Requires(clrResource != null);
this.ParentBuilder = parentBuilder;
var domReadWriteRelationships = domContainerNode.GetOrAddNode(DomNodeType.Relationships, () => DomReadWriteRelationships.Create());
this.DomReadWriteRelationships = domReadWriteRelationships;
this.ClrResource = clrResource;
}
// INTERNAL CONSTRUCTORS ////////////////////////////////////////////
#region Constructors
internal RelationshipBuilder(TParentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, string rel)
{
Contract.Requires(parentBuilder != null);
Contract.Requires(domContainerNode != null);
Contract.Requires(String.IsNullOrWhiteSpace(rel) == false);
this.ParentBuilder = parentBuilder;
var domReadWriteRelationships = (DomReadWriteRelationships)domContainerNode;
var domReadWriteRelationship = domReadWriteRelationships.AddDomReadWriteRelationship(rel);
this.DomReadWriteRelationship = domReadWriteRelationship;
this.Rel = rel;
}
public virtual void Focus(IContainerNode containerBaseNode)
{
// Show node and expand it
containerBaseNode.SetHiddenRecursive(false);
containerBaseNode.Expand(0);
// Show neighbors
foreach (var neighborNode in containerBaseNode.GetLinkedNodes <IBaseNode>(true))
{
neighborNode.Hidden = false;
}
containerBaseNode.PostLayoutStep();
_view.Refresh();
}
private void InitializeResource(IContainerNode <DomNodeType> domContainerNode, object clrResource)
{
Contract.Requires(clrResource != null);
if (clrResource == null)
{
return;
}
// Map the incoming CLR resource to the DOM resource node.
var resourceType = this.ResourceType;
var domReadWriteResource = DomReadWriteResource.Create();
resourceType.MapClrTypeToDomResource(domReadWriteResource);
resourceType.MapClrIdToDomResource(domReadWriteResource, clrResource);
var domResource = (IDomResource)domReadWriteResource;
var domResourceKey = domResource.CreateDomResourceKey();
// Do not add the DOM read-write resource node if it already has been added to the DOM document.
if (this.DocumentBuilderContext.ContainsDomReadWriteResource(domResourceKey))
{
return;
}
// Add the DOM read/write resource nodes to the DOM document.
this.DocumentBuilderContext.AddDomReadWriteResource(domResourceKey, domReadWriteResource);
domContainerNode.Add(domReadWriteResource);
// Finish mapping the DOM read/write resource attributes nodes to the DOM document.
var queryParameters = this.DocumentBuilderContext.QueryParameters;
var apiType = resourceType.ResourceIdentityInfo.ApiType;
var useSparseFieldsets = this.DocumentBuilderContext.SparseFieldsetsEnabled && queryParameters.ContainsField(apiType);
if (!useSparseFieldsets)
{
resourceType.MapClrAttributesToDomResource(domReadWriteResource, clrResource);
}
else
{
resourceType.MapClrAttributesToDomResource(domReadWriteResource, clrResource, (x, y) => queryParameters.ContainsField(x, y));
}
this.BuildingResource = true;
this.DomReadWriteResource = domReadWriteResource;
this.ClrResource = clrResource;
}
// PROTECTED CONSTRUCTORS ///////////////////////////////////////////
#region Constructors
protected ResourceCollectionBuilder(DocumentBuilder parentBuilder, IContainerNode <DomNodeType> domContainerNode, Type clrResourceType, IEnumerable <object> clrResourceCollection)
{
Contract.Requires(domContainerNode != null);
Contract.Requires(clrResourceType != null);
this.ParentBuilder = parentBuilder;
if (clrResourceType == null)
{
return;
}
var resourceType = this.ServiceModel.GetResourceType(clrResourceType);
this.ResourceType = resourceType;
this.InitializeResourceCollection(domContainerNode, clrResourceType, clrResourceCollection);
this.InitializeResourcePathContextBuilder();
}
// INTERNAL CONSTRUCTORS ////////////////////////////////////////////
#region Constructors
internal RelationshipBuilderBase(IServiceModel serviceModel, IContainerNode <DomNodeType> domContainerNode, string rel)
{
Contract.Requires(serviceModel != null);
Contract.Requires(domContainerNode != null);
Contract.Requires(String.IsNullOrWhiteSpace(rel) == false);
this.ServiceModel = serviceModel;
var resourceType = serviceModel.GetResourceType <TResource>();
this.ResourceType = resourceType;
this.Rel = rel;
var domReadWriteRelationships = (DomReadWriteRelationships)domContainerNode;
var domReadWriteRelationship = domReadWriteRelationships.AddDomReadWriteRelationship(rel);
this.DomReadWriteRelationship = domReadWriteRelationship;
}
/// <summary>
/// Sets parents and siblings for the metadata tree. This should be executed only for unit testing scenarios since the
/// metadata tree service will initialize the parent/next sibling properties correctly. This was done because the development
/// cost of retrofitting every existing unit test to set the parent/sibling properties was going to take too much time.
/// </summary>
/// <param name="metric"></param>
/// <param name="parentMetric"></param>
private void SetParentsAndSiblings(IContainerNode<MetricMetadataNode> metric, IContainerNode<MetricMetadataNode> parentMetric)
{
var metricNode = metric as MetricMetadataNode;
if (metricNode != null)
{
metricNode.Parent = parentMetric as MetricMetadataNode;
EnsureMetricNodeIdInitialized(metricNode);
}
MetricMetadataNode lastChild = null;
foreach (var childMetric in metric.Children)
{
SetParentsAndSiblings(childMetric, metric);
if (lastChild != null)
lastChild.NextSibling = childMetric;
lastChild = childMetric;
}
}
