Uses of Class
com.yworks.yfiles.layout.LayoutGraph

Packages that use LayoutGraph

Package	Description
com.yworks.yfiles.layout	Provides essential classes and interfaces that constitute the infrastructure for automatic graph layout generation.
com.yworks.yfiles.layout.circular	Provides circular layout style algorithms.
com.yworks.yfiles.layout.genealogy	Provides layout algorithms that are especially suited for genealogical family trees.
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.orthogonal	Provides orthogonal layout style algorithms.
com.yworks.yfiles.layout.partial	Provides class PartialLayout that enables layout of user-specified, distinct parts of a diagram without altering the existing layout of the remainder of the diagram.
com.yworks.yfiles.layout.radial	Provides the radial layout algorithm.
com.yworks.yfiles.layout.router	Provides classes for automatic routing of the edges in a graph.
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 LayoutGraph in com.yworks.yfiles.layout

Subclasses of LayoutGraph in com.yworks.yfiles.layout

Modifier and Type	Class and Description
class	CopiedLayoutGraph A CopiedLayoutGraph is a LayoutGraph that serves as a copy of another graph with layout information.
class	DefaultLayoutGraph DefaultLayoutGraph is a default implementation of LayoutGraph which holds the complete layout information about the graph and its elements.

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

Modifier and Type	Method and Description
LayoutGraph	ILabelLayoutFactory.getGraph() Gets the graph associated with this label factory instance.

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

Modifier and Type	Method and Description
protected void	BendConverter.addedPathForEdge(LayoutGraph graph, Edge edge, NodeList dummyNodes) Adds information to newly created dummy nodes.
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.
static double	GraphTransformer.applyBestFitRotationAngle(LayoutGraph graph, double width, double height) Rotates the given graph so its resulting bounding box fits best to the given bounds.
void	SubgraphLayout.applyLayout(LayoutGraph graph) Delegates the arrangement of the specified subgraph of the given graph to the core layout algorithm.
void	SequentialLayout.applyLayout(LayoutGraph graph) Executes all layout algorithms in the chain, one after the other.
void	SelfLoopRouter.applyLayout(LayoutGraph graph) Delegates the arrangement of nodes and edges to the core layout algorithm and routes the self-loops.
void	ReverseEdgesStage.applyLayout(LayoutGraph graph) Reverses all selected edges before calling the core layout algorithm and restores the original edge direction after the core layout algorithm has finished.
void	RemoveCollinearBendsStage.applyLayout(LayoutGraph graph) Removes collinear bends of the edges in the given graph.
void	RecursiveGroupLayout.applyLayout(LayoutGraph graph) Invokes a recursive traversal through the grouping hierarchy of the given graph during which the specified layout algorithms are applied to the content of the groups.
void	PortPlacementStage.applyLayout(LayoutGraph graph) Corrects the ports of the edges considering PortConstraints and PortCandidates.
void	PortCalculator.applyLayout(LayoutGraph graph) Adjusts the ports after invoking the core layout algorithm.
void	PartitionLayout.applyLayout(LayoutGraph graph) Arranges and places independent partitions in the graph.
void	ParallelEdgeRouter.applyLayout(LayoutGraph graph) Delegates the arrangement of nodes and edges to the core layout algorithm and routes the parallel edges.
void	OrientationLayout.applyLayout(LayoutGraph graph) Prepares the graph for orientation change before calling the core layout algorithm and finishes the orientation change afterwards.
void	NormalizeGraphElementOrderStage.applyLayout(LayoutGraph graph) Enforces the specified order of nodes and order of edges before invoking the core layout algorithm.
void	MultiStageLayout.applyLayout(LayoutGraph layoutGraph) Calculates a layout for the given graph and applies it directly to the graph.
void	MinimumNodeSizeStage.applyLayout(LayoutGraph graph) Resizes all nodes that are smaller than the specified minimum size to that minimum size, executes the core layout algorithm and restores the original sizes afterwards.
void	LayoutMultiplexer.applyLayout(LayoutGraph graph) Retrieves and invokes the layout algorithm that is assigned to the graph.
void	LabelLayoutTranslator.applyLayout(LayoutGraph graph) Translates traditional ILabelLayout information to IDataProvider-based LabelLayoutData.
void	IsolatedGroupComponentLayout.applyLayout(LayoutGraph graph) Calculates the layout based on the current core layout algorithm.
void	ILayoutAlgorithm.applyLayout(LayoutGraph graph) Main layout routine that assigns new layout information to the given graph.
void	HideGroupsStage.applyLayout(LayoutGraph graph) Calculates the layout based on the given core layout algorithm.
void	HandleNaNCoordinatesStage.applyLayout(LayoutGraph graph) Hides all graph elements with NaN-coordinates during core layout and restores them afterwards.
void	GraphLayoutLineWrapper.applyLayout(LayoutGraph graph) Cuts the layout resulting from the core layout algorithm at a specified width/height and shifts the remaining graph into the next row/column until the layout has the desired width/height.
void	FixPortLocationStage.applyLayout(LayoutGraph graph) Restores the locations of strong PortConstraints after invoking the core layout algorithm.
void	FixNodeLayoutStage.applyLayout(LayoutGraph graph) Delegates to the core layout algorithm and moves the fixed point back to its initial location.
void	FixGroupLayoutStage.applyLayout(LayoutGraph graph) Calculates the layout for the given graph, that is, prepares the graph by hiding the content of fixed group nodes for the core layout algorithm, executes it and, finally, restores the graph and routes inter-edges.
void	CurveFittingLayoutStage.applyLayout(LayoutGraph graph) Changes the edge paths of selected edges of the given graph such that they represent piecewise cubic bezier curves which approximate the original points of the path.
void	CompositeLayoutStage.applyLayout(LayoutGraph graph) Executes the pipeline of ILayoutStage and the core layout algorithm which apply the layout to the graph.
void	ComponentLayout.applyLayout(LayoutGraph graph) Delegates the layout calculation for each component separately to the core layout algorithm and optionally arranges the components.
void	BufferedLayout.applyLayout(LayoutGraph graph) Applies the layout calculated by the core layout algorithm to the input graph.
void	BendConverter.applyLayout(LayoutGraph graph) Replaces all bends in the current scope with dummy nodes before invoking the core layout algorithm.
abstract void	AbstractLayoutStage.applyLayout(LayoutGraph graph)
abstract void	MultiStageLayout.applyLayoutCore(LayoutGraph graph) Invokes the core layout algorithm.
void	GraphTransformer.applyLayoutCore(LayoutGraph graph) Applies the selected transformation to the given graph after invoking the optional core layout algorithm.
protected void	AbstractLayoutStage.applyLayoutCore(LayoutGraph graph) Invokes the layout process of the core layout algorithm.
protected void	ComponentLayout.arrangeComponents(LayoutGraph graph, NodeList[] nodes, EdgeList[] edges, YRectangle[] bbox, Rectangle2D[] boxes) Produces a component graph layout.
protected void	ComponentLayout.arrangeFields(LayoutGraph graph, NodeList[] nodes, EdgeList[] edges, YRectangle[] bbox, Rectangle2D[] boxes, boolean circular, boolean fill, boolean fromSketch) Arranges the bounding boxes of the components.
static void	LayoutGraphUtilities.assignReverseLayout(LayoutGraph graph, Edge edge1, Edge edge2) Applies the reversed layout of the first edge to the second edge.
protected Rectangle2D	ComponentLayout.calculateBounds(LayoutGraph graph) Calculates the bounding box of a graph component including NodeHalos.
protected Rectangle2D	FixNodeLayoutStage.calculateBounds(LayoutGraph graph, NodeList fixed) Calculates the bounding box of the specified nodes.
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 YPoint	FixNodeLayoutStage.calculateFixPoint(LayoutGraph graph, NodeList fixed) Calculates the fix point for the specified nodes in the specified graph.
protected void	PortCalculator.calculatePorts(LayoutGraph graph) Performs the actual port calculation on the specified graph instance.
protected void	MultiStageLayout.checkNodeSize(LayoutGraph g) Checks the sizes of the nodes to be non-zero.
static void	LayoutGraphUtilities.clipEdgeOnBounds(LayoutGraph graph, Edge edge) Clips the path of the given edge on the bounding box of the source and target points.
static YPointPath	LayoutGraphUtilities.clipEdgePathOnBounds(LayoutGraph graph, Edge edge) Returns the path of an edge clipped on the bounding box of the source and target node.
static void	LayoutGraphUtilities.clipEdgesOnBounds(LayoutGraph graph) Clips the path of all edges in the graph on the bounding box of their source and target points.
protected void	OrientationLayout.completeOrientationChange(LayoutGraph graph) Applies the desired orientation to the graph.
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.
PortConstraint	PortConstraintConfigurator.createPortConstraintFromSketch(LayoutGraph graph, Edge edge, boolean source, boolean strong) Creates a PortConstraint for the given edge.
void	PortConstraintConfigurator.createPortConstraintsFromSketch(LayoutGraph graph, IEdgeCursor ec, IEdgeMap spcMap, boolean strongSP, IEdgeMap tpcMap, boolean strongTP) Creates PortConstraints for some edges of the given graph.
void	PortConstraintConfigurator.createPortConstraintsFromSketch(LayoutGraph graph, IEdgeMap spcMap, IEdgeMap tpcMap) Creates weak PortConstraints for all edges of the given graph.
static EdgeFlow	LayoutGraphUtilities.determineEdgeFlowDirection(LayoutGraph graph, IDataProvider considerEdges) Determines the main direction of the edge flow by analyzing the current layout of the graph.
static String	LayoutGraphUtilities.edgeLayoutString(LayoutGraph graph, Edge edge) Returns a String representation of the path of the given edge.
static double	GraphTransformer.findBestFitRotationAngle(LayoutGraph graph, double width, double height) Returns the rotation angle for the graph that will result in a layout that fits best to the given bounds.
protected int	ComponentLayout.findGraphComponents(LayoutGraph graph, INodeMap compNumber) Determines which nodes belong to the same graph component.
protected int	IsolatedGroupComponentLayout.findIsolatedGraphComponents(LayoutGraph graph, INodeMap compNumber) Determines the nodes that belong to the same graph component.
void	PartitionLayout.IPartitionFinder.findPartitions(LayoutGraph graph, INodeMap partitionIDMap) Returns a partition ID for each node of an input graph.
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, Edge edge) Returns the bounding box of the given edge.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, IEdgeCursor edges) Returns the bounding box of the edges accessible through the given cursor.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, INodeCursor nodes) Returns the bounding box of the nodes accessible through the given cursor.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges) Returns the bounding box of the nodes and edges accessible through the given cursors.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges, boolean includeLabels) Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels and edge labels.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges, boolean includeNodeLabels, boolean includeEdgeLabels) Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels or edge labels.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, INodeCursor nodes, IEdgeCursor edges, boolean includeNodeLabels, boolean includeEdgeLabels, boolean includeHalos) Returns the bounding box of the nodes and edges accessible through the given cursors, optionally including node labels, edge labels or NodeHalos.
static Rectangle2D	LayoutGraphUtilities.getBoundingBox(LayoutGraph graph, Node node) Returns the bounding box of the given node.
protected ILayoutAlgorithm	LayoutMultiplexer.getCoreLayout(LayoutGraph graph) Returns the core layout algorithm associated with the nodes contained in the given graph.
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.
static ILabelLayoutFactory	LayoutGraphUtilities.getLabelFactory(LayoutGraph graph) Returns the ILabelLayoutFactory for the given graph.
static double	LayoutGraphUtilities.getNodeDistance(LayoutGraph graph, Node node1, Node node2) Returns the distance between the centers of the two given nodes.
static String	LayoutGraphUtilities.getNodePositions(LayoutGraph graph) Returns a String representation of all node positions in the graph.
static double	LayoutGraphUtilities.getPathLength(LayoutGraph graph, Edge edge) Returns the length of the path of the given edge.
static PortConstraint	PortConstraint.getSPC(LayoutGraph graph, Edge e) Returns the source PortConstraint associated with the given edge.
static PortConstraint	PortConstraint.getTPC(LayoutGraph graph, Edge e) Returns the target PortConstraint associated with the given edge.
static boolean	NodeHalo.hasHalos(LayoutGraph graph) Checks whether or not the given graph contains NodeHalo information.
static boolean	PortConstraint.hasPC(LayoutGraph graph, Edge e) Checks whether or not there exist source or target PortConstraints associated with the given edge.
static boolean	PortConstraint.hasSPC(LayoutGraph graph, Edge e) Checks whether or not there exist source PortConstraints associated with the given edge.
static boolean	PortConstraint.hasTPC(LayoutGraph graph, Edge e) Checks whether or not there exist target PortConstraints associated with the given edge.
void	HideGroupsStage.hideGroupNodes(LayoutGraph graph) Hides the group nodes and their incident edges of the input graph.
static boolean	LayoutGraphUtilities.isEdgeOutsideNodes(LayoutGraph graph, Edge edge) Checks whether or not the path of an edge is outside the bounding box of the source and target node.
static boolean	LayoutGraphUtilities.isUsingOctilinearEdgeRoutes(LayoutGraph graph, IDataProvider considerEdges) Determines whether or not most of the edges of the graph are routed octilinear.
static boolean	LayoutGraphUtilities.isUsingOrthogonalEdgeRoutes(LayoutGraph graph, IDataProvider considerEdges) Determines whether or not most of the edges of the graph are routed orthogonally.
protected void	ParallelEdgeRouter.layoutParallelEdges(LayoutGraph graph, IEdgeMap parallelEdges) Assigns a layout to all parallel edges.
protected void	SelfLoopRouter.layoutSelfLoops(LayoutGraph graph) Calculates the routes of the self-loops in the given graph.
static void	LayoutGraphUtilities.moveEdge(LayoutGraph graph, Edge edge, double dx, double dy) Moves all control points of the given edge by the vector (dx,dy).
static void	LayoutGraphUtilities.moveEdges(LayoutGraph graph, IEdgeCursor edges, double dx, double dy) Moves the control points of all edges accessible through the given IEdgeCursor by the vector (dx,dy).
static void	LayoutGraphUtilities.moveNode(LayoutGraph graph, Node node, double dx, double dy) Moves the given node by the vector (dx,dy).
static void	LayoutGraphUtilities.moveNodes(LayoutGraph graph, INodeCursor nodes, double dx, double dy) Moves all nodes accessible through the given INodeCursor by the vector (dx,dy).
static void	LayoutGraphUtilities.moveSubgraph(LayoutGraph graph, IEdgeCursor edges, double dx, double dy) Moves the subgraph induced by the edges accessible through the given IEdgeCursor by the vector (dx,dy).
static void	LayoutGraphUtilities.moveSubgraph(LayoutGraph graph, INodeCursor nodes, double dx, double dy) Moves the subgraph induced by the nodes accessible through the given INodeCursor by the vector (dx,dy).
static boolean	LayoutGraphUtilities.pathIntersectsRect(LayoutGraph graph, Edge edge, Rectangle2D rect) Checks whether or not the path of the given edge intersects the interior of a given rectangular area.
void	PartitionLayout.IPartitionPlacer.placePartitions(LayoutGraph graph, IDataProvider partitionIDDP, IDataProvider interEdgeDP) Arranges the graph while taking partition IDs and inter-edge information into account.
protected void	BendConverter.prepare(LayoutGraph graph) Prepares the graph before calling the core layout algorithm.
protected void	OrientationLayout.prepareOrientationChange(LayoutGraph graph) Prepares the layout for the desired orientation.
static void	LayoutGraphUtilities.removeDuplicateBends(LayoutGraph graph) Removes successive bends that have the same coordinates from all edges in the graph.
static void	LayoutGraphUtilities.removeDuplicateBends(LayoutGraph graph, Edge edge) Removes successive bends that have the same coordinates from the given edge.
static void	LayoutGraphUtilities.resetPath(LayoutGraph graph, Edge edge) Assigns a trivial path which has no control points to the specified edge.
static void	LayoutGraphUtilities.resetPath(LayoutGraph graph, Edge edge, boolean resetPorts) Assigns a trivial path which has no control points to the specified edge.
static void	LayoutGraphUtilities.resetPaths(LayoutGraph graph) Assigns a trivial path which has no control points to all edges in the specified graph.
static void	LayoutGraphUtilities.resetPaths(LayoutGraph graph, boolean resetPorts) Assigns a trivial path which has no control points to all edges in the specified graph.
static void	LayoutGraphUtilities.resetPorts(LayoutGraph graph) Sets the ports of all edges in the graph to the center of the nodes.
protected void	BendConverter.restore(LayoutGraph graph) Restores the structure of the graph after the core layout algorithm has finished.
void	ReverseEdgesStage.reverseEdge(LayoutGraph graph, Edge edge) Reverses the specified edge in the specified graph.
void	ReverseEdgesStage.reverseEdges(LayoutGraph graph) Reverses selected edges in the specified graph.
static void	LayoutGraphUtilities.roundEdgeLayout(LayoutGraph graph, Edge edge) Rounds the locations of the control points and ports of the given edge to integer values.
static void	LayoutGraphUtilities.roundLayout(LayoutGraph graph) Rounds coordinates and sizes in the layout of an entire graph to integer values.
static void	LayoutGraphUtilities.roundNodeLayout(LayoutGraph graph, Node node) Rounds the location and size of the given node to integer values.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance, boolean joinEnds) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance, boolean joinEnds, double absJoinDist) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge1, Edge edge2, double lineDistance, boolean joinEnds, double absJoinDist, double relJoinDist) Routes two edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1, boolean joinEnds) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1, boolean joinEnds, double absJoinDist) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
static void	LayoutGraphUtilities.routeEdgesParallel(LayoutGraph graph, Edge edge, EdgeList edges, double lineDistance, boolean adjustE1, boolean joinEnds, double absJoinDist, double relJoinDist) Routes a list of edges which are incident to the same nodes in parallel, optionally joining the end points.
protected void	RecursiveGroupLayout.routeInterEdges(LayoutGraph graph, EdgeList interEdges) Reroutes the given inter-edges using the current edge routing algorithm.
void	PartitionLayout.IInterEdgeRouter.routeInterEdges(LayoutGraph graph, IDataProvider partitionIDDP, IDataProvider interEdgeDP) Routes inter-edges of the partitioned graph.
static void	LayoutGraphUtilities.routeSelfLoop(LayoutGraph graph, Edge edge) Routes a self-loop.
static void	GraphTransformer.setMaximalBounds(LayoutGraph graph, double x, double y, double w, double h) Fits the given graph into the specified rectangular bounds.
protected void	ComponentLayout.setOrigin(LayoutGraph graph, NodeList nodes, EdgeList edges, YPoint origin, YRectangle rectangle) Moves the subgraph containing the given nodes and edges to the specified origin.
static void	GraphTransformer.translate(LayoutGraph graph, double dx, double dy) Translates the layout coordinates by the given vector.
void	HideGroupsStage.unhideGroupNodes(LayoutGraph graph) Un-hides the group nodes and their incident edges of the input graph that were previously hidden using method HideGroupsStage.hideGroupNodes(LayoutGraph).

Constructors in com.yworks.yfiles.layout with parameters of type LayoutGraph

Constructor and Description
CopiedLayoutGraph(LayoutGraph graph) Creates a new CopiedLayoutGraph instance which is a copy of the given graph.
DefaultLayoutGraph(LayoutGraph argGraph) Creates a new DefaultLayoutGraph instance which is a copy of the given graph.
DefaultLayoutGraph(LayoutGraph graph, ICursor nodeSubset) Creates a new DefaultLayoutGraph instance which is a copy of the given subgraph.
LayoutGraph(LayoutGraph subgraph) Creates a new LayoutGraph which is a copy of the given subgraph.
LayoutGraph(LayoutGraph graph, ICursor nodeSubset) Creates a new LayoutGraph which is a copy of the given subgraph.

Uses of LayoutGraph in com.yworks.yfiles.layout.circular

Methods in com.yworks.yfiles.layout.circular with parameters of type LayoutGraph

Modifier and Type	Method and Description
void	CircularLayout.applyLayout(LayoutGraph graph) Calculates a circular layout for the given graph.
void	SingleCycleLayout.applyLayoutCore(LayoutGraph graph) Arranges the nodes of the given graph such that they all lie on a common circle.
void	CircularLayout.applyLayoutCore(LayoutGraph graph) Arranges the given graph in a circular fashion.

Uses of LayoutGraph in com.yworks.yfiles.layout.genealogy

Methods in com.yworks.yfiles.layout.genealogy with parameters of type LayoutGraph

Modifier and Type	Method and Description
void	FamilyTreeLayout.applyLayoutCore(LayoutGraph graph) Applies a family tree layout to the given graph.

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

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

Modifier and Type	Method and Description
void	TopLevelGroupToSwimlaneStage.applyLayout(LayoutGraph graph) Calculates the layout by automatically assigning SwimlaneDescriptor instances to nodes and treating top-level group nodes as swimlanes.
void	PartitionGridLayoutStage.applyLayout(LayoutGraph graph) Calculates the layout based on a PartitionGrid structure.
void	HierarchicLayoutCore.applyLayoutCore(LayoutGraph graph) Calculates a hierarchic layout of the given graph.
void	HierarchicLayout.applyLayoutCore(LayoutGraph graph) Delegates the calculation of the hierarchic layout to a configured HierarchicLayoutCore instance.
void	SimplexNodePlacer.assignLayerCoordinates(LayoutGraph graph, ILayoutDataProvider layoutDataProvider, ILayers layers)
void	INodePlacer.assignLayerCoordinates(LayoutGraph graph, ILayoutDataProvider layoutDataProvider, ILayers layers) Assigns preliminary y-coordinates for each layer of a hierarchic layout.
void	WeightedLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and adds them to the ILayers instance.
void	TopologicalLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and adds them to the ILayers instance.
void	MultiComponentLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp)
void	ILayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and adds them to the ILayers instance.
void	GivenLayersLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and adds them to the ILayers instance.
void	ConstraintIncrementalLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and adds them to the ILayers instance based on relative and absolute layering constraints defined by the given layering constraints.
void	BFSLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and adds them to the ILayers instance.
void	AspectRatioComponentLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers and registers them to the ILayers instance based on the given aspect ratio.
void	AsIsLayerer.assignLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Assigns all nodes of the graph to layers by analyzing already existing node coordinates and adds them to the ILayers instance.
int	WeightedLayerer.assignNodeLayer(LayoutGraph graph, INodeMap layerID, EdgeList reversedEdges) Assigns all nodes of the graph to layers.
int	TopologicalLayerer.assignNodeLayer(LayoutGraph graph, INodeMap layerID, EdgeList reversedEdges) This method assigns the nodes in the graph to layers.
int	GivenLayersLayerer.assignNodeLayer(LayoutGraph graph, INodeMap layerID, EdgeList reversedEdges) Assigns the nodes of the graph to layers given by the IDataProvider registered with the graph using key GivenLayersLayerer.LAYER_ID_DPKEY.
int	BFSLayerer.assignNodeLayer(LayoutGraph graph, INodeMap layerID, EdgeList reversedEdges) Assigns the nodes of the graph to layers.
int	AsIsLayerer.assignNodeLayer(LayoutGraph graph, INodeMap layerID, EdgeList reversedEdges) Assigns all nodes of the graph to layers.
int	WeightedLayerer.assignNodeLayer(LayoutGraph graph, INodeMap layerID, EdgeList reversedEdges, IDataProvider weight) Assigns all nodes of the graph to layers.
protected void	SimplexNodePlacer.assignNodesToSublayer(NodeList layerNodes, ILayoutDataProvider ldp, LayoutGraph graph, INodeMap lowerSublayer) Assigns the nodes of a given layer to the corresponding upper/lower sublayer if node compaction is enabled.
void	IPortAllocator.assignPorts(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns to each edge of the graph a source port and target port coordinate pair.
void	DefaultPortAllocator.assignPorts(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns source and target port coordinates to each edge of the graph.
void	SimplexNodePlacer.assignSequenceCoordinates(LayoutGraph graph, ILayoutDataProvider layoutDataProvider, ILayers layers, IDrawingDistanceCalculator drawingDistanceCalculator)
void	INodePlacer.assignSequenceCoordinates(LayoutGraph graph, ILayoutDataProvider layoutDataProvider, ILayers layers, IDrawingDistanceCalculator drawingDistanceCalculator) Determines the resulting x-coordinates of a hierarchic layout.
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.
protected void	HierarchicLayout.configureCoreLayout(LayoutGraph graph, HierarchicLayoutCore coreLayouter) Configures the core layout algorithm with the settings of this HierarchicLayout instance.
protected GroupingSupport	HierarchicLayoutCore.createGrouping(LayoutGraph graph) Factory method that is called during HierarchicLayoutCore.applyLayoutCore(LayoutGraph) and creates a GroupingSupport instance in case of a grouped graph.
protected void	HierarchicLayoutCore.createItemData(LayoutGraph g, IItemFactory itemFactory) Callback method that is called during HierarchicLayoutCore.applyLayoutCore(LayoutGraph), creates the INodeData and IEdgeData instances and binds them to the elements using the given itemFactory.
ISequenceConstraintFactory	HierarchicLayout.createSequenceConstraintFactory(LayoutGraph graph) Returns a ISequenceConstraintFactory instance that can be used for specifying sequence constraints for the given graph.
void	TypeBasedDrawingDistanceCalculator.dispose(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp)
void	IDrawingDistanceCalculator.dispose(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Disposes of internal data structures.
void	DefaultDrawingDistanceCalculator.dispose(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp)
protected void	HierarchicLayout.disposeCoreLayout(LayoutGraph graph, HierarchicLayoutCore coreLayouter) Disposes of the core layout algorithm.
protected IDataProvider	HierarchicLayoutCore.getEdgeLayoutDescriptors(LayoutGraph graph) Callback method called during HierarchicLayoutCore.applyLayoutCore(LayoutGraph) and returns a IDataProvider that holds the EdgeLayoutDescriptor information.
protected IDataProvider	HierarchicLayoutCore.getIncrementalHints(LayoutGraph graph) Callback method called during HierarchicLayoutCore.applyLayoutCore(LayoutGraph) and returns a IDataProvider that holds the com.yworks.yfiles.layout.hierarchic.HierarchicLayoutCore.IncrementalHints information.
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.getMinimumDistance(LayoutGraph graph, Edge edge) Returns the minimum length between two edges associated with the given edge.
protected double	SelfLoopCalculator.getMinimumFirstSegmentLength(LayoutGraph graph, Edge edge) Returns the minimum length of the first segment of the given edge.
protected double	SelfLoopCalculator.getMinimumLastSegmentLength(LayoutGraph graph, Edge edge) Returns the minimum length of the last segment of the given edge.
protected double	SimplexNodePlacer.getMinimumLayerHeight(LayoutGraph graph, ILayoutDataProvider ldp, ILayer layer) Returns the minimum height of a given layer.
protected double	SelfLoopCalculator.getMinimumNodeDistance(LayoutGraph graph, Node node) Returns the minimum distance between two nodes associated with the given node.
protected double	SelfLoopCalculator.getMinimumOctilinearSegmentLength(LayoutGraph graph, Edge edge) Returns the minimum octilinear segment length of the given edge.
protected IDataProvider	HierarchicLayoutCore.getNodeLayoutDescriptors(LayoutGraph graph) Callback method called during HierarchicLayoutCore.applyLayoutCore(LayoutGraph) and returns a IDataProvider that holds the NodeLayoutDescriptor information.
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 IDataProvider	PortCandidateOptimizer.getPortCandidateSetDataProvider(LayoutGraph graph) Returns the data provider that provides the port candidate sets for nodes.
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.
protected IDataProvider	HierarchicLayoutCore.getSwimLaneDescriptors(LayoutGraph graph) Callback method called during HierarchicLayoutCore.applyLayoutCore(LayoutGraph) and returns a IDataProvider that holds the SwimlaneDescriptor information.
void	TypeBasedDrawingDistanceCalculator.initialize(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp)
void	IDrawingDistanceCalculator.initialize(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Initializes internal data structures.
void	DefaultDrawingDistanceCalculator.initialize(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp)
protected AbstractPortConstraintOptimizer.SameLayerData	PortCandidateOptimizer.insertSameLayerStructures(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory)
protected AbstractPortConstraintOptimizer.SameLayerData	AbstractPortConstraintOptimizer.insertSameLayerStructures(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Inserts a same-layer edge structure for each same-layer edge of the original graph.
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.
protected boolean	SelfLoopCalculator.isOctilinearEdge(LayoutGraph graph, Edge edge) Returns whether or not the given edge is octilinear.
void	ILayeredComponentsMerger.merge(LayoutGraph graph, ILayoutDataProvider ldp, ILayers srcLayers, ILayers targetLayers) Merges two ILayers instances.
void	DefaultLayeredComponentsMerger.merge(LayoutGraph graph, ILayoutDataProvider ldp, ILayers srcLayers, ILayers targetLayers)
void	IEdgeReverser.normalizeEdges(LayoutGraph graph, ILayoutDataProvider ldp) Reverses all edges which point to the wrong direction.
void	PortCandidateOptimizer.optimizeAfterLayering(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory)
void	IPortConstraintOptimizer.optimizeAfterLayering(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns new temporary port constraints after the layering information has been determined.
abstract void	AbstractPortConstraintOptimizer.optimizeAfterLayering(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns new temporary port constraints after the nodes have been assigned to layers.
protected void	AbstractPortConstraintOptimizer.optimizeAfterSequencing(Comparator<Object> inEdgeOrder, Comparator<Object> outEdgeOrder, LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns new temporary port constraints after the order of the nodes in each layer has been determined.
void	PortCandidateOptimizer.optimizeAfterSequencing(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory)
void	IPortConstraintOptimizer.optimizeAfterSequencing(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns new temporary port constraints after the sequence of the nodes has been determined.
void	AbstractPortConstraintOptimizer.optimizeAfterSequencing(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Assigns new temporary port constraints after the order of the nodes in each layer has been determined.
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.
protected void	HierarchicLayoutCore.publishLayers(LayoutGraph graph, ILayers layers) Callback method that publishes the layering information.
protected void	HierarchicLayoutCore.publishSequences(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp) Callback method that publishes the sequencing information.
protected void	HierarchicLayoutCore.reduceBendCount(LayoutGraph graph) Removes the bends which are obviously not necessary.
protected void	HierarchicLayoutCore.reduceBendCount(LayoutGraph graph, double bendReductionThreshold) Removes the bends which are obviously not necessary.
protected void	AbstractPortConstraintOptimizer.removeSameLayerStructures(AbstractPortConstraintOptimizer.SameLayerData sameLayerData, LayoutGraph graph, ILayoutDataProvider ldp, IItemFactory itemFactory) Removes the same-layer edge structure created using AbstractPortConstraintOptimizer.insertSameLayerStructures(LayoutGraph, ILayers, ILayoutDataProvider, IItemFactory).
void	IEdgeReverser.restoreEdgeDirections(LayoutGraph graph, ILayoutDataProvider ldp) Restores the original direction of edges marked as reversed.
void	IEdgeReverser.reverse(LayoutGraph graph, ILayoutDataProvider ldp, Edge edge) Reverses a given edge which points to the wrong direction.
void	ISequencer.sequenceNodeLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Calculates the sequence of the nodes within each layer.
void	GivenSequenceSequencer.sequenceNodeLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Calculates the sequence of the nodes within a ILayers instance based on the given Comparator instance.
void	DefaultLayerSequencer.sequenceNodeLayers(LayoutGraph graph, ILayers glayers, ILayoutDataProvider ldp, IItemFactory itemFactory)
void	AsIsSequencer.sequenceNodeLayers(LayoutGraph graph, ILayers layers, ILayoutDataProvider ldp, IItemFactory itemFactory) Calculates the sequence of the nodes within each layer using the nodes' coordinates.

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

Fields in com.yworks.yfiles.layout.labeling declared as LayoutGraph

Modifier and Type	Field and Description
protected LayoutGraph	AbstractMISLabeling.graph The input graph that will be labeled.

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

Modifier and Type	Method and Description
void	AbstractLabeling.applyLayout(LayoutGraph graph) Places the labels in the graph after first executing the core layouter.
void	AbstractLabeling.label(LayoutGraph graph) Places the labels of the input graph using a IDataProvider registered to the input graph with the given key for determining which labels to place.
void	AbstractLabeling.label(LayoutGraph graph, Object key) Places the labels of the input graph using a IDataProvider registered to the input graph with the given key for determining which labels to place.
void	AbstractLabeling.label(LayoutGraph graph, YList nodeLabels, YList edgeLabels) Places the labels of the input graph restricting the placement to labels contained in the given lists.

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

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

Modifier and Type	Method and Description
LayoutGraph	LayoutContext.getGraph() Gets the relevant graph.
LayoutGraph	MultiPageLayoutResult.getPage(int pageNo) Returns the page graph associated with the given page number.

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

Modifier and Type	Method and Description
protected void	MultiPageLayout.applyIncrementalLayout(LayoutGraph graph, IDataProvider incrementalNodesDP, LayoutContext context) This method is called to further improve the layout results.
void	MultiPageLayout.applyLayout(LayoutGraph graph) Calculates a new multi-page layout for the specified graph.
MultiPageLayoutResult	MultiPageLayout.calculateLayout(LayoutGraph graph) Calculates a new multi-page layout for the specified graph.
protected void	MultiPageLayout.routeRestoredEdges(LayoutGraph graph, IDataProvider selectedEdgesDP, YRectangle boundingRectangle) This method is called by MultiPageLayout.removeConnectorPair(Node, Node, YList, LayoutContext) to route the restored edges.

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

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

Modifier and Type	Method and Description
void	SplitEdgeStage.applyLayout(LayoutGraph graph) Replaces the edges of the given graph by a path of split-edges, executes the core layout algorithm and restores the original edges, introducing bends at the locations of the split-nodes.
void	ShuffleLayout.applyLayout(LayoutGraph graph) Performs the overlap removal (shuffle) algorithm on the given graph, after the core layout algorithm was applied to it.
void	RemoveOverlapsStage.applyLayout(LayoutGraph graph) Removes node overlaps and displaces nodes of the given graph such that they keep the specified minimum distance to each other.
void	RecursiveShuffleLayout.applyLayout(LayoutGraph graph) Removes all node overlaps in the given graph, after executing the specified core layout algorithm.
void	OrganicRemoveOverlapsStage.applyLayout(LayoutGraph graph) Removes node overlaps and displaces nodes of the given graph such that they keep the specified minimum distance to each other.
void	OrganicPartitionGridLayoutStage.applyLayout(LayoutGraph graph) Calculates the layout according to the core layout algorithm, while considering an existing partition grid structure defined for the graph.
void	OrganicLayout.applyLayout(LayoutGraph graph) Calculates an organic arrangement of the graph.
void	InteractiveOrganicLayout.applyLayout(LayoutGraph graph) Calculates an organic layout for the given input graph, however, the layout is not automatically applied to the graph.
void	OrganicLayout.applyLayoutCore(LayoutGraph graph) Calculates an organic arrangement of the graph.
void	ClassicOrganicLayout.applyLayoutCore(LayoutGraph graph) Calculates an organic arrangement of the given graph.
protected void	OrganicLayout.configureComponentLayout(LayoutGraph graph, ComponentLayout layouter) Configures the given ComponentLayout to take fixed nodes in components into account.
protected void	OrganicLayout.disposeComponentLayout(LayoutGraph graph, ComponentLayout layouter) Disposes of the ComponentLayout instance.
Thread	InteractiveOrganicLayout.startLayout(LayoutGraph graph) Starts the layout process calculating an organic layout for the input graph in a new, separate Thread.
InteractiveOrganicLayout.ISingleThreadContext	InteractiveOrganicLayout.startLayoutSingleThreaded(LayoutGraph graph) Creates a context object that provides methods to continue and stop the layout calculation for running this layout algorithm in a single-threaded environment.

Uses of LayoutGraph in com.yworks.yfiles.layout.orthogonal

Fields in com.yworks.yfiles.layout.orthogonal declared as LayoutGraph

Modifier and Type	Field and Description
protected LayoutGraph	KanCompactor.graph

Methods in com.yworks.yfiles.layout.orthogonal with parameters of type LayoutGraph

Modifier and Type	Method and Description
void	OrthogonalLayout.applyLayout(LayoutGraph graph) Calculates an orthogonal layout for the given graph.
void	OrthogonalLayout.applyLayoutCore(LayoutGraph graph) Calculates an orthogonal layout for the given graph.

Uses of LayoutGraph in com.yworks.yfiles.layout.partial

Methods in com.yworks.yfiles.layout.partial with parameters of type LayoutGraph

Modifier and Type	Method and Description
void	PartialLayout.applyLayout(LayoutGraph graph) This method calculates the partial layout.
protected void	PartialLayout.layoutSubgraph(LayoutGraph subGraph) This method is called during the layout process and calculates the layout for the given subgraph component using the specified core layout algorithm.
protected void	PartialLayout.placeSubgraphs(LayoutGraph graph, NodeList[] subgraphComponents) This method is called during the layout process and places the subgraph components one-by-one onto the drawing area.
protected void	PartialLayout.routeEdgesBetweenFixedElements(LayoutGraph graph, EdgeList partialEdges) This method is called during the layout process and routes all partial edges that connect two fixed elements.
protected void	PartialLayout.routeInterEdges(LayoutGraph graph, EdgeList interEdges) This method is called during the layout process and routes all inter-edges.

Uses of LayoutGraph in com.yworks.yfiles.layout.radial

Methods in com.yworks.yfiles.layout.radial with parameters of type LayoutGraph

Modifier and Type	Method and Description
void	RadialLayout.applyLayoutCore(LayoutGraph graph) Calculates a radial arrangement for the given graph.

Uses of LayoutGraph in com.yworks.yfiles.layout.router

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

Modifier and Type	Method and Description
void	StraightLineEdgeRouter.applyLayout(LayoutGraph graph) Routes the edges as straight-lines from their source to their target after invoking the core layout algorithm.
void	SnapOuterPortsToNodeBorderStage.applyLayout(LayoutGraph graph) Snaps all edge ports that lie outside the bounds of the nodes to their border.
void	OrthogonalSegmentDistributionStage.applyLayout(LayoutGraph graph) Distributes overlapping orthogonal segments after the core layout has been calculated.
void	OrthogonalPatternEdgeRouter.applyLayout(LayoutGraph graph) Routes the edges of the given graph orthogonally.
void	OrganicEdgeRouter.applyLayout(LayoutGraph graph) Performs the organic routing of the edges of the input graph.
void	ChannelEdgeRouter.applyLayout(LayoutGraph graph) Performs the orthogonal routing of the edges of the input graph.
void	BusRouter.applyLayout(LayoutGraph graph) Calculates bus-like routes for the edges in the given input graph.
protected void	OrthogonalPatternEdgeRouter.checkNodeSize(LayoutGraph g) Checks the sizes of the nodes to be non-zero.
protected void	OrganicEdgeRouter.checkNodeSize(LayoutGraph g) Checks the sizes of the nodes to be non-zero.
protected void	ChannelEdgeRouter.checkNodeSize(LayoutGraph g) Checks the sizes of the nodes to be non-zero.
static EdgeList	BusRepresentations.replaceHubsBySubgraph(LayoutGraph graph, EdgeList[] hubEdgesLists, IDataProvider hubMarker, IDataProvider fixedMarker, IDataAcceptor descriptorAcceptor) Changes the representation of buses from hubs to complete subgraphs by creating new edges between regular nodes and removing the hubs.
static EdgeList	BusRepresentations.replaceHubsBySubgraph(LayoutGraph graph, IDataProvider hubMarker, IDataAcceptor descriptorAcceptor) Changes the representation of buses from hubs to complete subgraphs.
static void	BusRepresentations.replaceSubgraphByHubs(LayoutGraph graph, IEdgeCursor edgeCursor, IDataProvider descriptorProvider, IDataAcceptor busIDAcceptor) Changes the representation of buses from complete subgraphs to hubs by replacing intersection points by hubs.

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

Methods in com.yworks.yfiles.layout.router.polyline that return LayoutGraph

Modifier and Type	Method and Description
LayoutGraph	PathSearchConfiguration.getGraph() Gets the graph containing the edges whose path is searched.

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

Modifier and Type	Method and Description
void	PolylineLayoutStage.applyLayout(LayoutGraph graph) Adds polyline segments to the edge routes produced by the core layout algorithm.
void	EdgeRouter.applyLayout(LayoutGraph graph) Performs the routing of the edges of the input graph.
protected void	EdgeRouter.checkNodeSize(LayoutGraph g) Checks the sizes of the nodes to be non-zero.
protected PathSearchConfiguration	EdgeRouter.createConfiguration(LayoutGraph graph, GroupingSupport grouping) Creates a PathSearchConfiguration that is used during the path searching process.
protected Comparator<Object>	EdgeRouter.createDefaultEdgeOrderComparator(LayoutGraph graph, PathSearchConfiguration configuration) Creates a default Comparator instance to determine the order of the edges according to which they will be routed.

Constructors in com.yworks.yfiles.layout.router.polyline with parameters of type LayoutGraph

Constructor and Description
PathSearchConfiguration(LayoutGraph graph, GroupingSupport grouping, EdgeRouter edgeRouter) Creates a new instance of PathSearchConfiguration used for a path search.

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

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

Modifier and Type	Method and Description
void	SeriesParallelLayout.applyLayoutCore(LayoutGraph graph) Calculates a series-parallel layout for the given graph.
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 LayoutGraph in com.yworks.yfiles.layout.tree

Fields in com.yworks.yfiles.layout.tree declared as LayoutGraph

Modifier and Type	Field and Description
protected LayoutGraph	TreeLayout.graph The input graph for which a layout is calculated.
protected LayoutGraph	BalloonLayout.graph The layout graph being acted upon.
protected LayoutGraph	AspectRatioTreeLayout.graph The input graph this algorithm is handling.
protected LayoutGraph	AbstractRotatableNodePlacer.graph The graph instance this INodePlacer is working on.
protected LayoutGraph	AbstractNodePlacer.graph The graph instance this class is working on.

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

Modifier and Type	Method and Description
void	TreeLayout.SubtreeShape.addEdgeSegments(LayoutGraph graph, Edge edge) Adds all edge segments of the given edge to this TreeLayout.SubtreeShape instance.
void	TreeReductionStage.applyLayout(LayoutGraph graph) Determines a spanning tree of the graph and passes it to the core layout algorithm.
void	TreeComponentLayout.applyLayout(LayoutGraph graph) Finds the tree components inside the given graph and applies a tree layout to them.
void	TreeLayout.applyLayoutCore(LayoutGraph graph) Arranges the given graph as a tree.
void	ClassicTreeLayout.applyLayoutCore(LayoutGraph graph) Arranges the given graph as a tree.
void	BalloonLayout.applyLayoutCore(LayoutGraph graph) Arranges the given graph as a tree graph in a balloon-like fashion.
void	AspectRatioTreeLayout.applyLayoutCore(LayoutGraph graph) Arranges the given graph considering the specified aspect ratio.
protected void	TreeComponentLayout.applyLayoutUsingDummies(LayoutGraph graph, IDataProvider dummyDp) Delegates the layout calculation to the core layout algorithm and handles the dummy nodes.
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 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.
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 PortConstraint	DefaultPortAssignment.getSourcePortConstraint(LayoutGraph graph, Edge edge, int index) Retrieves the source PortConstraint for the given edge.
protected PortConstraint	DefaultPortAssignment.getTargetPortConstraint(LayoutGraph graph, Edge edge) Retrieves the target PortConstraint for the given edge.
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 NodeList	DelegatingNodePlacer.primaryChildren(Node localRoot, LayoutGraph graph) Returns all upper-left children of the local root node.
protected void	TreeReductionStage.routeNonTreeEdges(LayoutGraph graph, IEdgeMap nonTreeEdgeMap) Routes all edges that do not belong to the chosen spanning tree.
protected NodeList	DelegatingNodePlacer.secondaryChildren(Node localRoot, LayoutGraph graph) Returns all lower-right children of the local root node.