BalloonLayout (yFiles-for-JavaFX-Complete-3.0 API)

java.lang.Object
- com.yworks.yfiles.layout.MultiStageLayout
- - com.yworks.yfiles.layout.tree.BalloonLayout

All Implemented Interfaces:

ILayoutAlgorithm
```
public class BalloonLayout
extends MultiStageLayout
```
A tree layout algorithm that arranges the subtrees of the tree in a balloon-like fashion.

Layout Style
BalloonLayout is designed to arrange directed and undirected tree graphs. Subtrees rooted at a node are placed in a radial fashion around their root node. All direct children of one node can be placed on a common circle around their parent node (depending on the alignment policy). Therefore, subtrees look like balloons or stars, especially if subtrees have similar sizes. The edges of the tree are drawn as straight lines. Sample balloon-drawing of a large tree obtained with default settings Sample balloon-drawing featuring interleaved child placement and ray-like node labels
Concept
The algorithm executes the following steps:
1. Select a root node according to the specified root policy.
2. Determine the placement of subtrees around the root using a bottom-up recursive approach (starting with leaf nodes).
3. Assign the actual coordinates of nodes, again using a recursive approach (starting with the root node).
Features

The algorithm features integrated edge labeling as well as node labeling. Edge labels and node labels are placed automatically without generating overlaps with other labels or graph elements. There are different ways to place node labels. Edge labeling will take the settings of PreferredPlacementDescriptor into account.

Defining a preferred wedge angle has a great influence on the layout style. Subtrees rooted at a node get a certain amount of radial space to be placed around the parent node, such that a preferred angle close to 360 degrees will generate drawings where subtrees look like balloons, while an angle close to 180 degrees could be chosen to get drawings where subtrees look like semicircles.

Since it is computationally not very complex, BalloonLayout is very well suited for large tree graphs. It performs well even for huge graphs.

This layout algorithm can only handle graphs with a tree structure. To apply it to a general graph, a TreeReductionStage can be appended. This stage will temporarily remove some edges of the input graph until a tree is obtained. These edges will later be reinserted and routed separately.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class BalloonLayout.NodeInfo
Encapsulates information bound to a node while the algorithm calculates a layout.

Nested Classes
Modifier and Type	Class and Description
`static class`	`BalloonLayout.NodeInfo` Encapsulates information bound to a node while the algorithm calculates a layout.

Field Summary

Fields
Modifier and Type	Field and Description
`protected LayoutGraph`	`graph` The layout graph being acted upon.
`static NodeDpKey<Boolean>`	`INTERLEAVED_NODES_DPKEY` A `DataProvider` key for marking nodes whose child nodes should be placed in an interleaved fashion This `IDataProvider` allows to individually configure the interleaving feature for each node in the graph.
`static NodeDpKey<Boolean>`	`SELECTED_ROOT_DPKEY` A `DataProvider` key for marking the node that will be used as root node of the tree.

Constructor Summary

Constructors
Constructor and Description

BalloonLayout()
Creates a new BalloonLayout instance with default settings.

Constructors
Constructor and Description
`BalloonLayout()` Creates a new `BalloonLayout` instance with default settings.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyLayoutCore(LayoutGraph graph)` Arranges the given graph as a tree graph in a balloon-like fashion.
`protected double`	`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`	`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`	`calculateChildArrangement(Node root)` Calculates a child node arrangement for a given root node of the tree.
`protected Node`	`determineRoot()` Determines the root node of `graph` according to the chosen `root node policy`.
`ChildAlignmentPolicy`	`getChildAlignmentPolicy()` Gets the child alignment policy for this layout algorithm.
`ChildOrderingPolicy`	`getChildOrderingPolicy()` Gets the child ordering policy for sorting the child nodes around their parents.
`double`	`getCompactnessFactor()` Gets the factor defining how compact layout results will potentially be, where a smaller factor produces potentially more compact layouts.
`Comparator<Object>`	`getComparator()` Gets the `Comparator` instance that determines the order of the outgoing edges for each node of the tree.
`double`	`getEdgeLabelSpacing()` Gets the distance between edge labels belonging to the same edge as well as the distance of the edge labels to the target node of the edge.
`InterleavedMode`	`getInterleavedMode()` Gets the mode for child node arrangement.
`int`	`getMinimumEdgeLength()` Gets the minimum length that this layout algorithm assigns to edges of the graph.
`int`	`getMinimumNodeDistance()` Gets the minimum distance to be kept between the nodes in the tree.
`NodeLabelingPolicy`	`getNodeLabelingPolicy()` Gets the policy defining how node labels are placed by the integrated node labeling mechanism (for example, the desired label orientation).
`double`	`getNodeLabelSpacing()` Gets the distance between node labels belonging to the same node.
`int`	`getPreferredChildWedge()` Gets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around their parent node.
`protected double`	`getPreferredChildWedge(Node root)` Returns the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the given node.
`int`	`getPreferredRootWedge()` Gets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the global root.
`RootNodePolicy`	`getRootNodePolicy()` Gets the root node selection policy of this layout algorithm.
`boolean`	`isChainStraighteningModeEnabled()` Gets whether or not chains are drawn straight or not.
`boolean`	`isFromSketchModeEnabled()` Gets whether or not to consider the given coordinates of the input diagram when arranging the tree.
`boolean`	`isIntegratedEdgeLabelingEnabled()` Gets whether or not the layout algorithm automatically places edge labels.
`boolean`	`isIntegratedNodeLabelingEnabled()` Gets whether or not the layout algorithm automatically places node labels.
`boolean`	`isNodeLabelConsiderationEnabled()` Gets whether or not the layout algorithm reserves space for node labels.
`boolean`	`isOverlapsAllowed()` Gets whether or not (partially) overlapping nodes are allowed.
`void`	`setChainStraighteningModeEnabled(boolean value)` Sets whether or not chains are drawn straight or not.
`void`	`setChildAlignmentPolicy(ChildAlignmentPolicy value)` Sets the child alignment policy for this layout algorithm.
`void`	`setChildOrderingPolicy(ChildOrderingPolicy value)` Sets the child ordering policy for sorting the child nodes around their parents.
`void`	`setCompactnessFactor(double value)` Sets the factor defining how compact layout results will potentially be, where a smaller factor produces potentially more compact layouts.
`void`	`setComparator(Comparator<Object> value)` Sets the `Comparator` instance that determines the order of the outgoing edges for each node of the tree.
`void`	`setComponentLayoutEnabled(boolean value)` Sets whether or not the `ILayoutStage` used for arranging the components of the graph is activated.
`void`	`setEdgeLabelSpacing(double value)` Sets the distance between edge labels belonging to the same edge as well as the distance of the edge labels to the target node of the edge.
`void`	`setFromSketchModeEnabled(boolean value)` Sets whether or not to consider the given coordinates of the input diagram when arranging the tree.
`void`	`setHideGroupsStageEnabled(boolean value)` Sets whether or not the `ILayoutStage` used for hiding group nodes is activated.
`void`	`setIntegratedEdgeLabelingEnabled(boolean value)` Sets whether or not the layout algorithm automatically places edge labels.
`void`	`setIntegratedNodeLabelingEnabled(boolean value)` Sets whether or not the layout algorithm automatically places node labels.
`void`	`setInterleavedMode(InterleavedMode value)` Sets the mode for child node arrangement.
`void`	`setMinimumEdgeLength(int value)` Sets the minimum length that this layout algorithm assigns to edges of the graph.
`void`	`setMinimumNodeDistance(int value)` Sets the minimum distance to be kept between the nodes in the tree.
`void`	`setNodeLabelConsiderationEnabled(boolean value)` Sets whether or not the layout algorithm reserves space for node labels.
`void`	`setNodeLabelingPolicy(NodeLabelingPolicy value)` Sets the policy defining how node labels are placed by the integrated node labeling mechanism (for example, the desired label orientation).
`void`	`setNodeLabelSpacing(double value)` Sets the distance between node labels belonging to the same node.
`void`	`setOrientationLayoutEnabled(boolean value)` Sets whether or not the `ILayoutStage` that modifies the orientation of the layout is activated.
`void`	`setOverlapsAllowed(boolean value)` Sets whether or not (partially) overlapping nodes are allowed.
`void`	`setParallelEdgeRouterEnabled(boolean value)` Sets whether or not the `ILayoutStage` used for routing parallel edges is activated.
`void`	`setPreferredChildWedge(int value)` Sets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around their parent node.
`void`	`setPreferredRootWedge(int value)` Sets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the global root.
`void`	`setRootNodePolicy(RootNodePolicy value)` Sets the root node selection policy of this layout algorithm.
`void`	`setSelfLoopRouterEnabled(boolean value)` Sets whether or not the `ILayoutStage` used for routing self-loops is activated.
`protected void`	`sortChildNodes(Node root)` Sorts the child nodes (successors) of the given node.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - graph
```
protected LayoutGraph graph
```
    The layout graph being acted upon.
  - INTERLEAVED_NODES_DPKEY
```
public static final NodeDpKey<Boolean> INTERLEAVED_NODES_DPKEY
```
    A DataProvider key for marking nodes whose child nodes should be placed in an interleaved fashion
    This IDataProvider allows to individually configure the interleaving feature for each node in the graph.
    
    The custom node selection induced by this IDataProvider is only considered if the interleaved mode is set to InterleavedMode.MARKED_NODES.
    
    See Also:
    
    setInterleavedMode(InterleavedMode)
  - SELECTED_ROOT_DPKEY
```
public static final NodeDpKey<Boolean> SELECTED_ROOT_DPKEY
```
    A DataProvider key for marking the node that will be used as root node of the tree.
    
    The custom root node selection induced by this IDataProvider is only considered if the root node policy is set to RootNodePolicy.SELECTED_ROOT.
    
    See Also:
    
    setRootNodePolicy(RootNodePolicy)
- Constructor Detail
  - BalloonLayout
```
public BalloonLayout()
```
    Creates a new BalloonLayout instance with default settings.
- Method Detail
  - applyLayoutCore
```
public void applyLayoutCore(LayoutGraph graph)
```
    Arranges the given graph as a tree graph in a balloon-like fashion.
    
    Specified by:
    
    applyLayoutCore in class MultiStageLayout
    
    Throws:
    
    InvalidGraphStructureException - if the given graph is not a tree
    
    The given graph will not be copied during the layout process and the layout will be immediately applied to the given graph. This method is not side effect free in the sense that the order of edges or nodes in the input graph may change during the layout process.
    
    Parameters:
    
    graph - the input graph
  - calculateAngles
```
protected final double 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.
    Given some distance the upper angle and lower angle of the wedge belonging to the subtree rooted at root will be calculated and stored in the BalloonLayout.NodeInfo instance associated with root (com.yworks.yfiles.layout.tree.BalloonLayout.getInfo(com.yworks.yfiles.algorithms.Node)).
    
    This method may be overridden to perform a custom wedge angle assignment scheme. The method is called when arranging child nodes. Large edge labels on the incoming edge to root need to be considered, if integrated edge labeling should still work properly.
    
    Calling this method may change data in the com.yworks.yfiles.layout.tree.BalloonLayout.getInfo(com.yworks.yfiles.algorithms.Node) associated with node root.
    
    Parameters:
    
    root - the node for which the wedge angles are calculated
    
    Returns:
    
    the sum of the upper and lower wedge angle of the subtree rooted at the given root node
    
    See Also:
    
    calculateChildArrangement(Node)
  - calculateAngles
```
protected double 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.
    Given some distance the upper angle and lower angle of the wedge belonging to the subtree rooted at root will be calculated and stored in the BalloonLayout.NodeInfo instance associated with root (com.yworks.yfiles.layout.tree.BalloonLayout.getInfo(com.yworks.yfiles.algorithms.Node)).
    
    This method may be overridden to perform a custom wedge angle assignment scheme. The method is called when arranging child nodes. Large edge labels on the incoming edge to root need to be considered, if integrated edge labeling should still work properly.
    
    Calling this method may change data in the com.yworks.yfiles.layout.tree.BalloonLayout.getInfo(com.yworks.yfiles.algorithms.Node) associated with node root.
    
    Parameters:
    
    root - the node for which the wedge angles are calculated
    
    scaleFactor - a factor to be applied to the distance of root
    
    Returns:
    
    the sum of the upper and lower wedge angle of the subtree rooted at the given root node
    
    See Also:
    
    calculateChildArrangement(Node)
  - calculateChildArrangement
```
protected void calculateChildArrangement(Node root)
```
    Calculates a child node arrangement for a given root node of the tree.
    During the arrangement, child nodes of root will be sorted. Furthermore, distances of the child nodes will be chosen such that the wedge of the subtree of root fits into the preferred wedge angle, which is either defined via PreferredRootWedge or PreferredChildWedge. Calculated distances are stored in BalloonLayout.NodeInfo.dist.
    
    The angle values - upper and lower wedge angle - may also be updated during this process and stored in BalloonLayout.NodeInfo.upperAngle and BalloonLayout.NodeInfo.lowerAngle, respectively. To compute the angles of wedges, method calculateAngles(Node, double) is used.
    
    This method may be overridden to perform a custom child node arrangement. If support for available features like interleaving should be maintained, then these features need to be carefully considered during the arrangement.
    
    Parameters:
    
    root - the node for whose children to compute an arrangement
  - determineRoot
```
protected Node determineRoot()
```
    Determines the root node of graph according to the chosen root node policy.
    This method may be overridden to implement some other strategy for choosing the root node of the input graph. It is called before the rest of the layout process within applyLayoutCore(LayoutGraph).
    
    If the root node policy is set to RootNodePolicy.SELECTED_ROOT and more than one node is marked as potential root node, only one will be considered as root. If no nodes are selected, the root node will be defined according to Trees.getRoot(com.yworks.yfiles.algorithms.Graph).
    
    Returns:
    
    the root node of graph
    
    See Also:
    
    setRootNodePolicy(RootNodePolicy)
  - getChildAlignmentPolicy
```
public ChildAlignmentPolicy getChildAlignmentPolicy()
```
    Gets the child alignment policy for this layout algorithm.
    This policy influences the distance of child nodes to their parent nodes and the alignment of children with the same parent.
    
    Throws:
    
    IllegalArgumentException - if an unknown policy is given
    
    The alignment policy can have a high influence on the result if node sizes and/or subtree sizes are differing a lot. It also has a high influence if the graph contains labels - especially large edge labels - and if integrated labeling is enabled.
    
    Default Value:
    The default value is ChildAlignmentPolicy.COMPACT
    
    Returns:
    
    one of the predefined child alignment policies
    
    See Also:
    
    setChildAlignmentPolicy(ChildAlignmentPolicy)
  - getChildOrderingPolicy
```
public ChildOrderingPolicy getChildOrderingPolicy()
```
    Gets the child ordering policy for sorting the child nodes around their parents.
    The sorting policy can affect the compactness of drawings. Advantageous orderings allow adjacent subtrees to be close together and can thus make the whole layout more compact.
    
    Throws:
    
    IllegalArgumentException - if an unknown ordering policy is given
    
    This policy is ignored if From Sketch mode is enabled.
    
    Default Value:
    The default value is ChildOrderingPolicy.COMPACT
    
    Returns:
    
    one of the predefined child ordering policies
    
    See Also:
    
    setFromSketchModeEnabled(boolean), setComparator(Comparator), setChildOrderingPolicy(ChildOrderingPolicy)
  - getCompactnessFactor
```
public double getCompactnessFactor()
```
    Gets the factor defining how compact layout results will potentially be, where a smaller factor produces potentially more compact layouts.
    The algorithm tries to optimize the child node arrangement around each tree node such that each subtree is as close to its root as possible, while still fitting into the preferred wedge angle and not overlapping with adjacent subtrees.
    
    High compactness factor values induce the optimization procedure to be less strict and accept less optimal results, while low factor values mean that the optimization will only stop when being nearly optimal. Thus, lower values lead to a potentially higher runtime.
    
    The minimum factor value is 0.05 and the maximum is 1.0.
    
    Throws:
    
    IllegalArgumentException - if the factor is smaller than 0.05 or greater than 1.0
    
    Default Value:
    The default value is 0.5. A factor offering good balance between compactness and runtime.
    
    Returns:
    
    the compactness factor from the interval [0.05, 1.0]
    
    See Also:
    
    setCompactnessFactor(double)
  - getComparator
```
public Comparator<Object> getComparator()
```
    Gets the Comparator instance that determines the order of the outgoing edges for each node of the tree.
    If no Comparator is specified (i.e. the Comparator is null), the outgoing edges will be sorted according to the current child ordering policy.
    
    If From Sketch mode is enabled, the specified comparator does not have any effect.
    
    Default Value:
    The default value is null. The algorithm uses a built-in sorting logic.
    
    Returns:
    
    a Comparator instance to sort outgoing edges or null if edges are sorted according to the child ordering policy
    
    See Also:
    
    setChildOrderingPolicy(ChildOrderingPolicy), setFromSketchModeEnabled(boolean), setComparator(Comparator)
  - getEdgeLabelSpacing
```
public double getEdgeLabelSpacing()
```
    Gets the distance between edge labels belonging to the same edge as well as the distance of the edge labels to the target node of the edge.
    The spacing must have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the given label spacing value is negative
    
    With a spacing of 0, labels will touch each other and the target node.
    
    The spacing value has an effect only if integrated edge labeling is enabled.
    
    Default Value:
    The default value is 4.0. Labels are close together and close to targets.
    
    Returns:
    
    the non-negative edge label spacing
    
    See Also:
    
    setIntegratedEdgeLabelingEnabled(boolean), setEdgeLabelSpacing(double)
  - getInterleavedMode
```
public InterleavedMode getInterleavedMode()
```
    Gets the mode for child node arrangement.
    Child nodes are either placed interleaved or on a single layer around their parent node. Interleaved placement means that child nodes are placed around their common parent in two different layers in an alternating fashion. For example, the first child is on the inner layer, the second child on the outer layer, the third one again on the inner layer, etc.
    
    Independent of this mode, the alignment of child nodes on the same layer is still defined by the alignment policy. However, ChildAlignmentPolicy.SMART is only supported for non-interleaved arrangement.
    
    Throws:
    
    IllegalArgumentException - if an unknown mode for interleaved arrangement is given
    
    Interleaved placement leads to the best results if all subtrees rooted at a node have similar total sizes or if there are two groups of different sizes among the subtrees. In these cases, interleaved placement makes drawings much more compact and still shows symmetries.
    
    Activating interleaved child arrangement for all or for selected nodes will cause the ordering policy to have no more effect for those nodes.
    
    Default Value:
    The default value is InterleavedMode.OFF. Interleaved placement is disabled.
    
    Returns:
    
    the mode for interleaved child node arrangement
    
    See Also:
    
    setChildAlignmentPolicy(ChildAlignmentPolicy), setInterleavedMode(InterleavedMode)
  - getMinimumEdgeLength
```
public int getMinimumEdgeLength()
```
    Gets the minimum length that this layout algorithm assigns to edges of the graph.
    A lower minimum edge length allows generally more compact layouts. It has the highest effect if most nodes of the graph have a low degree, as the minimum can potentially be met for such graphs.
    
    The minimum length must be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the given length is negative
    
    Really small minimum edge length values (i.e. smaller than 5) are not recommended, because edges may be barely visible in the result drawing.
    
    Default Value:
    The default value is 40.
    
    Returns:
    
    the non-negative minimum edge length
    
    See Also:
    
    setMinimumEdgeLength(int)
  - getMinimumNodeDistance
```
public int getMinimumNodeDistance()
```
    Gets the minimum distance to be kept between the nodes in the tree.
    The distance needs to be a non-negative integer value.
    
    Throws:
    
    IllegalArgumentException - if the given minimum distance is negative
    
    This minimum distance is not always considered if overlaps are allowed.
    
    Default Value:
    The default value is 10.
    
    Returns:
    
    the non-negative minimum node distance
    
    See Also:
    
    setOverlapsAllowed(boolean), setMinimumNodeDistance(int)
  - getNodeLabelingPolicy
```
public NodeLabelingPolicy getNodeLabelingPolicy()
```
    Gets the policy defining how node labels are placed by the integrated node labeling mechanism (for example, the desired label orientation).
    
    Throws:
    
    IllegalArgumentException - if an unknown labeling policy is given
    
    The policy only has an effect if integrated node labeling is enabled.
    
    Default Value:
    The default value is NodeLabelingPolicy.RAY_LIKE
    
    Returns:
    
    one of the predefined node labeling policies
    
    See Also:
    
    setIntegratedNodeLabelingEnabled(boolean), setNodeLabelingPolicy(NodeLabelingPolicy)
  - getNodeLabelSpacing
```
public double getNodeLabelSpacing()
```
    Gets the distance between node labels belonging to the same node.
    It also defines the distance between labels and the node they belong to in case of label placement outside of the node (e.g. for ray-like label placement).
    
    The spacing must have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the given spacing value is negative
    
    With a spacing of 0, node labels will be maximally close to each other and to their node.
    
    The spacing value has an effect only if integrated node labeling is enabled.
    
    Default Value:
    The default value is 4.0.
    
    Returns:
    
    the non-negative node label spacing
    
    See Also:
    
    isIntegratedNodeLabelingEnabled(), setNodeLabelSpacing(double)
  - getPreferredChildWedge
```
public int getPreferredChildWedge()
```
    Gets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around their parent node.
    The wedge angle controls the degree to which the child nodes may radiate from the center of layout. A value close to 360 means that the child nodes may radiate in (almost) any direction from their parent node, edge lengths can in consequence stay rather small. On the other hand, a small value means that children are restricted to a small angle; thus, edge lengths (and drawings) may become large.
    
    The minimum allowed wedge angle is 1 and the maximum allowed value is 359.
    
    Throws:
    
    IllegalArgumentException - if the given angle is smaller than 1 or larger than 359
    
    To get drawings where each subtree looks balloon-like, an angle close to 360 is needed.
    
    The angle of the designated root node of the tree is not affected by this setting. The preferred angle of the root can be specified using PreferredRootWedge.
    
    Default Value:
    The default value is 340.
    
    Returns:
    
    the preferred wedge angle in degrees from the interval [1,359]
    
    See Also:
    
    setPreferredRootWedge(int), setPreferredChildWedge(int)
  - getPreferredChildWedge
```
protected double getPreferredChildWedge(Node root)
```
    Returns the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the given node.
    The wedge angle controls the degree to which the child nodes may radiate from the center of layout. A value close to 360 means that the child nodes may radiate in (almost) any direction from their parent node, edge lengths can in consequence stay rather small. On the other hand, a small value means that children are restricted to a small angle; thus, edges lengths (and drawings) may become large.
    
    This method returns the preferred root wedge if node root was selected as global root node (RootNodePolicy). Otherwise, it either returns PreferredChildWedge or if the given node has an outdegree equal to 2, it returns the minimum of PreferredChildWedge and 180.
    
    This method may be overridden to provide a custom child wedge function.
    
    Parameters:
    
    root - the node to get the preferred wedge angle for
    
    Returns:
    
    the preferred wedge angle for root in degrees
    
    See Also:
    
    setPreferredChildWedge(int), setPreferredRootWedge(int)
  - getPreferredRootWedge
```
public int getPreferredRootWedge()
```
    Gets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the global root.
    This property allows to separately control the wedge angle for the designated root node of the tree, while PreferredChildWedge controls the angles of all child nodes. The root node will be determined depending on the root node policy.
    
    The minimum allowed root wedge angle is 1 and the maximum allowed value is 360.
    
    Throws:
    
    IllegalArgumentException - if the given angle is smaller than 1 or larger than 360
    
    Default Value:
    The default value is 360.
    
    Returns:
    
    the preferred wedge angle in degrees from the interval [1,360]
    
    See Also:
    
    setPreferredChildWedge(int), setPreferredRootWedge(int)
  - getRootNodePolicy
```
public RootNodePolicy getRootNodePolicy()
```
    Gets the root node selection policy of this layout algorithm.
    The policy determines which node is chosen as (virtual) tree root during the layout process.
    
    Throws:
    
    IllegalArgumentException - if an unknown root node policy is given
    
    Default Value:
    The default value is RootNodePolicy.DIRECTED_ROOT
    
    Returns:
    
    one of the predefined root node policies
    
    See Also:
    
    setRootNodePolicy(RootNodePolicy)
  - isChainStraighteningModeEnabled
```
public boolean isChainStraighteningModeEnabled()
```
    Gets whether or not chains are drawn straight or not.
    A chain is defined as a tree node with exactly one child node. If this feature is enabled, then the incoming edge and outgoing edge of the chain will have the same orientation, i.e., the whole chain looks straight.
    
    Straightening all chains can lead to smoother, more symmetric results.
    
    This feature improves result quality especially if a graph has many (large) labels associated to nodes and edges, because in that case non-straight chains are more likely.
    
    Default Value:
    The default value is false. There is no guarantee that chains are drawn straight.
    
    Returns:
    
    true if chains are drawn straight, false otherwise.
    
    See Also:
    
    setChainStraighteningModeEnabled(boolean)
  - isFromSketchModeEnabled
```
public boolean isFromSketchModeEnabled()
```
    Gets whether or not to consider the given coordinates of the input diagram when arranging the tree.
    Enabling this feature, the original circular order of child nodes around their parent nodes will be maintained according to the initial coordinates when determining the order of the child nodes.
    
    Default Value:
    The default value is false. The coordinates of the input are not considered.
    
    Returns:
    
    true if the initial coordinates of the nodes are considered, false otherwise
    
    See Also:
    
    setFromSketchModeEnabled(boolean)
  - isIntegratedEdgeLabelingEnabled
```
public boolean isIntegratedEdgeLabelingEnabled()
```
    Gets whether or not the layout algorithm automatically places edge labels.
    If enabled, this layout algorithm will calculate the positions for the edge labels assuring that no overlaps occur.
    
    Optimal label placement with integrated labeling can be achieved using FreeEdgeLabelLayoutModel as the IEdgeLabelLayoutModel for the edges.
    
    When enabling integrated edge labeling, it is recommended to also enable chain straightening, because edge labels (especially large ones) may lead to significantly non-straight node chains.
    
    Default Value:
    The default value is false. Edge labels are not placed by this algorithm.
    
    Returns:
    
    true if integrated edge labeling is enabled, false otherwise.
    
    See Also:
    
    setIntegratedEdgeLabelingEnabled(boolean)
  - isIntegratedNodeLabelingEnabled
```
public boolean isIntegratedNodeLabelingEnabled()
```
    Gets whether or not the layout algorithm automatically places node labels.
    If enabled, this layout algorithm will calculate the positions for the node labels assuring that no overlaps occur.
    
    Different labeling strategies may be selected using NodeLabelingPolicy.
    
    Optimal label placement with integrated labeling can be achieved using FreeNodeLabelLayoutModel as the INodeLabelLayoutModel for the nodes.
    
    If integrated labeling is enabled, then the simple consideration mechanism has no more effect.
    
    Default Value:
    The default value is false. Node labels are not placed by this algorithm.
    
    Returns:
    
    true if integrated node labeling is enabled, false otherwise.
    
    See Also:
    
    setNodeLabelingPolicy(NodeLabelingPolicy), setIntegratedNodeLabelingEnabled(boolean)
  - isNodeLabelConsiderationEnabled
```
public boolean isNodeLabelConsiderationEnabled()
```
    Gets whether or not the layout algorithm reserves space for node labels.
    The size of nodes will temporarily be adjusted such that the label is included. Therefore, result drawings may get significantly larger if this feature is enabled.
    
    This option only works correctly if the layout orientation is set to LayoutOrientation.TOP_TO_BOTTOM (which is the default). Changing the layout orientation for an undirected layout algorithm like the BalloonLayout doesn't make sense.
    
    This has an effect only if the integrated node labeling mechanism is disabled.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Returns:
    
    true if node labels are considered, false otherwise
    
    See Also:
    
    setNodeLabelConsiderationEnabled(boolean)
  - isOverlapsAllowed
```
public boolean isOverlapsAllowed()
```
    Gets whether or not (partially) overlapping nodes are allowed.
    If overlaps are allowed, the resulting layouts can become significantly more compact. Overlaps will mostly occur at the borders of nodes. Nodes will not be totally covered by other nodes.
    
    For smaller graphs or graphs where most nodes have a low outdegree count, overlaps will often not occur, even if this property is enabled. This allows really compact drawings of such graphs.
    
    The computation of the convex hull of a node depends on this setting: the outer circle with respect to the rectangle defined by height and width of a node is taken if overlaps ar not allowed. Otherwise, the inner circle is used for the convex hull.
    
    Default Value:
    The default value is false. Nodes are not allowed to overlap.
    
    Returns:
    
    true if node overlaps are allowed, false otherwise
    
    See Also:
    
    setOverlapsAllowed(boolean)
  - setChainStraighteningModeEnabled
```
public void setChainStraighteningModeEnabled(boolean value)
```
    Sets whether or not chains are drawn straight or not.
    A chain is defined as a tree node with exactly one child node. If this feature is enabled, then the incoming edge and outgoing edge of the chain will have the same orientation, i.e., the whole chain looks straight.
    
    Straightening all chains can lead to smoother, more symmetric results.
    
    This feature improves result quality especially if a graph has many (large) labels associated to nodes and edges, because in that case non-straight chains are more likely.
    
    Default Value:
    The default value is false. There is no guarantee that chains are drawn straight.
    
    Parameters:
    
    value - true if chains are drawn straight, false otherwise.
    
    See Also:
    
    isChainStraighteningModeEnabled()
  - setChildAlignmentPolicy
```
public void setChildAlignmentPolicy(ChildAlignmentPolicy value)
```
    Sets the child alignment policy for this layout algorithm.
    This policy influences the distance of child nodes to their parent nodes and the alignment of children with the same parent.
    
    Throws:
    
    IllegalArgumentException - if an unknown policy is given
    
    The alignment policy can have a high influence on the result if node sizes and/or subtree sizes are differing a lot. It also has a high influence if the graph contains labels - especially large edge labels - and if integrated labeling is enabled.
    
    Default Value:
    The default value is ChildAlignmentPolicy.COMPACT
    
    Parameters:
    
    value - one of the predefined child alignment policies
    
    See Also:
    
    getChildAlignmentPolicy()
  - setChildOrderingPolicy
```
public void setChildOrderingPolicy(ChildOrderingPolicy value)
```
    Sets the child ordering policy for sorting the child nodes around their parents.
    The sorting policy can affect the compactness of drawings. Advantageous orderings allow adjacent subtrees to be close together and can thus make the whole layout more compact.
    
    Throws:
    
    IllegalArgumentException - if an unknown ordering policy is given
    
    This policy is ignored if From Sketch mode is enabled.
    
    Default Value:
    The default value is ChildOrderingPolicy.COMPACT
    
    Parameters:
    
    value - one of the predefined child ordering policies
    
    See Also:
    
    setFromSketchModeEnabled(boolean), setComparator(Comparator), getChildOrderingPolicy()
  - setCompactnessFactor
```
public void setCompactnessFactor(double value)
```
    Sets the factor defining how compact layout results will potentially be, where a smaller factor produces potentially more compact layouts.
    The algorithm tries to optimize the child node arrangement around each tree node such that each subtree is as close to its root as possible, while still fitting into the preferred wedge angle and not overlapping with adjacent subtrees.
    
    High compactness factor values induce the optimization procedure to be less strict and accept less optimal results, while low factor values mean that the optimization will only stop when being nearly optimal. Thus, lower values lead to a potentially higher runtime.
    
    The minimum factor value is 0.05 and the maximum is 1.0.
    
    Throws:
    
    IllegalArgumentException - if the factor is smaller than 0.05 or greater than 1.0
    
    Default Value:
    The default value is 0.5. A factor offering good balance between compactness and runtime.
    
    Parameters:
    
    value - the compactness factor from the interval [0.05, 1.0]
    
    See Also:
    
    getCompactnessFactor()
  - setComparator
```
public void setComparator(Comparator<Object> value)
```
    Sets the Comparator instance that determines the order of the outgoing edges for each node of the tree.
    If no Comparator is specified (i.e. the Comparator is null), the outgoing edges will be sorted according to the current child ordering policy.
    
    If From Sketch mode is enabled, the specified comparator does not have any effect.
    
    Default Value:
    The default value is null. The algorithm uses a built-in sorting logic.
    
    Parameters:
    
    value - a Comparator instance to sort outgoing edges or null if edges are sorted according to the child ordering policy
    
    See Also:
    
    setChildOrderingPolicy(ChildOrderingPolicy), setFromSketchModeEnabled(boolean), getComparator()
  - setComponentLayoutEnabled
```
public void setComponentLayoutEnabled(boolean value)
```
    Sets whether or not the ILayoutStage used for arranging the components of the graph is activated.
    
    Overrides:
    
    setComponentLayoutEnabled in class MultiStageLayout
    
    BalloonLayout can only handle single components. Disabling ComponentLayout will lead to errors during execution.
    
    Default Value:
    The default value is true. The stage that arranges connected graph components is activated.
    
    Parameters:
    
    value - true if the stage that arranges the graph components is activated, false otherwise
    
    See Also:
    
    MultiStageLayout.isComponentLayoutEnabled(), MultiStageLayout.setComponentLayout(ILayoutStage), ComponentLayout
  - setEdgeLabelSpacing
```
public void setEdgeLabelSpacing(double value)
```
    Sets the distance between edge labels belonging to the same edge as well as the distance of the edge labels to the target node of the edge.
    The spacing must have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the given label spacing value is negative
    
    With a spacing of 0, labels will touch each other and the target node.
    
    The spacing value has an effect only if integrated edge labeling is enabled.
    
    Default Value:
    The default value is 4.0. Labels are close together and close to targets.
    
    Parameters:
    
    value - the non-negative edge label spacing
    
    See Also:
    
    setIntegratedEdgeLabelingEnabled(boolean), getEdgeLabelSpacing()
  - setFromSketchModeEnabled
```
public void setFromSketchModeEnabled(boolean value)
```
    Sets whether or not to consider the given coordinates of the input diagram when arranging the tree.
    Enabling this feature, the original circular order of child nodes around their parent nodes will be maintained according to the initial coordinates when determining the order of the child nodes.
    
    Default Value:
    The default value is false. The coordinates of the input are not considered.
    
    Parameters:
    
    value - true if the initial coordinates of the nodes are considered, false otherwise
    
    See Also:
    
    isFromSketchModeEnabled()
  - setHideGroupsStageEnabled
```
public void setHideGroupsStageEnabled(boolean value)
```
    Sets whether or not the ILayoutStage used for hiding group nodes is activated.
    
    Overrides:
    
    setHideGroupsStageEnabled in class MultiStageLayout
    
    BalloonLayout cannot handle group nodes. Disabling HideGroupsStage will lead to errors during execution.
    
    Default Value:
    The default value is true. The stage responsible for hiding group nodes is activated.
    
    Parameters:
    
    value - true if the stage used for hiding group nodes is activated, false otherwise
    
    See Also:
    
    MultiStageLayout.isHideGroupsStageEnabled(), MultiStageLayout.setHideGroupsStage(ILayoutStage), HideGroupsStage
  - setIntegratedEdgeLabelingEnabled
```
public void setIntegratedEdgeLabelingEnabled(boolean value)
```
    Sets whether or not the layout algorithm automatically places edge labels.
    If enabled, this layout algorithm will calculate the positions for the edge labels assuring that no overlaps occur.
    
    Optimal label placement with integrated labeling can be achieved using FreeEdgeLabelLayoutModel as the IEdgeLabelLayoutModel for the edges.
    
    When enabling integrated edge labeling, it is recommended to also enable chain straightening, because edge labels (especially large ones) may lead to significantly non-straight node chains.
    
    Default Value:
    The default value is false. Edge labels are not placed by this algorithm.
    
    Parameters:
    
    value - true if integrated edge labeling is enabled, false otherwise.
    
    See Also:
    
    isIntegratedEdgeLabelingEnabled()
  - setIntegratedNodeLabelingEnabled
```
public void setIntegratedNodeLabelingEnabled(boolean value)
```
    Sets whether or not the layout algorithm automatically places node labels.
    If enabled, this layout algorithm will calculate the positions for the node labels assuring that no overlaps occur.
    
    Different labeling strategies may be selected using NodeLabelingPolicy.
    
    Optimal label placement with integrated labeling can be achieved using FreeNodeLabelLayoutModel as the INodeLabelLayoutModel for the nodes.
    
    If integrated labeling is enabled, then the simple consideration mechanism has no more effect.
    
    Default Value:
    The default value is false. Node labels are not placed by this algorithm.
    
    Parameters:
    
    value - true if integrated node labeling is enabled, false otherwise.
    
    See Also:
    
    setNodeLabelingPolicy(NodeLabelingPolicy), isIntegratedNodeLabelingEnabled()
  - setInterleavedMode
```
public void setInterleavedMode(InterleavedMode value)
```
    Sets the mode for child node arrangement.
    Child nodes are either placed interleaved or on a single layer around their parent node. Interleaved placement means that child nodes are placed around their common parent in two different layers in an alternating fashion. For example, the first child is on the inner layer, the second child on the outer layer, the third one again on the inner layer, etc.
    
    Independent of this mode, the alignment of child nodes on the same layer is still defined by the alignment policy. However, ChildAlignmentPolicy.SMART is only supported for non-interleaved arrangement.
    
    Throws:
    
    IllegalArgumentException - if an unknown mode for interleaved arrangement is given
    
    Interleaved placement leads to the best results if all subtrees rooted at a node have similar total sizes or if there are two groups of different sizes among the subtrees. In these cases, interleaved placement makes drawings much more compact and still shows symmetries.
    
    Activating interleaved child arrangement for all or for selected nodes will cause the ordering policy to have no more effect for those nodes.
    
    Default Value:
    The default value is InterleavedMode.OFF. Interleaved placement is disabled.
    
    Parameters:
    
    value - the mode for interleaved child node arrangement
    
    See Also:
    
    setChildAlignmentPolicy(ChildAlignmentPolicy), getInterleavedMode()
  - setMinimumEdgeLength
```
public void setMinimumEdgeLength(int value)
```
    Sets the minimum length that this layout algorithm assigns to edges of the graph.
    A lower minimum edge length allows generally more compact layouts. It has the highest effect if most nodes of the graph have a low degree, as the minimum can potentially be met for such graphs.
    
    The minimum length must be non-negative.
    
    Throws:
    
    IllegalArgumentException - if the given length is negative
    
    Really small minimum edge length values (i.e. smaller than 5) are not recommended, because edges may be barely visible in the result drawing.
    
    Default Value:
    The default value is 40.
    
    Parameters:
    
    value - the non-negative minimum edge length
    
    See Also:
    
    getMinimumEdgeLength()
  - setMinimumNodeDistance
```
public void setMinimumNodeDistance(int value)
```
    Sets the minimum distance to be kept between the nodes in the tree.
    The distance needs to be a non-negative integer value.
    
    Throws:
    
    IllegalArgumentException - if the given minimum distance is negative
    
    This minimum distance is not always considered if overlaps are allowed.
    
    Default Value:
    The default value is 10.
    
    Parameters:
    
    value - the non-negative minimum node distance
    
    See Also:
    
    setOverlapsAllowed(boolean), getMinimumNodeDistance()
  - setNodeLabelConsiderationEnabled
```
public void setNodeLabelConsiderationEnabled(boolean value)
```
    Sets whether or not the layout algorithm reserves space for node labels.
    The size of nodes will temporarily be adjusted such that the label is included. Therefore, result drawings may get significantly larger if this feature is enabled.
    
    This option only works correctly if the layout orientation is set to LayoutOrientation.TOP_TO_BOTTOM (which is the default). Changing the layout orientation for an undirected layout algorithm like the BalloonLayout doesn't make sense.
    
    This has an effect only if the integrated node labeling mechanism is disabled.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Parameters:
    
    value - true if node labels are considered, false otherwise
    
    See Also:
    
    isNodeLabelConsiderationEnabled()
  - setNodeLabelingPolicy
```
public void setNodeLabelingPolicy(NodeLabelingPolicy value)
```
    Sets the policy defining how node labels are placed by the integrated node labeling mechanism (for example, the desired label orientation).
    
    Throws:
    
    IllegalArgumentException - if an unknown labeling policy is given
    
    The policy only has an effect if integrated node labeling is enabled.
    
    Default Value:
    The default value is NodeLabelingPolicy.RAY_LIKE
    
    Parameters:
    
    value - one of the predefined node labeling policies
    
    See Also:
    
    setIntegratedNodeLabelingEnabled(boolean), getNodeLabelingPolicy()
  - setNodeLabelSpacing
```
public void setNodeLabelSpacing(double value)
```
    Sets the distance between node labels belonging to the same node.
    It also defines the distance between labels and the node they belong to in case of label placement outside of the node (e.g. for ray-like label placement).
    
    The spacing must have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the given spacing value is negative
    
    With a spacing of 0, node labels will be maximally close to each other and to their node.
    
    The spacing value has an effect only if integrated node labeling is enabled.
    
    Default Value:
    The default value is 4.0.
    
    Parameters:
    
    value - the non-negative node label spacing
    
    See Also:
    
    isIntegratedNodeLabelingEnabled(), getNodeLabelSpacing()
  - setOrientationLayoutEnabled
```
public void setOrientationLayoutEnabled(boolean value)
```
    Sets whether or not the ILayoutStage that modifies the orientation of the layout is activated.
    
    Overrides:
    
    setOrientationLayoutEnabled in class MultiStageLayout
    
    If the current layout orientation is LayoutOrientation.TOP_TO_BOTTOM, the orientation of the layout will not be modified.
    
    Based on the undirected layout style, disabling OrientationLayout has no significant effect.
    
    Default Value:
    The default value is true. The orientation ILayoutStage is activated.
    
    Parameters:
    
    value - true if the stage that modifies the orientation is activated, false otherwise
    
    See Also:
    
    MultiStageLayout.isOrientationLayoutEnabled(), MultiStageLayout.setOrientationLayout(ILayoutStage), MultiStageLayout.setLayoutOrientation(com.yworks.yfiles.layout.LayoutOrientation), OrientationLayout
  - setOverlapsAllowed
```
public void setOverlapsAllowed(boolean value)
```
    Sets whether or not (partially) overlapping nodes are allowed.
    If overlaps are allowed, the resulting layouts can become significantly more compact. Overlaps will mostly occur at the borders of nodes. Nodes will not be totally covered by other nodes.
    
    For smaller graphs or graphs where most nodes have a low outdegree count, overlaps will often not occur, even if this property is enabled. This allows really compact drawings of such graphs.
    
    The computation of the convex hull of a node depends on this setting: the outer circle with respect to the rectangle defined by height and width of a node is taken if overlaps ar not allowed. Otherwise, the inner circle is used for the convex hull.
    
    Default Value:
    The default value is false. Nodes are not allowed to overlap.
    
    Parameters:
    
    value - true if node overlaps are allowed, false otherwise
    
    See Also:
    
    isOverlapsAllowed()
  - setParallelEdgeRouterEnabled
```
public void setParallelEdgeRouterEnabled(boolean value)
```
    Sets whether or not the ILayoutStage used for routing parallel edges is activated.
    
    Overrides:
    
    setParallelEdgeRouterEnabled in class MultiStageLayout
    
    BalloonLayout cannot handle parallel edges. Disabling ParallelEdgeRouter will lead to errors during execution.
    
    Default Value:
    The default value is true. The stage that routes parallel edges is activated.
    
    Parameters:
    
    value - true if the stage responsible for routing parallel edges is activated, false otherwise
    
    See Also:
    
    MultiStageLayout.isParallelEdgeRouterEnabled(), MultiStageLayout.setParallelEdgeRouter(ILayoutStage), ParallelEdgeRouter
  - setPreferredChildWedge
```
public void setPreferredChildWedge(int value)
```
    Sets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around their parent node.
    The wedge angle controls the degree to which the child nodes may radiate from the center of layout. A value close to 360 means that the child nodes may radiate in (almost) any direction from their parent node, edge lengths can in consequence stay rather small. On the other hand, a small value means that children are restricted to a small angle; thus, edge lengths (and drawings) may become large.
    
    The minimum allowed wedge angle is 1 and the maximum allowed value is 359.
    
    Throws:
    
    IllegalArgumentException - if the given angle is smaller than 1 or larger than 359
    
    To get drawings where each subtree looks balloon-like, an angle close to 360 is needed.
    
    The angle of the designated root node of the tree is not affected by this setting. The preferred angle of the root can be specified using PreferredRootWedge.
    
    Default Value:
    The default value is 340.
    
    Parameters:
    
    value - the preferred wedge angle in degrees from the interval [1,359]
    
    See Also:
    
    setPreferredRootWedge(int), getPreferredChildWedge()
  - setPreferredRootWedge
```
public void setPreferredRootWedge(int value)
```
    Sets the preferred radial amount (wedge) in degrees that child nodes may in total occupy around the global root.
    This property allows to separately control the wedge angle for the designated root node of the tree, while PreferredChildWedge controls the angles of all child nodes. The root node will be determined depending on the root node policy.
    
    The minimum allowed root wedge angle is 1 and the maximum allowed value is 360.
    
    Throws:
    
    IllegalArgumentException - if the given angle is smaller than 1 or larger than 360
    
    Default Value:
    The default value is 360.
    
    Parameters:
    
    value - the preferred wedge angle in degrees from the interval [1,360]
    
    See Also:
    
    setPreferredChildWedge(int), getPreferredRootWedge()
  - setRootNodePolicy
```
public void setRootNodePolicy(RootNodePolicy value)
```
    Sets the root node selection policy of this layout algorithm.
    The policy determines which node is chosen as (virtual) tree root during the layout process.
    
    Throws:
    
    IllegalArgumentException - if an unknown root node policy is given
    
    Default Value:
    The default value is RootNodePolicy.DIRECTED_ROOT
    
    Parameters:
    
    value - one of the predefined root node policies
    
    See Also:
    
    getRootNodePolicy()
  - setSelfLoopRouterEnabled
```
public void setSelfLoopRouterEnabled(boolean value)
```
    Sets whether or not the ILayoutStage used for routing self-loops is activated.
    
    Overrides:
    
    setSelfLoopRouterEnabled in class MultiStageLayout
    
    BalloonLayout cannot handle self-loops. Disabling SelfLoopRouter will lead to errors during execution.
    
    Default Value:
    The default value is true. The stage that routes self-loops is activated.
    
    Parameters:
    
    value - true if the stage responsible for routing self-loops is activated, false otherwise
    
    See Also:
    
    MultiStageLayout.isSelfLoopRouterEnabled(), MultiStageLayout.setSelfLoopRouter(ILayoutStage), SelfLoopRouter
  - sortChildNodes
```
protected void sortChildNodes(Node root)
```
    Sorts the child nodes (successors) of the given node.
    This implementation uses the original node coordinates if From Sketch mode is enabled. Otherwise it uses the specified comparator to sort the outgoing edges and thus the children of root. If there is no such comparator, then the sorting depends on whether or not the child nodes are placed in an interleaved fashion:
    - Normal: Children are sorted according to the chosen child ordering policy.
    - Interleaved: Children are sorted such that the resulting interleaved node placement is compact, while children inducing larger subgraphs are placed next to smaller ones.
    This method may be overridden to realize a custom child node ordering. It gets called in method calculateChildArrangement(Node) before coordinates are assigned and just after the wedge sizes for all subtrees rooted at root are determined.
    Parameters:
    
    root - the node whose child nodes will be sorted

Class BalloonLayout

Layout Style

Concept

Features

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.yworks.yfiles.layout.MultiStageLayout

Methods inherited from class java.lang.Object

Field Detail

graph

INTERLEAVED_NODES_DPKEY

SELECTED_ROOT_DPKEY

Constructor Detail

BalloonLayout

Method Detail

applyLayoutCore

calculateAngles

calculateAngles

calculateChildArrangement

determineRoot

getChildAlignmentPolicy

getChildOrderingPolicy

getCompactnessFactor

getComparator

getEdgeLabelSpacing

getInterleavedMode

getMinimumEdgeLength

getMinimumNodeDistance

getNodeLabelingPolicy

getNodeLabelSpacing

getPreferredChildWedge

getPreferredChildWedge

getPreferredRootWedge

getRootNodePolicy

isChainStraighteningModeEnabled

isFromSketchModeEnabled

isIntegratedEdgeLabelingEnabled

isIntegratedNodeLabelingEnabled

isNodeLabelConsiderationEnabled

isOverlapsAllowed

setChainStraighteningModeEnabled

setChildAlignmentPolicy

setChildOrderingPolicy

setCompactnessFactor

setComparator

setComponentLayoutEnabled

setEdgeLabelSpacing

setFromSketchModeEnabled

setHideGroupsStageEnabled

setIntegratedEdgeLabelingEnabled

setIntegratedNodeLabelingEnabled

setInterleavedMode

setMinimumEdgeLength

setMinimumNodeDistance

setNodeLabelConsiderationEnabled

setNodeLabelingPolicy

setNodeLabelSpacing

setOrientationLayoutEnabled

setOverlapsAllowed

setParallelEdgeRouterEnabled

setPreferredChildWedge

setPreferredRootWedge

setRootNodePolicy

setSelfLoopRouterEnabled

sortChildNodes