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