Uses of Class
com.yworks.yfiles.algorithms.Node

Packages that use Node

Package	Description
com.yworks.yfiles.algorithms	Provides the yFiles library's most fundamental classes and interfaces that model an efficient graph data type (class Graph), its nodes and edges (classes Node and Edge), and related container structures and iteration mechanisms (class YList and interface ICursor).
com.yworks.yfiles.layout	Provides essential classes and interfaces that constitute the infrastructure for automatic graph layout generation.
com.yworks.yfiles.layout.hierarchic	Provides hierarchic layout style algorithms.
com.yworks.yfiles.layout.labeling	Provides algorithms for the automatic placement of node and edge labels, so called generic labeling algorithms.
com.yworks.yfiles.layout.multipage	Provides the MultiPageLayout that subdivides the input graph into several smaller graphs whose layouts fit the specified maximum page size.
com.yworks.yfiles.layout.organic	Provides organic layout style algorithms that are based on a force-directed layout paradigm.
com.yworks.yfiles.layout.router.polyline	Provides classes and interfaces for automatic polyline routing of the edges of a graph.
com.yworks.yfiles.layout.seriesparallel	Provides the series-parallel layout algorithm.
com.yworks.yfiles.layout.tree	Provides tree layout style algorithms.

Uses of Node in com.yworks.yfiles.algorithms

Methods in com.yworks.yfiles.algorithms that return Node

Modifier and Type	Method and Description
Node	Node.createCopy(Graph g) Creates a copy of this node that will be inserted into the given graph.
Node	Graph.createNode() Creates a new node in this graph and fires a corresponding notification event to inform registered listeners.
Node	NodeList.firstNode() Returns the first node in this list, or null when the list is empty.
Node	Graph.firstNode() Gets the first node in this graph.
static Node	Trees.getCenterRoot(Graph tree) Returns the center node of an undirected tree.
static Node	Trees.getNearestCommonAncestor(Graph tree, Node root, boolean rootedDownward, NodeList nodes) Returns the nearest common ancestor of a subset of nodes within a directed rooted tree.
Node[]	Graph.getNodeArray() Returns an array containing all nodes of this graph.
Node	Groups.Dendrogram.getNodeAtLevel(int level) Returns the node of the dendrogram that belongs to the given level index.
Node	Groups.Dendrogram.getOriginalNode(Node node) Returns the node of original graph that is mapped with the given leaf node of the dendrogram.
Node	Groups.Dendrogram.getRoot() Gets the root node of the dendrogram.
static Node	Trees.getRoot(Graph tree) Returns a possible root for the given (undirected) tree.
static Node	Trees.getWeightedCenterNode(Graph tree) Finds a node used by the greatest number of all (undirected) paths interconnecting all nodes with each other.
static Node	Trees.getWeightedCenterNode(Graph tree, INodeMap intWeight) Finds a node used by the greatest number of all (undirected) paths interconnecting all nodes with each other.
Node	NodeList.lastNode() Returns the last node in this list, or null when the list is empty.
Node	Graph.lastNode() Gets the last node in this graph.
Node	INodeCursor.node() Gets the node at the current location of the cursor.
Node	Edge.opposite(Node v) Returns the node at the opposite edge end with respect to the given node.
Node	NodeList.popNode() Removes the first node from this list and returns it.
static Node[]	Sorting.sortNodesByDegree(Graph graph) Sorts the nodes of a given graph by degree in ascending order.
static Node[]	Sorting.sortNodesByIntKey(Graph graph, IDataProvider keys) Sorts the nodes of a given graph by an integer key associated with each node through a IDataProvider.
Node	Edge.source() Gets the source node connected to this edge.
Node	Edge.target() Gets the target node connected to this edge.
Node[]	NodeList.toNodeArray() Returns a node array containing all elements of this list in the canonical order.

Methods in com.yworks.yfiles.algorithms that return types with arguments of type Node

Modifier and Type	Method and Description
IEnumerable<Node>	Node.getNeighbors() Yields a dynamic Iterable for Nodes that can be used to iterate over the opposite sides of adjacent adjacent edges at this instance.
IEnumerable<Node>	Graph.getNodes() Yields a dynamic Iterable for Nodes that can be used to iterate over the nodes that are contained in this instance.
IEnumerable<Node>	Node.getPredecessors() Yields a dynamic Iterable for Nodes that can be used to iterate over the opposite sides of adjacent incoming edges at this instance.
IEnumerable<Node>	Node.getSuccessors() Yields a dynamic Iterable for Nodes that can be used to iterate over the opposite sides of adjacent outgoing edges at this instance.

Methods in com.yworks.yfiles.algorithms with parameters of type Node

Modifier and Type	Method and Description
static boolean	ShortestPaths.acyclic(Graph graph, Node s, double[] cost, double[] dist) Solves the single-source shortest path problem for acyclic directed graphs.
static boolean	ShortestPaths.acyclic(Graph graph, Node s, double[] cost, double[] dist, Edge[] pred) Solves the single-source shortest path problem for acyclic directed graphs.
static boolean	ShortestPaths.acyclic(Graph graph, Node s, IDataProvider cost, INodeMap dist, INodeMap pred) Each edge is associated with an arbitrary double value that represents the cost of that edge.
static boolean	ShortestPaths.bellmanFord(Graph graph, Node s, boolean directed, double[] cost, double[] dist) Solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.bellmanFord(Graph graph, Node s, boolean directed, double[] cost, double[] dist, Edge[] pred) Solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.bellmanFord(Graph graph, Node s, boolean directed, IDataProvider cost, INodeMap dist, INodeMap pred) Solves the single-source shortest path problem for arbitrary graphs.
static int	NetworkFlows.calcMaxFlow(Graph graph, Node source, Node sink, IDataProvider eCapDP, IEdgeMap flowEM) Solves a maximum flow problem using the preflow-push method.
static int	NetworkFlows.calcMaxFlowMinCut(Graph graph, Node source, Node sink, IDataProvider eCapDP, IEdgeMap flowEM, INodeMap sourceCutNM) Solves a maximum flow problem using the preflow-push method but additionally marks all nodes that belong to the minimum cut set that is associated with the source of the network.
void	Graph.changeEdge(Edge e, Node newSource, Edge sourceReference, GraphElementInsertion sourceD, Node newTarget, Edge targetReference, GraphElementInsertion targetD) Redefines an edge's end points and fires corresponding notification events to inform registered listeners.
void	Graph.changeEdge(Edge e, Node newSource, Node newTarget) Redefines an edge's end points and fires corresponding notification events to inform registered listeners.
static void	Trees.collectSubtree(Node root, NodeList nodes) Collects all nodes of the subtree starting from the given root node.
static EdgeList	ShortestPaths.constructEdgePath(Node s, Node t, Edge[] pred) Convenience method that constructs an explicit path of edges from the result returned by one of the shortest paths methods defined in this class.
static EdgeList	ShortestPaths.constructEdgePath(Node s, Node t, IDataProvider pred) Like ShortestPaths.constructEdgePath(Node, Node, Edge[]) but the path edges are given by a IDataProvider.
static NodeList	ShortestPaths.constructNodePath(Node s, Node t, Edge[] pred) Convenience method that constructs an explicit path of nodes from the result returned by one of the shortest paths methods defined in this class.
static NodeList	ShortestPaths.constructNodePath(Node s, Node t, IDataProvider pred) Like ShortestPaths.constructNodePath(Node, Node, Edge[]) but the path edges are given by a IDataProvider.
boolean	Graph.contains(Node v) Whether or not this graph contains the given node.
boolean	Graph.containsEdge(Node source, Node target) Returns whether or not this graph contains an edge that connects the given nodes.
Edge	Edge.createCopy(Graph g, Node v, Node w) Creates a copy of this edge that will be inserted into the given graph connecting the given source and target nodes.
Edge	Graph.createEdge(Node v, Edge e1, Node w, Edge e2, GraphElementInsertion d1, GraphElementInsertion d2) Creates a new edge in this graph to be ordered before or after a given edge and fires a corresponding notification event to inform registered listeners.
Edge	Graph.createEdge(Node v, Node w) Creates a new edge in this graph and fires a corresponding notification event to inform registered listeners.
static void	ShortestPaths.dijkstra(Graph graph, Node s, boolean directed, double[] cost, double[] dist) Solves the single-source shortest path problem for arbitrary graphs.
static void	ShortestPaths.dijkstra(Graph graph, Node s, boolean directed, double[] cost, double[] dist, Edge[] pred) Solves the single-source shortest path problem for arbitrary graphs.
static void	ShortestPaths.dijkstra(Graph graph, Node s, boolean directed, IDataProvider cost, INodeMap dist, INodeMap pred) Solves the single-source shortest path problem for arbitrary graphs.
static EdgeList	Trees.directTree(Graph tree, Node root) Converts the given tree to a directed rooted tree with the given node as root element by reversing some edges.
static EdgeList[]	Paths.findAllPaths(Graph graph, Node startNode, Node endNode, boolean directed) Returns all simple directed or undirected paths that connect a start node with an end node.
static EdgeList[]	Paths.findAllPaths(Graph graph, Node startNode, Node endNode, boolean directed, Predicate<EdgeList> filter) A variant of Paths.findAllPaths(Graph, Node, Node, boolean) which returns all simple directed or undirected paths between two given nodes and, additionally, allows to specify a filter for the paths to be returned.
static void	Paths.findAllPaths(Graph graph, Node startNode, Node endNode, IEdgeMap pathEdges) Finds all edges that belong to a directed path from a start node to an end node.
static ICursor	Paths.findAllPathsCursor(Graph graph, Node startNode, Node endNode, boolean directed) A variant of Paths.findAllPaths(Graph, Node, Node, boolean), which returns all simple directed or undirected paths between two given nodes as a special cursor that calculates the next path in the sequence, only when needed.
static void	Paths.findLongestPaths(Graph graph, Node startNode, IEdgeMap dist, INodeMap maxDist, IEdgeMap predicate) Calculates the longest path from a given node to all other node in a given directed acyclic graph.
static boolean	Paths.findPath(Graph graph, NodeList topSort, Node startNode, Node endNode, IEdgeMap predicate) Returns whether or not a directed path from a start node to another node in an acyclic graph exists.
static EdgeList	Paths.findPath(Graph graph, Node startNode, Node endNode, boolean directed) Returns an EdgeList containing the edges of a path from the given start node to the given end node, if such a path exists.
static void	ShortestPaths.findShortestUniformPaths(Graph graph, Node start, IDataProvider targetMap, boolean directed, int maxLength, EdgeList pathEdges, NodeList pathNodes) Finds all nodes and edges that belong to a shortest path from a start node to a set of target nodes in the graph not farther away than a given distance.
static void	ShortestPaths.findShortestUniformPaths(Graph graph, Node start, Node end, boolean directed, IEdgeMap pathMap) Marks all edges that belong to a shortest path from start node to target node.
protected static Edge	Graph.firstOutEdge(Node v) Low-level iteration support for adjacent edges.
NodeList	Groups.Dendrogram.getChildren(Node parent) Returns a NodeList that contains the child nodes of the given parent node.
NodeList[]	Groups.Dendrogram.getClusterNodes(Node node) Returns an array of NodeLists that contain the nodes of the original graph that are associated with the given dendrogram node.
double	Groups.Dendrogram.getDissimilarityValue(Node node) Returns the dissimilarity value associated with the given node of the dendrogram.
double	Groups.INodeDistanceProvider.getDistance(Node n1, Node n2) Returns the distance between two given nodes of a graph.
Edge	Node.getEdge(Node opposite) Returns an edge that connects this node with the given node, if such an edge exists.
Edge	Node.getEdgeFrom(Node source) Returns an incoming edge that connects the given node with this node, if such an edge exists.
Edge	Node.getEdgeTo(Node target) Returns an outgoing edge that connects this node with the given node, if such an edge exists.
int	Groups.Dendrogram.getLevel(Node node) Returns the level of the given node of the dendrogram.
static Node	Trees.getNearestCommonAncestor(Graph tree, Node root, boolean rootedDownward, NodeList nodes) Returns the nearest common ancestor of a subset of nodes within a directed rooted tree.
Node	Groups.Dendrogram.getOriginalNode(Node node) Returns the node of original graph that is mapped with the given leaf node of the dendrogram.
List<Dart>	PlanarEmbedding.getOutgoingDarts(Node node) Returns a List containing the (cyclic ordered) outgoing darts of the specified node.
void	LayoutGraphHider.hide(Node v) Hides the given node and all it's adjacent edges from the graph.
void	GraphPartitionManager.hide(Node v) Hides the given node and all it's adjacent edges from the graph.
void	Graph.hide(Node v) Hides the given node from this graph.
boolean	Groups.Dendrogram.isLeaf(Node node) Returns whether or not the given dendrogram node is a leaf node.
static YList	ShortestPaths.kShortestPaths(Graph graph, IDataProvider costDP, Node start, Node end, int k) This method finds the k shortest paths connecting a pair of nodes in a directed graph with non-negative edge costs.
static ICursor	ShortestPaths.kShortestPathsCursor(Graph graph, IDataProvider costDP, Node start, Node end, int k) A variant of ShortestPaths.kShortestPaths(Graph, IDataProvider, Node, Node, int) that returns the result as a special cursor that calculates the next path in the sequence only when needed.
protected void	Dfs.lookFurther(Node v) Callback method that will be invoked whenever DFS continues its search at a new root node.
static int	NetworkFlows.minCostFlow(Graph graph, Node s, Node t, IDataProvider uCapDP, IDataProvider cost0DP, IEdgeMap flowEM, INodeMap dualsNM) Solves a minimum cost maximum flow problem.
void	Graph.moveToFirst(Node v) Moves the given node to the first position within the sequence of nodes in this graph.
void	Graph.moveToLast(Node v) Moves the given node to the last position within the sequence of nodes in this graph.
Node	Edge.opposite(Node v) Returns the node at the opposite edge end with respect to the given node.
protected void	Dfs.postTraverse(Edge edge, Node node) Callback method that will be invoked after the DFS has returned from the given node.
protected void	Dfs.postVisit(Node node, int dfsNumber, int compNumber) Callback method that will be invoked whenever a node visit has been completed.
protected void	Dfs.preTraverse(Edge edge, Node node, boolean treeEdge) Callback method that will be invoked if the given edge will be considered the first (and only) time during the DFS.
protected void	Dfs.preVisit(Node node, int dfsNumber) Callback method that will be invoked whenever a formerly unvisited node gets visited for the first time.
static void	GraphConnectivity.reachable(Graph graph, Node start, boolean directed, boolean[] reached) Determines the set of nodes that are reachable from a given node when a set of edges that cannot be traversed is specified.
static void	GraphConnectivity.reachable(Graph graph, Node start, boolean directed, boolean[] reached, boolean[] forbidden) Determines the set of nodes that are reachable from a given node when a set of edges that cannot be traversed is specified.
void	Graph.reInsertNode(Node v) Reinserts a formerly removed node into this graph and fires a corresponding notification event to inform registered listeners.
void	Graph.removeNode(Node v) Removes the given node from this graph.
static EdgeList[]	ShortestPaths.shortestPair(Graph graph, Node source, Node target, boolean directed, IDataProvider costDP) Returns two edge-disjoint paths in a non-negatively weighted directed graph, such that both paths connect nodes s and t and have minimum total length.
static int	RankAssignments.simplex(Graph graph, INodeMap layer, IDataProvider w, IDataProvider minLength, IEdgeMap tree, Node _root, boolean validRanking) Similar to RankAssignments.simplex(Graph, INodeMap, IDataProvider, IDataProvider, long) but, additionally, it is possible to provide a valid initial tree solution for the problem.
static int	RankAssignments.simplex(Graph graph, INodeMap layer, IDataProvider w, IDataProvider minLength, IEdgeMap tree, Node _root, boolean validRanking, long maximalDuration) Similar to RankAssignments.simplex(Graph, INodeMap, IDataProvider, IDataProvider, long) but, additionally, it is possible to provide a valid initial tree solution for the problem.
static boolean	ShortestPaths.singleSource(Graph graph, Node s, boolean directed, double[] cost, double[] dist) This method solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.singleSource(Graph graph, Node s, boolean directed, double[] cost, double[] dist, Edge[] pred) This method solves the single-source shortest path problem for arbitrary graphs.
static boolean	ShortestPaths.singleSource(Graph graph, Node s, boolean directed, IDataProvider cost, INodeMap dist, INodeMap pred) This method solves the single-source shortest path problem for arbitrary graphs.
static EdgeList	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, double[] cost) Similar to ShortestPaths.singleSourceSingleSink(Graph, Node, Node, boolean, double[], Edge[]) but instead of returning the shortest distance between the source and sink the actual shortest edge path between these nodes will be returned.
static double	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, double[] cost, Edge[] pred) This method solves the single-source single-sink shortest path problem for arbitrary graphs.
static EdgeList	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, IDataProvider cost) Similar to ShortestPaths.singleSourceSingleSink(Graph, Node, Node, boolean, IDataProvider, INodeMap) but instead of returning the shortest distance between the source and sink the actual shortest edge path between these nodes will be returned.
static double	ShortestPaths.singleSourceSingleSink(Graph graph, Node s, Node t, boolean directed, IDataProvider cost, INodeMap pred) Like ShortestPaths.singleSourceSingleSink(Graph, Node, Node, boolean, double[], Edge[]) but uses INodeMaps and IDataProviders instead of arrays.
void	Dfs.start(Graph graph, Node start) Starts a depth first search from a given Node of the input graph.
protected void	LayoutGraphHider.unhide(Node v) This method will be called whenever the hider is requested to unhide the given node from the graph.
protected void	GraphPartitionManager.unhide(Node v) This method will be called whenever the partition manager is requested to unhide the given node from the graph.
void	Graph.unhide(Node v) Unhides the given node in this graph.
void	LayoutGraphHider.unhideNode(Node v, boolean unhideAdjacentEdges) Unhides the given node and if requested its adjacent edges.
static void	ShortestPaths.uniform(Graph graph, Node s, boolean directed, double[] dist) Solves the single-source shortest path problem for arbitrary graphs in which each edge has a uniform cost of 1.0.
static void	ShortestPaths.uniform(Graph graph, Node s, boolean directed, double[] dist, Edge[] pred) Solves the single-source shortest path problem for arbitrary graphs in which each edge has a uniform cost of 1.0.
static void	ShortestPaths.uniform(Graph graph, Node s, boolean directed, INodeMap dist, INodeMap pred) Like ShortestPaths.uniform(Graph, Node, boolean, double[], Edge[]) but uses INodeMaps instead of arrays.

Constructors in com.yworks.yfiles.algorithms with parameters of type Node

Constructor and Description
Edge(Graph g, Node v, Edge e1, Node w, Edge e2, GraphElementInsertion d1, GraphElementInsertion d2) Creates a new edge that belongs to the given graph.
NodeList(Node v) Creates a list that is initialized with a single node provided.
NodeList(Node[] a) Creates a list that is initialized with the nodes provided by the given array of nodes.

Uses of Node in com.yworks.yfiles.layout

Methods in com.yworks.yfiles.layout that return Node

Modifier and Type	Method and Description
Node	CopiedLayoutGraph.createNode(Object originalNode) Creates a node in the copied graph that corresponds to the given original node.
Node	YGraphAdapter.getCopiedNode(INode node) Yields the node that has been created as a copy in YGraph to represent the given node.
Node	CopiedLayoutGraph.getCopiedNode(Object originalNode) Returns the copied node that corresponds to the given original node.
Node	GroupingSupport.getNearestCommonAncestor(Node node1, Node node2) Returns the nearest common ancestor of the given nodes in the hierarchy structure.
abstract Node	LayoutGraph.getOwner(INodeLabelLayout labelLayout) Returns the node to which the given INodeLabelLayout belongs.
Node	DefaultLayoutGraph.getOwner(INodeLabelLayout labelLayout)
Node	CopiedLayoutGraph.getOwner(INodeLabelLayout labelLayout) Returns the edge of the copied graph to which the given IEdgeLabelLayout belongs.
Node	GroupingSupport.getParent(Node node) Returns the parent for the given node.
Node	GroupingSupport.getRepresentative(Node node, Node group) Returns an immediate child of the group node that represents the given node.
Node	GroupingSupport.getRoot() Gets a Node instance associated with the virtual root of the hierarchy tree.

Methods in com.yworks.yfiles.layout with parameters of type Node

Modifier and Type	Method and Description
void	ILabelLayoutFactory.addLabelLayout(Node node, INodeLabelLayout labelLayout) Adds the given node label layout to the given node.
static void	LayoutGraphUtilities.alignNodeLayouts(LayoutGraph graph, NodeList nodes, Node referenceNode, boolean vertical, NodeAlignment mode) Aligns the specified nodes either vertically or horizontally according to the specified node alignment mode.
Rectangle2D	MinimumSizeGroupBoundsCalculator.calculateBounds(LayoutGraph graph, Node groupNode, NodeList children) Calculates the bounds of the given group node, enlarges the bounds by the insets associated with the group node and makes sure that the size of the group node obeys the associated minimum size.
Rectangle2D	InsetsGroupBoundsCalculator.calculateBounds(LayoutGraph graph, Node groupNode, NodeList children) Calculates the bounds of the given group node and enlarges the bounds by the insets associated with the group node.
Rectangle2D	IGroupBoundsCalculator.calculateBounds(LayoutGraph graph, Node groupNode, NodeList children) Calculates the bounds of the given group node that contains the given list of child nodes.
protected Rectangle2D	InsetsGroupBoundsCalculator.createEnlargedBounds(LayoutGraph graph, Node groupNode, NodeList children, Rectangle2D bounds) Enlarges the given graph bounds by the insets associated with the given group node.
INodeLabelLayout	ILabelLayoutFactory.createLabelLayout(Node node, YOrientedRectangle orientedBox) Creates a new ILabelLayout for the given node.
INodeLabelLayout	ILabelLayoutFactory.createLabelLayout(Node node, YOrientedRectangle orientedBox, INodeLabelLayoutModel model) Creates a new ILabelLayout for the given node.
static void	ReverseEdgesStage.findReversedTreeEdges(LayoutGraph graph, Node root, IDataAcceptor reversedEdges) Marks edges in a tree-structured graph component that need to be reversed to make the specified node the root of the tree component.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, Node node) Returns the bounding box of the given node.
YRectangle	LayoutGraph.getBoundingBox(Node node) Returns the rectangle describing the bounding box of the given node.
YPoint	LayoutGraph.getCenter(Node node) Returns the center coordinates of the given node.
double	LayoutGraph.getCenterX(Node node) Returns the x-coordinate of the given node's center.
double	LayoutGraph.getCenterY(Node node) Returns the y-coordinate of the given node's center.
NodeList	GroupingSupport.getChildren(Node parent) Returns the direct children of the given group node.
NodeList	GroupingSupport.getDescendants(Node parent) Returns all descendants of the given group node.
EdgeList	GroupingSupport.getEdgesGoingIn(Node group) Returns all edges crossing the bounds of the given group node such that their targets are inside the group node while their sources lie outside the group node.
EdgeList	GroupingSupport.getEdgesGoingOut(Node group) Returns all edges crossing the bounds of the given group node such that their sources are inside the group node while their targets lie outside the group node.
static NodeHalo	NodeHalo.getHalo(LayoutGraph graph, Node node) Returns the NodeHalo associated with the given node.
static YRectangle	NodeHalo.getHaloBox(LayoutGraph graph, Node node) Returns a YRectangle instance with the bounds of the given node including its NodeHalo.
double	LayoutGraph.getHeight(Node node) Returns the height of the given node.
abstract INodeLabelLayout[]	LayoutGraph.getLabelLayout(Node node) Returns the layout information for all labels associated with the given node.
INodeLabelLayout[]	DefaultLayoutGraph.getLabelLayout(Node node)
INodeLabelLayout[]	CopiedLayoutGraph.getLabelLayout(Node copiedNode) Returns the layout information for all labels associated with the given node of the copied graph.
abstract INodeLayout	LayoutGraph.getLayout(Node node) Returns the layout information for the given node.
INodeLayout	DefaultLayoutGraph.getLayout(Node node)
INodeLayout	CopiedLayoutGraph.getLayout(Node copiedNode) Returns the layout information for the given node of the copied graph.
YPoint	LayoutGraph.getLocation(Node node) Returns the coordinates of the given node's upper-left corner.
Node	GroupingSupport.getNearestCommonAncestor(Node node1, Node node2) Returns the nearest common ancestor of the given nodes in the hierarchy structure.
static double	LayoutGraphUtilities.getNodeDistance(LayoutGraph graph, Node node1, Node node2) Returns the distance between the centers of the two given nodes.
INode	YGraphAdapter.getOriginalNode(Node node) Yields the original node from the original IGraph that the given node has been created for.
Object	CopiedLayoutGraph.getOriginalNode(Node copiedNode) Returns the original node that corresponds to the given copied node.
Node	GroupingSupport.getParent(Node node) Returns the parent for the given node.
Node	GroupingSupport.getRepresentative(Node node, Node group) Returns an immediate child of the group node that represents the given node.
YDimension	LayoutGraph.getSize(Node node) Returns the size of the given node.
double	LayoutGraph.getWidth(Node node) Returns the width of the given node.
double	LayoutGraph.getX(Node node) Returns the x-coordinate of the given node's upper-left corner.
double	LayoutGraph.getY(Node node) Returns the y-coordinate of the given node's upper-left corner.
boolean	GroupingSupport.hasChildren(Node node) Determines whether or not the given node is a group node with children.
boolean	GroupingSupport.isGroupNode(Node node) Determines whether or not the given node is a group node.
void	LayoutGraph.moveBy(Node node, double dx, double dy) Moves the upper-left corner of a node by a given vector.
static void	LayoutGraphUtilities.moveNode(LayoutGraph graph, Node node, double dx, double dy) Moves the given node by the vector (dx,dy).
void	ILabelLayoutFactory.removeLabelLayout(Node node, INodeLabelLayout labelLayout) Removes the given node label layout from the given node.
static void	LayoutGraphUtilities.roundNodeLayout(LayoutGraph graph, Node node) Rounds the location and size of the given node to integer values.
void	LayoutGraph.setCenter(Node node, double x, double y) Specifies the center coordinates of the given node.
void	LayoutGraph.setCenter(Node node, YPoint position) Specifies the center coordinates of the given node.
void	DefaultLayoutGraph.setLabelLayout(Node node, INodeLabelLayout layout) Specifies the layout information for all associated labels of the given node in case there is only one label.
void	DefaultLayoutGraph.setLabelLayout(Node node, INodeLabelLayout[] layout) Specifies the layout information for all associated labels of the given node.
void	DefaultLayoutGraph.setLayout(Node node, INodeLayout layout) Specifies the layout information for the given node.
void	LayoutGraph.setLocation(Node node, double x, double y) Specifies the coordinates of the upper-left corner of the given node.
void	LayoutGraph.setLocation(Node node, YPoint position) Specifies the coordinates of the upper-left corner of the given node.
void	LayoutGraph.setSize(Node node, double width, double height) Specifies the width and height of the given node.
void	LayoutGraph.setSize(Node node, YDimension size) Specifies the size of the given node.

Uses of Node in com.yworks.yfiles.layout.hierarchic

Methods in com.yworks.yfiles.layout.hierarchic that return Node

Modifier and Type	Method and Description
default Node	IItemFactory.createBendNode(ILayer layer, Edge edge) Creates a bend Node for the given Edge in the given ILayer and assigns it to the given SwimlaneDescriptor instance.
Node	IItemFactory.createBendNode(ILayer layer, Edge edge, SwimlaneDescriptor laneDescriptor) Creates a bend Node for the given Edge in the given ILayer and assigns it to the given SwimlaneDescriptor instance.
Node	IItemFactory.createConnectorProxyForGroup(Node groupNode, Object groupId, ILayer layer, Edge edge) Creates a dummy Node that mimics a connector to a group Node.
Node	IItemFactory.createContentConnectorProxyForGroup(Node groupNode, Object groupId, ILayer layer, Edge e) Creates a dummy node that mimics a connector to a group node from a descendant.
Node	IItemFactory.createDistanceNode(ILayer layer, Rectangle2D size, Edge[] edges) Creates a spacer Node for the drawing phase using the given bounds in the given ILayer.
Node	IItemFactory.createEdgeGroupNode(ILayer layer, Object groupId) Creates an edge group Node in the given ILayer.
Node	IItemFactory.createGroupBorderNode(Node groupNode, ILayer layer, NodeDataType type) Creates a group boundary Node for a group node in the given ILayer.
Node	IItemFactory.createGroupLayerDummyNode() Create a dummy Node for a group layer.
default Node	IItemFactory.createProxyNode(Edge edge, boolean source) Creates a proxy Node for an Edge during the drawing phase, changing the Edge to end/start at the proxy and assigns it to a SwimlaneDescriptor instance.
Node	IItemFactory.createProxyNode(Edge edge, boolean source, SwimlaneDescriptor laneDescriptor) Creates a proxy Node for an Edge during the drawing phase, changing the Edge to end/start at the proxy and assigns it to a SwimlaneDescriptor instance.
Node	IItemFactory.createRecursiveEdgeDummy(ILayer layer, Edge edge, SwimlaneDescriptor laneDescriptor) Creates a dummy Node that represents a bend node of a recursive Edge.
default Node	IItemFactory.createSameLayerSideProxy(ILayer inLayer, Node forNode, Edge edge) Creates a proxy Node for a same-layer Edge during the drawing phase that ends at the side of a node.
Node	IItemFactory.createSameLayerSideProxy(ILayer inLayer, Node forNode, Edge edge, SwimlaneDescriptor sld) Creates a proxy Node for a same-layer Edge during the drawing phase that ends at the side of a node.
Node	IItemFactory.createSameLayerSwitchProxy(ILayer layer, Edge edge) Creates a same-layer switch proxy Node (switching between two same-layer Edges on two different sides of the layer).
Node	INodeData.getAssociatedNode() Gets the associated Node of this INodeData instance (in case of e.g.
Node	IEdgeData.getAssociatedNode() Gets the Node associated with this IEdgeData instance.
Node	INodeData.getGroupNode() Gets the group node this node belongs to.
Node	INodeData.getParentGroupNode() Gets the parent group node of the Node of this INodeData instance (if any).
Node	GroupingSupport.getParentNode(Node node) Returns the parent group node of the given Node or null if the given node is a top-level node.

Methods in com.yworks.yfiles.layout.hierarchic with parameters of type Node

Modifier and Type	Method and Description
void	ILayer.add(Node node) Adds a newly created Node to this ILayer instance.
void	AbstractPortConstraintOptimizer.SameLayerData.addDummyNode(Node sameLayerDummy, Edge originalEdge) Adds a given dummy Node to this AbstractPortConstraintOptimizer.SameLayerData instance and associates it with the given original (same-layer) Edge.
void	SelfLoopCalculator.calculateSelfLoops(LayoutGraph graph, Node node, IDataProvider spc, IDataProvider tpc) Calculates all self-loops at the given node of the given input graph.
void	SelfLoopCalculator.calculateSelfLoops(LayoutGraph graph, Node node, YList selfLoops, IDataProvider spc, IDataProvider tpc) Convenience method that calculates a list of self-loops that belong to a given node.
void	IItemFactory.convertToLabelNode(Node dummyNode) Converts a given Node to a label node.
default INodeData	IItemFactory.createBendNodeData(Node node, Edge edge) Creates a INodeData object for a bend Node and associates it with the Node.
INodeData	IItemFactory.createBendNodeData(Node node, Edge edge, SwimlaneDescriptor laneDescriptor) Creates a INodeData object for a bend Node and associates it with the Node.
Node	IItemFactory.createConnectorProxyForGroup(Node groupNode, Object groupId, ILayer layer, Edge edge) Creates a dummy Node that mimics a connector to a group Node.
Node	IItemFactory.createContentConnectorProxyForGroup(Node groupNode, Object groupId, ILayer layer, Edge e) Creates a dummy node that mimics a connector to a group node from a descendant.
Edge	IItemFactory.createDummyEdge(Node newSource, Node newTarget, Edge oldEdge, boolean sourceEnd, boolean targetEnd) Creates a dummy Edge using the given data.
INodeData	IItemFactory.createEdgeGroupNodeData(Node node, Object groupId, boolean source) Creates a INodeData object for an edge group Node and associates it with the Node.
Edge	IItemFactory.createGroupBorderEdge(Node source, Node target) Creates an Edge that connects two group border Nodes.
Node	IItemFactory.createGroupBorderNode(Node groupNode, ILayer layer, NodeDataType type) Creates a group boundary Node for a group node in the given ILayer.
Edge	IItemFactory.createGroupNodeConnectorEdge(Node groupNode1, Node groupNode2, Edge representative) Creates a group node connector Edge between two group Nodes.
INodeData	IItemFactory.createNormalNodeData(Node node) Creates a INodeData object for a normal Node and associates it with the Node.
INodeData	IItemFactory.createProxyNodeData(Node node, Node proxy, Edge edge) Creates a INodeData object for a proxy Node and associates it with the proxy node.
Edge	IItemFactory.createRecursiveDummyEdge(Node newSource, Node newTarget, Edge oldEdge, boolean sourceEnd, boolean targetEnd) Creates a dummy edge that belongs to a recursive Edge.
INodeData	IItemFactory.createRecursiveEdgeNodeData(Node node, Edge edge, SwimlaneDescriptor laneDescriptor) Creates a INodeData for a dummy Node of a recursive Edge.
Edge	IItemFactory.createRedirectedGroupEdge(Node newSource, Node newTarget, Edge groupEdge) Creates a redirected Edge to replace an Edge connected to a group Node.
Edge	IItemFactory.createReverseDummyEdge(Node newSource, Node newTarget, Edge oldEdge, boolean sourceEnd, boolean targetEnd) Creates a reversed dummy Edge using the given data.
Edge	IItemFactory.createSameLayerProxy(ILayer layer, Edge edge, Node toProxy) Creates a same-layer Edge proxy connecting a newly created proxy Node and a given proxy Node in the given ILayer.
default Node	IItemFactory.createSameLayerSideProxy(ILayer inLayer, Node forNode, Edge edge) Creates a proxy Node for a same-layer Edge during the drawing phase that ends at the side of a node.
Node	IItemFactory.createSameLayerSideProxy(ILayer inLayer, Node forNode, Edge edge, SwimlaneDescriptor sld) Creates a proxy Node for a same-layer Edge during the drawing phase that ends at the side of a node.
void	IItemFactory.destroyDistanceNode(Node distanceNode) Destroys a spacer Node for the drawing phase created using IItemFactory.createDistanceNode(ILayer, Rectangle2D, Edge[]).
Edge	IItemFactory.destroyProxyNode(Node proxyNode) Destroys a proxy Node created using IItemFactory.createProxyNode(Edge, boolean, SwimlaneDescriptor) for the drawing phase.
void	IItemFactory.destroySameLayerSideProxy(Node proxyNode) Destroys a proxy Node created using IItemFactory.createProxyNode(Edge, boolean, SwimlaneDescriptor) for the drawing phase.
Edge	IItemFactory.destroySameLayerSwitchProxy(Node node) Destroys a same-layer switch proxy Node created using IItemFactory.createSameLayerSwitchProxy(ILayer, Edge).
NodeList	GroupingSupport.getChildren(Node groupNode) Returns the direct children of the given group node.
NodeList	GroupingSupport.getDescendants(Node groupNode) Returns the descendant Nodes of the given group node.
protected double	SimplexNodePlacer.getLayerAlignment(LayoutGraph graph, ILayoutDataProvider ldp, Node node, int layerIndex, double minLayerHeight) Returns the alignment of the node with a specified layer.
protected double	AsIsLayerer.getMax(LayoutGraph graph, Node node) Callback used for calculating the lower (max) value of a given node.
protected double	AsIsLayerer.getMin(LayoutGraph graph, Node node) Callback used for calculating the upper (min) value of a given node.
double	TypeBasedDrawingDistanceCalculator.getMinDistance(LayoutGraph graph, ILayer layer, ILayoutDataProvider ldp, Node left, Node right)
double	IDrawingDistanceCalculator.getMinDistance(LayoutGraph graph, ILayer layer, ILayoutDataProvider ldp, Node left, Node right) Main interface method called by INodePlacer instances to determine the minimum distance between Nodes of same layer.
double	DefaultDrawingDistanceCalculator.getMinDistance(LayoutGraph graph, ILayer layer, ILayoutDataProvider ldp, Node left, Node right) Determines the minimum distance between two Nodes of the same layer.
protected double	SimplexNodePlacer.getMinDistance(LayoutGraph graph, ILayer layer, Node predNode, Node succ) Specifies the minimum allowed distance between two nodes of the same given layer.
protected double	SelfLoopCalculator.getMinimumNodeDistance(LayoutGraph graph, Node node) Returns the minimum distance between two nodes associated with the given node.
INodeData	ILayoutDataProvider.getNodeData(Node node) Returns the INodeData instance associated with the given Node.
Edge	AbstractPortConstraintOptimizer.SameLayerData.getOriginalEdge(Node sameLayerDummy) Returns the original (same-layer) edge associated with the given dummy Node.
Node	GroupingSupport.getParentNode(Node node) Returns the parent group node of the given Node or null if the given node is a top-level node.
protected double	DefaultPortAllocator.getPortBorderGap(LayoutGraph graph, ILayoutDataProvider ldp, Node node, int sideIndex, double sideLength, int edgeCount) Callback method used for determining the port border gap for each node and side.
protected double	DefaultPortAllocator.getPortBorderGapRatio(LayoutGraph graph, ILayoutDataProvider ldp, Node node, int sideIndex, double sideLength, int edgeCount) Callback method used for determining the port border gap ratio.
protected double	DefaultPortAllocator.getPortDistanceDelta(LayoutGraph graph, ILayoutDataProvider ldp, Node node, int sideIndex, double sideLength, int edgeCount, double portBorderGap) Callback method used for determining the distance between two adjacent ports.
boolean	GroupingSupport.isDescendant(Node node, Node groupNode) Returns whether or not the given node is a descendant Node of the given group node.
protected boolean	SimplexNodePlacer.isFixedNode(LayoutGraph graph, ILayoutDataProvider provider, Node node, boolean inLayer) Returns whether or not the given node should be treated as a node with fixed (given) coordinates.
boolean	GroupingSupport.isGroupNode(Node node) Returns whether or not the given Node is a non-empty group node.
protected void	PortCandidateOptimizer.optimizeAfterSequencing(Node node, Comparator<Object> inEdgeOrder, Comparator<Object> outEdgeOrder, LayoutGraph graph, ILayoutDataProvider ldp, IItemFactory itemFactory)
protected abstract void	AbstractPortConstraintOptimizer.optimizeAfterSequencing(Node node, Comparator<Object> inEdgeOrder, Comparator<Object> outEdgeOrder, LayoutGraph graph, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns new temporary port constraints to a given node of the graph after the order of the nodes in each layer has been determined.
void	ILayer.remove(Node node) Removes a Node from this ILayer instance.
void	IItemFactory.unconvertToLabelNode(Node labelNode) Reverts a label node to the normal Node.
void	GroupingSupport.IVisitor.visit(Node node, Node parentNode) Visits the descendants of a group node.
void	GroupingSupport.visitDescendants(Node groupNode, GroupingSupport.IVisitor visitor) Visits all descendant Nodes of the given group node.

Uses of Node in com.yworks.yfiles.layout.labeling

Methods in com.yworks.yfiles.layout.labeling with parameters of type Node

Modifier and Type	Method and Description
protected void	AbstractMISLabeling.foundHaloOverlap(LabelCandidate labelCandidate, Node node, YRectangle haloRect) Indicates that an overlap between a LabelCandidate and a NodeHalo of the input graph has been found.
protected void	AbstractMISLabeling.foundNodeOverlap(LabelCandidate labelCandidate, Node node, YRectangle nodeBox) Indicates that an overlap between a LabelCandidate and a Node of the input graph has been found.

Uses of Node in com.yworks.yfiles.layout.multipage

Methods in com.yworks.yfiles.layout.multipage that return Node

Modifier and Type	Method and Description
Node	IElementFactory.createConnectorNode(LayoutContext context, YList edgesIds, Object representedNodeId) Callback method for creating a node of type NodeType.CONNECTOR.
Node	DefaultElementFactory.createConnectorNode(LayoutContext context, YList edgeIds, Object representedNodeId)
Node	LayoutContext.createNode(Object sameDataElementId) All methods of the IElementFactory have to use this method to create a node.
Node	IElementFactory.createProxyNode(LayoutContext context, Object origNodeId) Callback method for creating a node of type NodeType.PROXY.
Node	DefaultElementFactory.createProxyNode(LayoutContext context, Object origNodeId)
Node	IElementFactory.createProxyReferenceNode(LayoutContext context, Object referringProxyId) Callback method for creating a node of type NodeType.PROXY_REFERENCE.
Node	DefaultElementFactory.createProxyReferenceNode(LayoutContext context, Object referringProxyId)
Node	LayoutContext.getOriginalNode(Object id) Returns the node of the input graph with the given ID or null if there is no such node.
Node	LayoutContext.getPageNode(Object id) Returns the node of a page graph (a graph that represents the result of the multi-page layout) with the given ID or null if there is no such node.
Node	INodeInfo.getReferencingNode() Gets the node that refers to the one associated with this info object.
Node	INodeInfo.getRepresentedNode() Gets the node of the input graph that is represented by the node associated with this info object.

Methods in com.yworks.yfiles.layout.multipage with parameters of type Node

Modifier and Type	Method and Description
void	LayoutContext.addNodeLabel(INodeLabelLayout label, Node labeledElement) Adds a label to a given node.
Edge	IElementFactory.createConnectorEdge(LayoutContext context, Node connector, Node opposite, Object origEdgeId, boolean atTarget) Callback method for creating an edge of type EdgeType.CONNECTOR.
Edge	DefaultElementFactory.createConnectorEdge(LayoutContext context, Node connector, Node opposite, Object origEdgeId, boolean atTarget)
Edge	LayoutContext.createEdge(Node source, Node target, Object sameDataElementId) All methods of the IElementFactory have to use this method to create an edge.
Edge	IElementFactory.createProxyEdge(LayoutContext context, Node proxyNode, Node opposite, Object replacingEdgeId, Object origNodeId) Callback method for creating an edge of type EdgeType.PROXY.
Edge	DefaultElementFactory.createProxyEdge(LayoutContext context, Node proxyNode, Node opposite, Object replacingEdgeId, Object origNodeId)
Edge	IElementFactory.createProxyReferenceEdge(LayoutContext context, Node proxyReference, Node opposite, Object referencingCopyId) Callback method for creating an edge of type EdgeType.PROXY_REFERENCE.
Edge	DefaultElementFactory.createProxyReferenceEdge(LayoutContext context, Node proxyReference, Node opposite, Object referencingCopyId)
INodeInfo	MultiPageLayoutResult.getNodeInfo(Node node)
INodeInfo	LayoutContext.getNodeInfo(Node node)
INodeInfo	IElementInfoManager.getNodeInfo(Node node) Returns the node information object of the given node.
protected boolean	MultiPageLayout.removeConnectorPair(Node connector1, Node connector2, YList originalEdgeIds, LayoutContext context) This method is called during a postprocessing step that reduces the number of connectors.
boolean	LayoutContext.removeNodeLabel(INodeLabelLayout label, Node labeledElement) Removes a label from a given node.

Uses of Node in com.yworks.yfiles.layout.organic

Methods in com.yworks.yfiles.layout.organic with parameters of type Node

Modifier and Type	Method and Description
YPoint	InteractiveOrganicLayout.getCenter(Node node) Polls the current coordinates of the center of the given node.
double	InteractiveOrganicLayout.getCenterX(Node node) Polls the current x-coordinate of the center location of the given node.
double	InteractiveOrganicLayout.getCenterY(Node node) Polls the current y-coordinate of the center location of the given node.
double	InteractiveOrganicLayout.getStress(Node node) Polls the current stress value of a given node.
void	InteractiveOrganicLayout.setCenter(Node node, double x, double y) Schedules an update for the center location of the given node.
void	InteractiveOrganicLayout.setCenterX(Node node, double x) Schedules an update for the center location's x-coordinate of the given node.
void	InteractiveOrganicLayout.setCenterY(Node node, double y) Schedules an update for the center location's y-coordinate of the given node.
void	InteractiveOrganicLayout.setInertia(Node node, double inertia) Schedules an update for the inertia of the given node.
void	InteractiveOrganicLayout.setRadius(Node node, double radius) Schedules an update for the radius of the given node.
void	InteractiveOrganicLayout.setStress(Node node, double stress) Schedules an update for the stress value of the given node.

Uses of Node in com.yworks.yfiles.layout.router.polyline

Methods in com.yworks.yfiles.layout.router.polyline with parameters of type Node

Modifier and Type	Method and Description
List<Object>	GraphPartition.getCells(Node node) Returns all PartitionCells that are completely covered by the bounds of the given node.

Uses of Node in com.yworks.yfiles.layout.seriesparallel

Methods in com.yworks.yfiles.layout.seriesparallel with parameters of type Node

Modifier and Type	Method and Description
void	IPortAssignment.assignPorts(LayoutGraph graph, Node node) Assigns both the incoming edges' target ports as well as all source ports for the outgoing edges.
void	DefaultPortAssignment.assignPorts(LayoutGraph graph, Node node) Places the ports of edges connecting to the given node according to the port assignment mode.

Uses of Node in com.yworks.yfiles.layout.tree

Methods in com.yworks.yfiles.layout.tree that return Node

Modifier and Type	Method and Description
protected Node	BalloonLayout.determineRoot() Determines the root node of BalloonLayout.graph according to the chosen root node policy.
protected Node[]	TreeLayout.getRootsArray(Node root) Returns an array of the nodes that will be laid out.

Methods in com.yworks.yfiles.layout.tree with parameters of type Node

Modifier and Type	Method and Description
protected void	DefaultPortAssignment.assignChildEdgeSourcePort(LayoutGraph graph, Node node, Edge edge, int index) Assigns relative coordinates to the source port of the outgoing edge to a child of the given node.
protected void	DefaultPortAssignment.assignParentEdgeTargetPort(LayoutGraph graph, Node node, Edge edge) Assigns relative coordinates to the target port of the incoming edge from the parent of the given node.
void	IPortAssignment.assignPorts(LayoutGraph graph, Node node) Places the ports of edges connecting to the given node.
void	DefaultPortAssignment.assignPorts(LayoutGraph graph, Node node) Places the ports of edges connecting to the given node according to the port assignment mode.
protected double	BalloonLayout.calculateAngles(Node root) Calculates the wedge angle that has to be reserved for the subtree rooted at the given node scaling the distance with the given scale factor.
protected double	BalloonLayout.calculateAngles(Node root, double scaleFactor) Calculates the wedge angle that has to be reserved for the subtree rooted at the given node scaling the distance with the given scale factor.
protected void	BalloonLayout.calculateChildArrangement(Node root) Calculates a child node arrangement for a given root node of the tree.
protected void	DefaultNodePlacer.calculateParentConnector(LayoutGraph graph, Node localRoot, INodeLayout rootLayout, TreeLayout.SubtreeShape subtreeShape, Edge parentEdge, IEdgeLayout parentEdgeLayout, byte direction) Calculates the bends for the connector to the parent node.
protected void	AspectRatioTreeLayout.createBends(IEdgeLayout edgeLayout, Node localRoot, Node child, RootPlacement rootPlacement, SubtreeArrangement routingPolicy) Adds bends to the given IEdgeLayout.
protected TreeLayout.SubtreeShape	TreeLayout.createNodeShape(Node node) Creates a TreeLayout.SubtreeShape for the given node that consists only of the bounds of this particular node.
IProcessor	LeafNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates an optional IProcessor for pre- and post-processing.
IProcessor	LayeredNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates a IProcessor that distributes the nodes over the layers.
IProcessor	INodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates an optional IProcessor for pre- and post-processing.
IProcessor	GroupedNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates a IProcessor that prepares the graph for edge grouping.
IProcessor	FreeNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates a IProcessor that will change all descending INodePlacers to FreeNodePlacer.
IProcessor	DendrogramNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates an optional IProcessor for pre- and post-processing.
IProcessor	DelegatingNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates a IProcessor that partitions child nodes of the current root node into two subsets.
IProcessor	AssistantNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates a IProcessor that prepares the graph for placing assistant node.
IProcessor	AbstractRotatableNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates an optional IProcessor for pre- and post-processing.
IProcessor	AbstractNodePlacer.createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates an optional IProcessor for pre- and post-processing.
protected ParentConnectorDirection	SimpleNodePlacer.determineChildConnector(Node child) Provides ParentConnectorDirection.NORTH as connector direction for the child nodes.
protected ParentConnectorDirection	LeftRightNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
protected ParentConnectorDirection	LayeredNodePlacer.determineChildConnector(Node child) Returns ParentConnectorDirection.NORTH for every given child node.
protected ParentConnectorDirection	GridNodePlacer.determineChildConnector(Node child) Returns ParentConnectorDirection.NORTH for every given child node.
protected ParentConnectorDirection	FreeNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
protected ParentConnectorDirection	DoubleLineNodePlacer.determineChildConnector(Node child) Returns ParentConnectorDirection.NORTH for every given child node.
protected ParentConnectorDirection	DelegatingNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
protected ParentConnectorDirection	DefaultNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node depending on the selected child placement.
protected ParentConnectorDirection	BusNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
protected ParentConnectorDirection	AssistantNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
protected ParentConnectorDirection	AspectRatioNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node depending on whether or not the child nodes are arranged horizontally.
protected abstract ParentConnectorDirection	AbstractRotatableNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
protected abstract ParentConnectorDirection	AbstractNodePlacer.determineChildConnector(Node child) Determines a connector direction for the given child node.
void	LeftRightNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Determines the direction of the child connectors according to which side of the bus the child is assigned.
void	LeafNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Does nothing because leaf nodes don't have children so there are no child connectors.
void	INodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Provides the direction of the connector to the SubtreeShape for each child node.
void	GroupedNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Delegates to the INodePlacer responsible for arranging the nodes in one group.
void	DendrogramNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Provides ParentConnectorDirection.NORTH for all children.
void	DelegatingNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Does nothing.
void	BusNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Determines connector directions depending on whether or not the child nodes are placed above or below the bus.
void	AssistantNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Delegates the calculation of the child connectors to the LeftRightNodePlacer which arranges the assistant nodes.
void	AbstractRotatableNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Provides the direction of the connector to the SubtreeShape for each child node.
void	AbstractNodePlacer.determineChildConnectors(Node localRoot, IDataMap connectorMap) Provides the direction of the connector to the SubtreeShape for each child node.
protected double	AspectRatioTreeLayout.getAspectRatio(Node localRoot) Retrieves the aspect ratio for the subtree that is rooted at the given node.
protected INodePlacer	TreeLayout.getNodePlacer(Node localRoot) Returns the INodePlacer instance that is used for the placement of the local root node and the TreeLayout.SubtreeShapes.
protected RotatedSubtreeShape	AbstractRotatableNodePlacer.getNodeShape(Node node) Returns the rotated subtree shape for the given node.
protected TreeLayout.SubtreeShape	AbstractNodePlacer.getNodeShape(Node node) Returns the TreeLayout.SubtreeShape for the given node.
protected Comparator<Object>	TreeLayout.getOutEdgeComparer(Node localRoot) Returns the Comparator instance that will sort the outgoing edges connecting to the given node.
protected IPortAssignment	TreeLayout.getPortAssignment(Node localRoot) Returns the IPortAssignment instance that places the ports of the connecting edges of the given node.
protected PortConstraint	AbstractRotatableNodePlacer.getPortConstraint(Node localRoot) Returns the target PortConstraint for the local root's incoming edge.
protected double	BalloonLayout.getPreferredChildWedge(Node root) Returns the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the given node.
protected Node[]	TreeLayout.getRootsArray(Node root) Returns an array of the nodes that will be laid out.
protected TreeLayout.SubtreeShape	TreeLayout.getSubtreeShape(Node localRoot) Provides access to the TreeLayout.SubtreeShape for the given node.
protected RotatedSubtreeShape	AbstractRotatableNodePlacer.getSubtreeShape(Node node) Returns the rotated subtree shape for the subtree rooted at the given node.
protected TreeLayout.SubtreeShape	AbstractNodePlacer.getSubtreeShape(Node node) Returns the TreeLayout.SubtreeShape for the subtree rooted at the given node.
protected INodeCursor	AspectRatioTreeLayout.getSuccessors(Node localRoot) Retrieves all children of the given local root.
protected TreeLayout.SubtreeShape	TreeLayout.layoutRoot(Node localRoot) Calculates the layout for the given root node and its subtrees.
TreeLayout.SubtreeShape	LeafNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Creates a TreeLayout.SubtreeShape for the local root node (a leaf node in this case) and adds target points to the incoming edge.
TreeLayout.SubtreeShape	INodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the SubtreeShapes of the local root and its children and routes the edges that connect them.
TreeLayout.SubtreeShape	GroupedNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the groups of TreeLayout.SubtreeShapes according to their group IDs.
TreeLayout.SubtreeShape	DendrogramNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the SubtreeShapes of the local root and its children as a dendrogram.
TreeLayout.SubtreeShape	DelegatingNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the TreeLayout.SubtreeShapes of the child nodes using the two delegate node placers retrieved with PrimaryPlacer and SecondaryPlacer.
TreeLayout.SubtreeShape	AssistantNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Delegates the arrangement of TreeLayout.SubtreeShapes to an instance of LeftRightNodePlacer.
TreeLayout.SubtreeShape	AbstractRotatableNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Initializes the local data structures and then delegates the work to the abstract variant of this method (AbstractRotatableNodePlacer.placeSubtree(Node, ParentConnectorDirection)).
TreeLayout.SubtreeShape	AbstractNodePlacer.placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Initializes the local data structures and then delegates the work to the abstract variant of this method (AbstractNodePlacer.placeSubtree(Node, ParentConnectorDirection)).
protected RotatedSubtreeShape	SimpleNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the children of the local root node in a single row.
protected RotatedSubtreeShape	LeftRightNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the subtree shapes of the children left and right of a common vertical bus.
protected RotatedSubtreeShape	LayeredNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the children of local root in layers.
protected RotatedSubtreeShape	GridNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the children of a local root node in a grid.
protected RotatedSubtreeShape	FreeNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Merges the rotated shapes of the given local root and its children and routes the edges between them.
protected RotatedSubtreeShape	DoubleLineNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Places the children of the given local root alternating in two horizontal lines.
protected RotatedSubtreeShape	DelegatingNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the local root relative to the subtree shape of its children.
protected TreeLayout.SubtreeShape	DefaultNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the root node and its children.
protected RotatedSubtreeShape	BusNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Places all children of the local root below and above a bus segment that is shared by the edges.
protected RotatedSubtreeShape	AssistantNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the local root relative to the subtree shape of its children.
protected TreeLayout.SubtreeShape	AspectRatioNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the SubtreeShapes of children of the local root node in rows or columns that fit the specified aspect ratio.
protected abstract RotatedSubtreeShape	AbstractRotatableNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the local root relative to the rotated subtree shapes of its children.
protected abstract TreeLayout.SubtreeShape	AbstractNodePlacer.placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the local root relative to the TreeLayout.SubtreeShape of its children.
protected NodeList	DelegatingNodePlacer.primaryChildren(Node localRoot, LayoutGraph graph) Returns all upper-left children of the local root node.
protected NodeList	DelegatingNodePlacer.secondaryChildren(Node localRoot, LayoutGraph graph) Returns all lower-right children of the local root node.
protected void	BalloonLayout.sortChildNodes(Node root) Sorts the child nodes (successors) of the given node.