IlvTreeLayout (Rogue Wave JViews 9.2 API)

java.lang.Object
- ilog.views.graphlayout.IlvGraphLayout
- - ilog.views.graphlayout.tree.IlvTreeLayout

All Implemented Interfaces:

GraphModelListener, Serializable, EventListener
```
public class IlvTreeLayout
extends IlvGraphLayout
```
The main class for the Tree Layout algorithm.
The Tree Layout algorithm places the nodes of a tree starting from the root of the tree to the leaves. If the graph has parts that are disconnected, it arranges each connected component as an individual tree. The Tree Layout algorithm is primarily designed for a forest of pure trees. In a tree, each node except the root has a parent node. All the nodes that have the same parent are called children with respect to the parent and siblings with respect to each other. The Tree Layout algorithm can also be used for non-trees (for example, cyclic graphs). In this case, the layout algorithm ignores those links that violate the tree structure and takes only the spanning tree of the graph into account.

The algorithm has several layout modes:
- The nodes can be arranged freely in a horizontal or vertical way. This is suitable for a graph with a large variation of node sizes.
- The nodes can be arranged in horizontal or vertical levels. This is suitable for a graph that contains nodes of approximately the same size.
- The nodes can be arranged radially on concentric circles or on ellipses around the root of the tree.
- The nodes can be arranged radially around parents like balloons.
To simplify the explanations of the layout parameters, we use the compass directions north, south, east, and west. The center of the root node of a tree is the north pole. If the root node is placed at the top border, north is always upwards, south towards the bottom, west towards the left, and east towards the right side of the layout. If the root node is placed at the left border, north is left and south is right. In radial mode, the root is placed in the center, and so the notation of north and south depends on where a node is placed relative to the root. The north side of any node is the side that is closer to the root and the south side is the side that is farther away from the root. In balloon mode, the compass directions make no sense.
Several alignment options are provided. In particular, the free layout mode allows the tip-over alignment, which means that subtrees are arranged serially rather than in parallel. If the subtrees starting at one node are normally arranged horizontally, the tip-over alignment arranges them vertically. The tree layout provides layout modes that automatically adapt the tip-over alignment to best fit the layout to a given aspect ratio.

The following sample drawings are produced by the Tree Layout algorithm. The left drawing uses the level layout mode. The flow direction of the links is towards the bottom, and the nodes are south-justified (that is, they are aligned to the bottom) within each level. The right drawing is the same tree in free layout mode (which always uses north level alignment):

Here is another sample drawing in free layout mode with the tip-over alignment at some leaf nodes:

The following are two sample drawings in the two radial layout modes. The normal radial mode in the left drawing places the nodes of the same level on a circle around the root node. The alternating radial mode in the right drawing places the nodes of the same level alternating on two circles around the root node. This results in better usage of the space.

In nonradial layout modes, the Tree Layout algorithm supports different styles of links in the same drawing. The following sample drawing shows orthogonal and straight-line links. It also shows nodes that are aligned to the center (see the red nodes), to the east (green), and to the west (blue) of their children. The drawing was created by the free layout mode with the link flow direction to the right, and so north is to the left.

The Tree Layout algorithm supports node neighboring in all modes. The following sample drawing shows a tree layout with the flow direction towards the top. Some nodes are not placed as children but rather as neighbors at the same level as the corresponding parent node. The red links, which are perpendicular to the flow direction, are between nodes that were specified as neighbored.

See the corresponding chapter of the User's Manual for details on the algorithm, the types of graphs for which this algorithm can be used, the features and limitations, code samples, and so on.

Note the following points:
- If no root node is specified, the layout algorithm takes the direction of links into account to calculate a root node. Other than that, the direction of links does not affect the layout.
- The layout algorithm has an incremental mode that is designed to be stable when incremental changes are made. If nodes are added or removed after a layout, the next layout uses a heuristic to try to adjust the layout only minimally and to avoid major structural reorganization.
- In incremental mode, the initial position of the nodes (at the moment you start the layout) affects the resulting layout because the algorithm tries to preserve the relative order of the children on incremental changes.
Since:

JViews 2.0

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALTERNATING_RADIAL` Alternating radial layout mode.
`static int`	`AUTOMATIC_PINS` Automatic connector pin option.
`static int`	`BALLOON` Balloon layout mode.
`static int`	`BORDER_CENTER` Border center alignment option.
`static int`	`CENTER` Center alignment option.
`static int`	`CENTERED_PINS` Centered connector pin option.
`static int`	`CLIPPED_PINS` Clipped connector pin option.
`static int`	`EAST` East alignment option.
`static int`	`EAST_NEIGHBOR` East neighbor child alignment option.
`static int`	`EVENLY_SPACED_PINS` Evenly spaced connector pin option.
`static int`	`FAST_PROPORTIONAL` Fast proportional angle spacing.
`static int`	`FREE` Free layout mode.
`static int`	`LEVEL` Level layout mode.
`static int`	`MIXED` Mixed alignment option.
`static int`	`MIXED_STYLE` Mixed link shape option.
`static int`	`NO_RESHAPE_STYLE` No reshape option.
`static int`	`NORTH` North alignment option.
`static int`	`OPTIMIZED_UNIFORM_LEAVES_RADIUS` Optimized uniform balloon radius mode.
`static int`	`OPTIMIZED_VARIABLE_RADIUS` Optimized variable balloon radius mode.
`static int`	`ORTHOGONAL_STYLE` Orthogonal link shape option.
`static int`	`PROPORTIONAL` Slow proportional angle spacing.
`static int`	`RADIAL` Radial layout mode.
`static int`	`REGULAR` Regular angle spacing.
`static int`	`SOUTH` South alignment option.
`static int`	`STRAIGHT_LINE_STYLE` Straight-line link shape option.
`static int`	`TIP_LEAVES_OVER` Tip-over layout mode.
`static int`	`TIP_OVER` Tip-over alignment option.
`static int`	`TIP_OVER_ASSOCIATE_BOTH_SIDES` Associate child alignment option.
`static int`	`TIP_OVER_ASSOCIATE_EAST` Associate east child alignment option.
`static int`	`TIP_OVER_ASSOCIATE_WEST` Associate west child alignment option.
`static int`	`TIP_OVER_BOTH_SIDES` Tip-over to both sides alignment option.
`static int`	`TIP_OVER_EAST` Tip-over east alignment option.
`static int`	`TIP_OVER_EAST_WEST` Tip-over east and west alignment option.
`static int`	`TIP_OVER_WEST` Tip-over west alignment option.
`static int`	`TIP_ROOTS_AND_LEAVES_OVER` Tip-over layout mode.
`static int`	`TIP_ROOTS_OVER` Tip-over layout mode.
`static int`	`UNIFORM_LEAVES_RADIUS` Uniform balloon radius mode.
`static int`	`UNIFORM_RADIUS` Uniform radius mode.
`static int`	`UNSPECIFIED` Unspecified child alignment option.
`static int`	`VARIABLE_RADIUS` Variable balloon radius mode.
`static int`	`WEST` West alignment option.
`static int`	`WEST_NEIGHBOR` West neighbor child alignment option.

Fields inherited from class ilog.views.graphlayout.IlvGraphLayout
INVERSE_VIEW_COORDINATES, MANAGER_COORDINATES, VIEW_COORDINATES

Constructor Summary

Constructors
Constructor and Description
`IlvTreeLayout()` Creates a new instance of the Tree Layout algorithm.
`IlvTreeLayout(IlvTreeLayout source)` Creates a new layout instance by copying an existing one.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAssociate(Object parentNode, Object associateNode)` Sets one node as associate of another node.
`int`	`checkAppropriateLink(Object link)` Checks whether the input link is appropriate for this layout.
`void`	`checkAppropriateLinks()` Throws an exception if the links are not appropriate for the layout.
`void`	`cleanLink(IlvGraphModel graphModel, Object link)` Cleans a link.
`void`	`cleanNode(IlvGraphModel graphModel, Object node)` Cleans a node.
`IlvGraphLayout`	`copy()` Copies the layout instance.
`void`	`copyParameters(IlvGraphLayout source)` Copies the parameters from a given layout instance.
`protected IlvGraphLayoutGrapherProperty`	`createLayoutGrapherProperty(String name, boolean withDefaults)` Returns a new instance of `IlvTreeLayoutGrapherProperty` that stores the parameter settings of this layout class.
`protected IlvGraphLayoutLinkProperty`	`createLayoutLinkProperty(String name, IlvGraphic link, boolean withDefaults)` Returns a new instance of `IlvTreeLayoutLinkProperty` that stores the parameter settings of this layout class for links.
`protected IlvGraphLayoutNodeProperty`	`createLayoutNodeProperty(String name, IlvGraphic node, boolean withDefaults)` Returns a new instance of `IlvTreeLayoutNodeProperty` that stores the parameter settings of this layout class for nodes.
`void`	`detach()` Detaches the graph model from the layout instance.
`int`	`getAlignment(Object node)` Returns the local alignment option of the node.
`double`	`getAspectRatio()` Returns the aspect ratio specified for the layout.
`double`	`getAssociateOffset()` Returns the minimum offset between associates and the orthogonal link segment starting at the parent.
`Object`	`getAssociateParent(Object node)` Returns the parent node for which the input node is an associate.
`Enumeration`	`getAssociates(Object parentNode)` Returns all associate nodes of the input parent node.
`int`	`getBalloonAngleSpacing()` Returns the current angle spacing for balloon layout mode.
`int`	`getBalloonInnerChildrenAngle()` Returns the maximum angle for children of inner nodes in balloon mode.
`int`	`getBalloonLeafChildrenAngle()` Returns the maximum angle for children of nodes that have only leaves as children in balloon mode.
`int`	`getBalloonRadiusMode()` Returns the radius mode for balloon layout mode.
`int`	`getBalloonRootChildrenAngle()` Returns the maximum angle for children of the root node in balloon mode.
`int`	`getBalloonStartAngle()` Returns the start angle of the layout in balloon mode.
`double`	`getBranchOffset()` Returns the minimum offset between neighbor nodes that belong to different branches in the tree.
`Enumeration`	`getCalcBackwardTreeLinks()` Returns the backward links that were used in the reverse direction as part of the spanning tree during layout.
`Enumeration`	`getCalcForwardTreeLinks()` Returns the forward links that were used as part of the spanning tree during layout.
`Enumeration`	`getCalcNonTreeLinks()` Returns the links that were neither forward nor backward links in the spanning tree during layout.
`Enumeration`	`getCalcRoots()` Returns the nodes that were used as roots during layout.
`int`	`getChildAlignment(Object node)` Returns the child alignment option of the node.
`int`	`getConnectorStyle()` Returns the style of the connectors.
`Object`	`getEastNeighbor(Object node)` Returns the specified east neighbor node of the input node, or `null` if none was specified.
`double`	`getEastSubtreeBlockMargin(Object node)` Returns the margin on the east side of the subtree starting at the input node.
`int`	`getFlowDirection()` Returns the current direction of the flow.
`int`	`getGlobalAlignment()` Returns the global alignment option.
`int`	`getGlobalLinkStyle()` Returns the global style of the shapes of links.
`int`	`getLayoutMode()` Returns the current layout mode.
`int`	`getLevelAlignment()` Returns the current alignment within the levels.
`int`	`getLinkStyle(Object link)` Returns the style of the shape of an individual link.
`int`	`getMaxChildrenAngle()` Returns the maximum angle for children that are placed in radial mode.
`IlvGraphicVector`	`getMovingNodes()` Returns the vector of nodes being moved by the graph layout algorithm.
`Comparator`	`getNodeComparator()` Returns the comparator used for sorting the nodes.
`double`	`getNorthSubtreeBlockMargin(Object node)` Returns the margin on the north side of the subtree starting at the input node.
`int`	`getNumberOfAlternatingCircles()` Returns the number of alternating circles.
`double`	`getOrthForkPercentage()` Returns the percentage of the parent-child offset that determines the location where the orthogonal link routing places the bends in order to fork the routing towards the children.
`double`	`getOverlapPercentage()` Returns the percentage for which a node is considered smaller in the flow direction.
`double`	`getParentChildAssociateOffset()` Returns the minimum offset between the parent and the first associate.
`double`	`getParentChildOffset()` Returns the minimum offset between a parent and its children.
`IlvPoint`	`getPosition()` Returns the specified position of the layout.
`int`	`getRootPreference(Object node)` Returns the specified preference of the node to become root node.
`double`	`getSiblingOffset()` Returns the minimum offset between siblings.
`double`	`getSouthSubtreeBlockMargin(Object node)` Returns the margin on the south side of the subtree starting at the input node.
`Enumeration`	`getSpecRoots()` Returns the nodes that were specified as root.
`double`	`getSubtreeBlockMargin(Object node, int side)` Returns the margin on the specified side of the subtree starting at the input node.
`double`	`getTipOverBranchOffset()` Returns the minimum offset in the flow direction between neighbor nodes that belong to different branches in the tree.
`Object`	`getWestNeighbor(Object node)` Returns the specified west neighbor node of the input node, or `null` if none was specified.
`double`	`getWestSubtreeBlockMargin(Object node)` Returns the margin on the west side of the subtree starting at the input node.
`protected void`	`init()` Initializes instance variables.
`boolean`	`isAllLevelsAlternating()` Returns `true` if at all levels, nodes are forced into alternating circular layers.
`boolean`	`isCalcRoot(Object node)` Returns `true` if the input node was used as root during layout.
`boolean`	`isCategorizingLinks()` Returns `true` if the layout algorithm stores the categorization of links into forward, backward, and non-tree links.
`boolean`	`isCategorizingLinksWithoutLayout()` Returns `true` if the layout algorithm does not really perform a full layout.
`boolean`	`isFirstCircleEvenlySpacing()` Returns `true` if the nodes on the first circle must be evenly spaced in radial mode.
`boolean`	`isIncrementalMode()` Returns `true` if the incremental mode is enabled.
`boolean`	`isIntergraphConnectivityMode()` Returns `true` if the intergraph link connectivity is considered for the partitioning of the layout into subtrees.
`boolean`	`isInvisibleRootUsed()` Returns `true` if an invisible root is used to combine components that are disconnected from each other.
`boolean`	`isLocalRecursiveLayoutNeeded(IlvLayoutProvider layoutProvider, IlvGraphLayout recLayout, IlvGraphModel rootModel, boolean traverse)` Checks whether layout is needed when layout is performed recursively on a hierarchy of nested subgraphs.
`boolean`	`isNonTreeLinksStraight()` Returns `true` if all non-tree links that don't have the no-reshape link style and that are not fixed and are not incident to fixed nodes are reshaped to be straight.
`boolean`	`isRecursiveLayoutFromAncestorAllowed()` Returns `true` if the layout instance of an ancestor graph is in principle allowed to treat this subgraph in a recursive layout.
`boolean`	`isRecursiveLeafLayoutMode()` Returns `true` if the recursive layout of nested subgraphs in leaves of the tree is enabled.
`boolean`	`isRespectNodeSizes()` Returns `true` if the algorithm tries to respect the size of the nodes, and `false` otherwise.
`boolean`	`isRootPosition()` Returns `true` if the specified position means the position of the root node.
`boolean`	`isSpecRoot(Object node)` Returns `true` if the input node was specified as root.
`protected void`	`layout(boolean redraw)` Computes the layout using the Tree Layout algorithm.
`void`	`layoutStepPerformed()` This method can be called by the layout classes when a step of the layout algorithm has been performed.
`void`	`removeAllAssociates(Object parentNode)` Removes all the associate nodes from the input parent node.
`void`	`removeAssociate(Object parentNode, Object associateNode)` Removes the associate node from its parent node.
`void`	`setAlignment(Object node, int alignment)` Sets the alignment option of an individual node.
`void`	`setAllLevelsAlternating(boolean enable)` Sets whether at all levels, nodes are forced into alternating circular layers.
`void`	`setAspectRatio(double aspectRatio)` Sets the aspect ratio for the layout.
`void`	`setAspectRatio(IlvManagerView view)` Sets the aspect ratio for the layout from a given view.
`void`	`setAspectRatio(IlvRect rect)` Sets the aspect ratio for the layout from a given rectangle.
`void`	`setAssociateOffset(double offset)` Sets the minimum offset between associates and the orthogonal link segment starting at the parent.
`void`	`setBalloonAngleSpacing(int angleSpacing)` Sets the current angle spacing for balloon layout mode.
`void`	`setBalloonInnerChildrenAngle(int angle)` Sets the maximum angle for children of inner nodes in balloon mode.
`void`	`setBalloonLeafChildrenAngle(int angle)` Sets the maximum angle for children of nodes that have only leaves as children in balloon mode.
`void`	`setBalloonRadiusMode(int radiusMode)` Sets the current radius mode for balloon layout mode.
`void`	`setBalloonRootChildrenAngle(int angle)` Sets the maximum angle for children of the root node in balloon mode.
`void`	`setBalloonStartAngle(int angle)` Sets the start angle of the layout in balloon mode.
`void`	`setBranchOffset(double offset)` Sets the minimum offset between neighbor nodes that belong to different branches in the tree.
`void`	`setCategorizingLinks(boolean flag)` Sets whether the layout algorithm stores the categorization of links into forward, backward, and non-tree links.
`void`	`setCategorizingLinksWithoutLayout(boolean flag)` Sets whether the layout algorithm does not really perform a full layout.
`void`	`setChildAlignment(Object node, int alignment)` Sets the child alignment option of the node.
`void`	`setConnectorStyle(int style)` Sets the style of the connectors.
`void`	`setEastSubtreeBlockMargin(Object node, double margin)` Sets the margin on the east side of the subtree starting at the input node.
`void`	`setEastWestNeighboring(Object eastNode, Object westNode)` Creates an east-west neighboring of two nodes.
`void`	`setFirstCircleEvenlySpacing(boolean enable)` Sets whether the nodes on the first circle must be evenly spaced in radial mode.
`void`	`setFlowDirection(int direction)` Sets the direction of the flow.
`void`	`setGlobalAlignment(int alignment)` Sets the global alignment option.
`void`	`setGlobalLinkStyle(int style)` Sets the global style of the shapes of links.
`void`	`setIncrementalMode(boolean enable)` Sets the incremental mode.
`void`	`setIntergraphConnectivityMode(boolean flag)` Sets whether the intergraph link connectivity is considered for the partitioning of the layout into subtrees.
`void`	`setInvisibleRootUsed(boolean flag)` Sets whether an invisible root is used to combine components that are disconnected from each other.
`void`	`setLayoutMode(int mode)` Sets the layout mode.
`void`	`setLevelAlignment(int alignment)` Sets the alignment within the levels.
`void`	`setLinkStyle(Object link, int style)` Sets the style of the shape of an individual link.
`void`	`setMaxChildrenAngle(int angle)` Sets the maximum angle for children that are placed in radial mode.
`void`	`setNodeComparator(Comparator comparator)` Sets the comparator used for sorting the nodes.
`void`	`setNonTreeLinksStraight(boolean enable)` Sets whether all non-tree links that don't have the no-reshape link style and that are not fixed and are not incident to fixed nodes are reshaped to be straight.
`void`	`setNorthSubtreeBlockMargin(Object node, double margin)` Sets the margin on the north side of the subtree starting at the input node.
`void`	`setNumberOfAlternatingCircles(int numCircles)` Sets the number of alternating circles.
`void`	`setOrthForkPercentage(double percentage)` Sets the percentage of the parent-child offset that determines the location where the orthogonal link routing places the bends in order to fork the routing towards the children.
`void`	`setOverlapPercentage(double percentage)` Sets the percentage for which a node is considered smaller in the flow direction.
`void`	`setParentChildAssociateOffset(double offset)` Sets the minimum offset between the parent and the first associate.
`void`	`setParentChildOffset(double offset)` Sets the minimum offset between a parent and its children.
`void`	`setPosition(IlvPoint point)` Sets the position of the layout.
`void`	`setPosition(IlvPoint point, boolean isRootPosition)` Sets the position of the layout.
`void`	`setRecursiveLayoutFromAncestorAllowed(boolean flag)` Sets whether the layout instance of the ancestor graph is in principle allowed to treat this subgraph in a recursive layout.
`void`	`setRecursiveLeafLayoutMode(boolean flag)` Sets whether the recursive layout of nested subgraphs in leaves of the tree is enabled.
`void`	`setRespectNodeSizes(boolean respect)` Sets whether the algorithm must try to respect the size of the nodes.
`void`	`setRoot(Object node)` Allows you to specify the root(s) of the tree.
`void`	`setRootPosition(boolean isRootPosition)` Sets the meaning of the specified position.
`void`	`setRootPreference(Object node, int preference)` Specifies the preference of the node to become root node.
`void`	`setSiblingOffset(double offset)` Sets the minimum offset between siblings, that is, between nodes that have the same parent in the tree structure.
`void`	`setSouthSubtreeBlockMargin(Object node, double margin)` Sets the margin on the south side of the subtree starting at the input node.
`void`	`setSubtreeBlockMargin(Object node, int side, double margin)` Sets the margin on the specified side of the subtree starting at the input node.
`void`	`setTipOverBranchOffset(double offset)` Sets the minimum offset in the flow direction between neighbor nodes that belong to different branches in the tree.
`void`	`setWestEastNeighboring(Object westNode, Object eastNode)` Creates an east-west neighboring of two nodes.
`void`	`setWestSubtreeBlockMargin(Object node, double margin)` Sets the margin on the west side of the subtree starting at the input node.
`boolean`	`stopImmediately()` Stops the running layout algorithm as soon as possible.
`boolean`	`supportsAllowedTime()` Indicates that this layout class can stop the layout computation in a proper manner when the user-defined allowed time is exceeded.
`boolean`	`supportsLayoutOfConnectedComponents()` Indicates that this layout class can use the generic connected component layout mechanism of the `IlvGraphLayout` base class.
`boolean`	`supportsLinkClipping()` Indicates that this layout class can use a link clip interface to clip the end points of a link.
`boolean`	`supportsLinkConnectionBox()` Indicates that this layout class can use a link connection box interface to calculate the end points of links.
`boolean`	`supportsPercentageComplete()` Indicates that this layout class can estimate the percentage of completion during the run of the layout.
`boolean`	`supportsPreserveFixedLinks()` Indicates that this layout class allows the user to specify fixed links.
`boolean`	`supportsPreserveFixedNodes()` Indicates that this layout class allows the user to specify fixed nodes.
`boolean`	`supportsSaveParametersToNamedProperties()` Indicates that this layout class can transfer the layout parameters to named properties.
`boolean`	`supportsSplineRouting()` Tests if this class supports the generic optimization of spline control points.
`boolean`	`supportsStopImmediately()` Indicates that this layout class can interrupt the current run of the layout immediately in a controlled way.

Methods inherited from class ilog.views.graphlayout.IlvGraphLayout
addGraphLayoutEventListener, addGraphLayoutParameterEventListener, afterLayoutOfSubgraph, attach, attach, beforeLayout, beforeLayoutOfSubgraph, callLayoutStepPerformedIfNeeded, cleanGraphModel, clipAllLinks, clipLink, connectAllLinksToCenter, connectLinkToCenter, contentsChanged, createLayoutReport, getAllowedTime, getAutoLayoutHandler, getBalanceSplineCurveThreshold, getCalcLayoutRegion, getCoordinatesMode, getGrapher, getGraphModel, getInstanceId, getLayout, getLayoutOfConnectedComponents, getLayoutOfConnectedComponentsReport, getLayoutRegion, getLayoutReport, getLayouts, getLinkClipInterface, getLinkConnectionBoxInterface, getMaxSplineCurveSize, getMinBusyTime, getMinSplineCurveSize, getParentLayout, getProperty, getProperty, getRecursiveLayout, getRemainingAllowedTime, getSeedValueForRandomGenerator, getSpecLayoutRegion, getSplineLinkFilter, increasePercentageComplete, isAnimate, isAutoLayout, isFitToView, isFixed, isGeometryUpToDate, isInputCheckEnabled, isLayoutNeeded, isLayoutOfConnectedComponentsEnabled, isLayoutOfConnectedComponentsEnabledByDefault, isLayoutRunning, isLayoutRunning, isLayoutTimeElapsed, isMemorySavings, isParametersUpToDate, isPreserveFixedLinks, isPreserveFixedNodes, isSplineRoutingEnabled, isStoppedImmediately, isStructureUpToDate, isUseDefaultParameters, isUseSeedValueForRandomGenerator, onParameterChanged, onParameterChanged, performAutoLayout, performLayout, performLayout, performLayout, PerformLayout, performSublayout, removeGraphLayoutEventListener, removeGraphLayoutParameterEventListener, setAllowedTime, setAnimate, setAutoCheckAppropriateLinksEnabled, setAutoLayout, setAutoLayoutHandler, setBalanceSplineCurveThreshold, setCoordinatesMode, setFixed, setGeometryUpToDate, setGrapher, setGraphModel, setInputCheckEnabled, setLayoutOfConnectedComponents, setLayoutOfConnectedComponentsEnabled, setLayoutRegion, setLayoutRegion, setLayoutRegion, setLayoutReport, setLayoutRunning, setLinkClipInterface, setLinkConnectionBoxInterface, setMaxSplineCurveSize, setMemorySavings, setMinBusyTime, setMinSplineCurveSize, setParametersUpToDate, setParentLayout, setPreserveFixedLinks, setPreserveFixedNodes, setProperty, setProperty, setSeedValueForRandomGenerator, setSplineLinkFilter, setSplineRoutingEnabled, setStructureUpToDate, setUseDefaultParameters, setUseSeedValueForRandomGenerator, supportsAnimation, supportsLayoutRegion, supportsMemorySavings, supportsRandomGenerator, unfixAllLinks, unfixAllNodes, useAnimateRedraw

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

- Field Detail
  - NO_RESHAPE_STYLE
```
public static final int NO_RESHAPE_STYLE
```
    No reshape option. When used as the argument of the method setGlobalLinkStyle(int), none of the links are reshaped. To specify the shape of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), Constant Field Values
  - STRAIGHT_LINE_STYLE
```
public static final int STRAIGHT_LINE_STYLE
```
    Straight-line link shape option. When used as the argument of the method setGlobalLinkStyle(int), all links that are part of the spanning tree get a straight-line shape. To specify the shape of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), Constant Field Values
  - ORTHOGONAL_STYLE
```
public static final int ORTHOGONAL_STYLE
```
    Orthogonal link shape option. When used as the argument of the method setGlobalLinkStyle(int), all links that are part of the spanning tree get a shape consisting of a sequence of orthogonal line segments. To specify the shape of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), Constant Field Values
  - MIXED_STYLE
```
public static final int MIXED_STYLE
```
    Mixed link shape option. When used as the argument of the method setGlobalLinkStyle(int), each link can have a different shape. The shape of an individual link can be set by setLinkStyle(Object, int).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), Constant Field Values
  - AUTOMATIC_PINS
```
public static final int AUTOMATIC_PINS
```
    Automatic connector pin option. When used as the argument of the method setConnectorStyle(int), the connector style is automatically selected depending on the global link style.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setConnectorStyle(int), setGlobalLinkStyle(int), Constant Field Values
  - CENTERED_PINS
```
public static final int CENTERED_PINS
```
    Centered connector pin option. When used as the argument of the method setConnectorStyle(int), the connector pins of links are placed at the center of the border to which the link is attached.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setConnectorStyle(int), Constant Field Values
  - CLIPPED_PINS
```
public static final int CLIPPED_PINS
```
    Clipped connector pin option. When used as the argument of the method setConnectorStyle(int), the connector pins of links are placed such that the link pointing toward the node center is clipped at the node border.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setConnectorStyle(int), Constant Field Values
  - EVENLY_SPACED_PINS
```
public static final int EVENLY_SPACED_PINS
```
    Evenly spaced connector pin option. When used as the argument of the method method setConnectorStyle(int), the connector pins of links are evenly spaced along the border to which the link is attached.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setConnectorStyle(int), Constant Field Values
  - EAST
```
public static final int EAST
```
    East alignment option. When used as the argument of the method setGlobalAlignment(int), all parent nodes are aligned to the east border of their children. The alignment of an individual node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - WEST
```
public static final int WEST
```
    West alignment option. When used as the argument of the method setGlobalAlignment(int), all parent nodes are aligned to the west border of their children. The alignment of an individual node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - NORTH
```
public static final int NORTH
```
    North alignment option. When used in level layout mode as the argument of the method setLevelAlignment(int), the nodes of the same level are justified to the north side (towards the root).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLevelAlignment(int), Constant Field Values
  - SOUTH
```
public static final int SOUTH
```
    South alignment option. When used in level layout mode as the argument of the method setLevelAlignment(int), the nodes of the same level are justified to the south side (away from the root).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLevelAlignment(int), Constant Field Values
  - CENTER
```
public static final int CENTER
```
    Center alignment option. When used as the argument of the method setGlobalAlignment(int), all parent nodes are centered with respect to their children. The alignment of an individual node can be set by setAlignment(Object, int).
    When used in level layout mode as the argument of the method setLevelAlignment(int), the nodes of the same level are justified to their centers.
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), setLevelAlignment(int), Constant Field Values
  - BORDER_CENTER
```
public static final int BORDER_CENTER
```
    Border center alignment option. When used as the argument of the method setGlobalAlignment(int), all parent nodes are centered with respect to the border of their children. The alignment of an individual node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - TIP_OVER
```
public static final int TIP_OVER
```
    Tip-over alignment option.
    When used as the argument of the method setGlobalAlignment(int), it behaves like TIP_OVER_EAST. The alignment of an individual parent node can be set by setAlignment(Object, int).
    
    When used as the argument of the method setLayoutMode(int), all links flow roughly in the flow direction. In this layout mode, the algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio by calculating which individual nodes need tip-over alignment and which nodes can use the specified alignment. The layout algorithm uses a fast heuristic.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), setLayoutMode(int), Constant Field Values
  - TIP_OVER_EAST
```
public static final int TIP_OVER_EAST
```
    Tip-over east alignment option.
    When used as the argument of the method setGlobalAlignment(int), the children are arranged serially rather than in parallel, on the east side of the parent node.. For instance, if the children are normally arranged horizontally below each parent node, the tip-over alignment arranges them vertically on the east side below the parent node. The alignment of an individual parent node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - TIP_OVER_WEST
```
public static final int TIP_OVER_WEST
```
    Tip-over west alignment option.
    When used as the argument of the method setGlobalAlignment(int), the children are arranged serially rather than in parallel, on the west side of the parent node.. For instance, if the children are normally arranged horizontally below each parent node, the tip-over alignment arranges them vertically on the west side below the parent node. The alignment of an individual parent node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - TIP_OVER_EAST_WEST
```
public static final int TIP_OVER_EAST_WEST
```
    Tip-over east and west alignment option.
    When used as the argument of the method setGlobalAlignment(int), the children are arranged serially rather than in parallel, alternating on the east and on the west side of the parent node. This is basically a combination of TIP_OVER_EAST and TIP_OVER_WEST. The first child is placed on the east side. Further children are placed on the east or west side, so that the space usage on both sides is roughly the same, i.e., the subtrees on the east side have roughly the same sum of height than the subtrees on the west side. The alignment of an individual parent node can be set by setAlignment(Object, int).
    
    Since this alignment option decides between east and west side depending on subtree sizes, it is not well suited in incremental mode (see setIncrementalMode(boolean)), since little changes in the graph can cause big changes in the layout even if the incremental mode is switched on.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), setIncrementalMode(boolean), Constant Field Values
  - TIP_OVER_BOTH_SIDES
```
public static final int TIP_OVER_BOTH_SIDES
```
    Tip-over to both sides alignment option.
    When used as the argument of the method setGlobalAlignment(int), the child nodes are arranged in pairs serially rather than in parallel. This style is very similar to the style TIP_OVER_EAST_WEST, because both the east and west sides are used. However, the algorithm does not try to optimize the space used on both sides; instead it always puts the odd-numbered child nodes to the west and the even-numbered child nodes to the east. The pairs of child nodes, one on the east side and one on the west side, are aligned with one another. The alignment of an individual parent node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - MIXED
```
public static final int MIXED
```
    Mixed alignment option. When used as the argument of the method setGlobalAlignment(int), each node can have a different alignment. The alignment of an individual node can be set by setAlignment(Object, int).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalAlignment(int), setAlignment(Object, int), Constant Field Values
  - UNSPECIFIED
```
public static final int UNSPECIFIED
```
    Unspecified child alignment option. When used as the argument of the method setChildAlignment(Object, int), the child passed as argument uses the alignment of the parent node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setChildAlignment(Object, int), Constant Field Values
  - EAST_NEIGHBOR
```
public static final int EAST_NEIGHBOR
```
    East neighbor child alignment option. When used as the argument of the method setChildAlignment(Object, int), the child passed as argument is made a neighbor at the east side of its parent node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setEastWestNeighboring(Object, Object), setChildAlignment(Object, int), Constant Field Values
  - WEST_NEIGHBOR
```
public static final int WEST_NEIGHBOR
```
    West neighbor child alignment option. When used as the argument of the method setChildAlignment(Object, int), the child passed as argument is made a neighbor at the west side of its parent node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setEastWestNeighboring(Object, Object), setChildAlignment(Object, int), Constant Field Values
  - TIP_OVER_ASSOCIATE_BOTH_SIDES
```
public static final int TIP_OVER_ASSOCIATE_BOTH_SIDES
```
    Associate child alignment option. When used as the argument of the method setChildAlignment(Object, int), the child is laid out like an associate node of its parent node. Associate nodes occur alternating on the east or west side of its parent node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    addAssociate(Object, Object), setChildAlignment(Object, int), Constant Field Values
  - TIP_OVER_ASSOCIATE_EAST
```
public static final int TIP_OVER_ASSOCIATE_EAST
```
    Associate east child alignment option. When used as the argument of the method setChildAlignment(Object, int), the child is laid out like an associate node of its parent node. This associate nodes occurs on the east side of its parent node.
    
    Since:
    
    JViews 8.8
    
    See Also:
    
    addAssociate(Object, Object), setChildAlignment(Object, int), Constant Field Values
  - TIP_OVER_ASSOCIATE_WEST
```
public static final int TIP_OVER_ASSOCIATE_WEST
```
    Associate west child alignment option. When used as the argument of the method setChildAlignment(Object, int), the child is laid out like an associate node of its parent node. This associate nodes occurs on the west side of its parent node.
    
    Since:
    
    JViews 8.8
    
    See Also:
    
    addAssociate(Object, Object), setChildAlignment(Object, int), Constant Field Values
  - FREE
```
public static final int FREE
```
    Free layout mode. When used as the argument of the method setLayoutMode(int), all links flow roughly in the flow direction. Parents and sibling nodes are aligned according to the specified alignment option, but nodes of different tree branches are not justified with each other,
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - LEVEL
```
public static final int LEVEL
```
    Level layout mode. When used as the argument of the method setLayoutMode(int), all links flow roughly in the flow direction. All nodes are organized in levels and are justified to their borders or centered according to the level alignment option. Tip-over node alignment is not possible; all other alignment options are possible.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - RADIAL
```
public static final int RADIAL
```
    Radial layout mode. When used as the argument of the method setLayoutMode(int), the root node is in the center and the links flow radially away from the center. The nodes are placed in circular layers around the root node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - ALTERNATING_RADIAL
```
public static final int ALTERNATING_RADIAL
```
    Alternating radial layout mode. When used as the argument of the method setLayoutMode(int), the root node is in the center and the links flow radially away from the center. The nodes are placed in circular layers around the root node. To optimize space, siblings may be placed alternating in several different circular layers. The alternating radial mode differs only from the radial mode if the alternating placement produces smaller circles.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - BALLOON
```
public static final int BALLOON
```
    Balloon layout mode. When used as the argument of the method setLayoutMode(int), the root node is in the center and the subtrees are arranged as balloon circles around the root. Each subtree froms its own balloon recursively.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - TIP_LEAVES_OVER
```
public static final int TIP_LEAVES_OVER
```
    Tip-over layout mode. When used as the argument of the method setLayoutMode(int), all links flow roughly in the flow direction. The algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio by calculating which individual nodes need tip-over alignment and which nodes can use the specified alignment. The layout algorithm uses a heuristic that checks whether leaf nodes (and their immediate parent nodes) should be tipped over. It checks only the alignment mode TIP_OVER_EAST, but not TIP_OVER_BOTH_SIDES or other variants.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - TIP_ROOTS_OVER
```
public static final int TIP_ROOTS_OVER
```
    Tip-over layout mode. When used as the argument of the method setLayoutMode(int), all links flow roughly in the flow direction. The algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio by calculating which individual nodes need tip-over alignment and which nodes can use the specified alignment. The layout algorithm uses a heuristic that checks whether root nodes (and their immediate children nodes) should be tipped over. It checks only the alignment mode TIP_OVER_EAST, but not TIP_OVER_BOTH_SIDES or other variants.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - TIP_ROOTS_AND_LEAVES_OVER
```
public static final int TIP_ROOTS_AND_LEAVES_OVER
```
    Tip-over layout mode. When used as the argument of the method setLayoutMode(int), all links flow roughly in the flow direction. The algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio by calculating which individual nodes need tip-over alignment and which nodes can use the specified alignment. The layout algorithm uses a heuristic that checks whether root nodes and leaf nodes should be tipped over. It checks only the alignment mode TIP_OVER_EAST, but not TIP_OVER_BOTH_SIDES or other variants.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), Constant Field Values
  - REGULAR
```
public static final int REGULAR
```
    Regular angle spacing. When used as the argument of the method setBalloonAngleSpacing(int) in balloon layout mode, the available angle range at a node is evenly split so that each subtrees at the node can occupy the same angle.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonAngleSpacing(int), Constant Field Values
  - FAST_PROPORTIONAL
```
public static final int FAST_PROPORTIONAL
```
    Fast proportional angle spacing. When used as the argument of the method setBalloonAngleSpacing(int) in balloon layout mode, the available angle range at a node is proprionally split so that larger subtrees at the node can occupy larger angles. The algorithm uses a fast heuristic to calculate the angle ranges.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonAngleSpacing(int), Constant Field Values
  - PROPORTIONAL
```
public static final int PROPORTIONAL
```
    Slow proportional angle spacing. When used as the argument of the method setBalloonAngleSpacing(int) in balloon layout mode, the available angle range at a node is proprionally split so that larger subtrees at the node can occupy larger angles. The algorithm uses a slow heuristic to calculate the angle ranges, which is often more precise than the fast heuristic.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonAngleSpacing(int), Constant Field Values
  - VARIABLE_RADIUS
```
public static final int VARIABLE_RADIUS
```
    Variable balloon radius mode. When used as the argument of the method setBalloonRadiusMode(int) in balloon layout mode, the radius of different child balloons at the same parent node can vary.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRadiusMode(int), Constant Field Values
  - OPTIMIZED_VARIABLE_RADIUS
```
public static final int OPTIMIZED_VARIABLE_RADIUS
```
    Optimized variable balloon radius mode. When used as the argument of the method setBalloonRadiusMode(int) in balloon layout mode, the radius of different child balloons at the same parent node can vary. An additional optimization heuristic reduces the radius. This has the advantage of smaller space requirements but looses symmetries in the diagram.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRadiusMode(int), Constant Field Values
  - UNIFORM_LEAVES_RADIUS
```
public static final int UNIFORM_LEAVES_RADIUS
```
    Uniform balloon radius mode. When used as the argument of the method setBalloonRadiusMode(int) in balloon layout mode, the radiuses of all leaves that are children of the same node are uniform. The radius of balloons that contain more than one node can still vary.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRadiusMode(int), Constant Field Values
  - OPTIMIZED_UNIFORM_LEAVES_RADIUS
```
public static final int OPTIMIZED_UNIFORM_LEAVES_RADIUS
```
    Optimized uniform balloon radius mode. When used as the argument of the method setBalloonRadiusMode(int) in balloon layout mode, the radiuses of all leaves that are children of the same node are uniform. The radius of balloons that contain more than one node can still vary. An additional optimization heuristic reduces the radius. This has the advantage of smaller space requirements but looses symmetries in the diagram.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRadiusMode(int), Constant Field Values
  - UNIFORM_RADIUS
```
public static final int UNIFORM_RADIUS
```
    Uniform radius mode. When used as the argument of the method setBalloonRadiusMode(int) in balloon layout mode, the radiuses of all subtree balloons that are children of the same node are uniform.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRadiusMode(int), Constant Field Values
- Constructor Detail
  - IlvTreeLayout
```
public IlvTreeLayout()
```
    Creates a new instance of the Tree Layout algorithm.
    To indicate the grapher you want to lay out, use the method IlvGraphLayout.attach(IlvGrapher).
    To indicate the graph model you want to lay out, use the method IlvGraphLayout.attach(IlvGraphModel).
    To perform the layout, use the method IlvGraphLayout.performLayout().
    To modify the layout parameters, use the different methods provided in this class and its superclass.
    
    See Also:
    
    IlvGraphLayout.attach(IlvGrapher), IlvGraphLayout.attach(IlvGraphModel), IlvGraphLayout.performLayout()
  - IlvTreeLayout
```
public IlvTreeLayout(IlvTreeLayout source)
```
    Creates a new layout instance by copying an existing one. This constructor is used by the copy() method. Any subclass should provide a copy constructor.
    The parameters of the source layout are copied using the method copyParameters(IlvGraphLayout).
    
    Parameters:
    
    source - The layout instance that is copied.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copy(), copyParameters(IlvGraphLayout)
- Method Detail
  - init
```
protected void init()
```
    Initializes instance variables.
    You should not call this method directly. The method is called internally by the constructor without arguments and by the copy constructor. The method must be overridden by subclasses that need to initialize additional instance variables.
    
    Overrides:
    
    init in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
  - copy
```
public IlvGraphLayout copy()
```
    Copies the layout instance.
    This method copies the layout instance by calling the copy constructor.
    
    When performing a recursive layout of a nested graph, this method is used by IlvLayoutProvider to "clone" the layout instance of a parent graph. Note that the parameters which are specific to a node or a link are not copied. Only the global parameters are copied. The layout position is not copied.
    
    Specified by:
    
    copy in class IlvGraphLayout
    
    Returns:
    
    A copy of the layout instance.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copyParameters(IlvGraphLayout), setPosition(IlvPoint), setPosition(IlvPoint, boolean)
  - copyParameters
```
public void copyParameters(IlvGraphLayout source)
```
    Copies the parameters from a given layout instance.
    Note that the parameters which are specific to a node or a link are not copied. Only the global parameters are copied. The layout position is not copied.
    
    Overrides:
    
    copyParameters in class IlvGraphLayout
    
    Parameters:
    
    source - The layout instance from which the parameters are copied.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copy(), setPosition(IlvPoint), setPosition(IlvPoint, boolean)
  - layout
```
protected void layout(boolean redraw)
               throws IlvGraphLayoutException
```
    Computes the layout using the Tree Layout algorithm. To start the layout, call the method IlvGraphLayout.performLayout().
    
    Specified by:
    
    layout in class IlvGraphLayout
    
    Parameters:
    
    redraw - If true, the attached graph model will be asked to redraw the graph after layout. When the layout algorithm moves the nodes and reshapes the links, it is required to pass the value of the redraw argument to the methods IlvGraphModel.moveNode(java.lang.Object, double, double, boolean) and IlvGraphModel.reshapeLink(java.lang.Object, ilog.views.IlvPoint, ilog.views.IlvPoint[], int, int, ilog.views.IlvPoint, boolean).
    
    Throws:
    
    IlvGraphLayoutException - If an unusual situation occurs. WARNING: this method can throw one of the subclasses of IlvGraphLayoutException. Specifically, it can throw an IlvInappropriateGraphException. It can also throw an IlvInappropriateLinkException when inappropriate types of links and/or link connectors are used in an IlvGrapher. For details, refer to the documentation of these exception classes.
    
    See Also:
    
    IlvGraphLayout.performLayout()
  - detach
```
public void detach()
```
    Detaches the graph model from the layout instance. When you attach a new graph model to the layout instance, you do not need to detach the old graph model because this is done automatically when you call IlvGraphLayout.attach(IlvGraphModel). The detach method performs cleaning operations on the graph model. In addition to the cleaning operations in the base class, the Tree Layout removes the alignment, root preference, and node neighboring specifications of individual nodes, and the link style specifications of individual links.
    Note that you must call this method when you no longer need the layout instance. Otherwise, some objects may not be garbage collected.
    
    Overrides:
    
    detach in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.attach(IlvGrapher), IlvGraphLayout.attach(IlvGraphModel), setAlignment(Object, int), setRootPreference(Object, int), setLinkStyle(Object, int), setEastWestNeighboring(Object, Object)
  - cleanNode
```
public void cleanNode(IlvGraphModel graphModel,
                      Object node)
```
    Cleans a node. This method removes any data that has been stored by the layout algorithm on a node. In addition to the cleaning operations in the base class, Tree Layout removes the root node preference and the alignment and east/west attachment settings from the nodes.
    Subclasses can override this method to remove additional information stored in the nodes.
    
    Overrides:
    
    cleanNode in class IlvGraphLayout
    
    Parameters:
    
    graphModel - The graph model to which node belongs.
    
    node - The node to be cleaned.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    detach()
  - cleanLink
```
public void cleanLink(IlvGraphModel graphModel,
                      Object link)
```
    Cleans a link. This method removes any data that has been stored by the layout algorithm on a link. In addition to the cleaning operations in the base class, Tree Layout removes the link style settings from the nodes.
    Subclasses can override this method to remove additional information stored in the links.
    
    Overrides:
    
    cleanLink in class IlvGraphLayout
    
    Parameters:
    
    graphModel - The graph model to which link belongs.
    
    link - The link to be cleaned.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    detach()
  - supportsPreserveFixedNodes
```
public final boolean supportsPreserveFixedNodes()
```
    Indicates that this layout class allows the user to specify fixed nodes.
    Fixed nodes are not moved during the layout if the method IlvGraphLayout.setPreserveFixedNodes(boolean) is called with a true argument. Links that are incident to fixed nodes are not reshaped during the layout. Fixed nodes are ignored by the Tree Layout algorithm, which may lead to node overlaps. The effect is very similar to the effect when the node is filtered during layout.
    
    Overrides:
    
    supportsPreserveFixedNodes in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGrapherAdapter.setFilter(IlvLayoutGraphicFilter), IlvGraphLayout.setPreserveFixedNodes(boolean), IlvGraphLayout.isPreserveFixedNodes()
  - supportsPreserveFixedLinks
```
public final boolean supportsPreserveFixedLinks()
```
    Indicates that this layout class allows the user to specify fixed links. Fixed links are not reshaped during the layout if the method IlvGraphLayout.setPreserveFixedLinks(boolean) is called with a true argument. Fixed links are ignored by the Tree Layout algorithm, which may lead to overlaps. The effect is very similar to the effect when the link is filtered during layout.
    
    Overrides:
    
    supportsPreserveFixedLinks in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    IlvGrapherAdapter.setFilter(IlvLayoutGraphicFilter), IlvGraphLayout.setPreserveFixedLinks(boolean), IlvGraphLayout.isPreserveFixedLinks(), setGlobalLinkStyle(int), setLinkStyle(Object, int)
  - supportsAllowedTime
```
public final boolean supportsAllowedTime()
```
    Indicates that this layout class can stop the layout computation in a proper manner when the user-defined allowed time is exceeded. If the allowed time elapses before termination of the Tree Layout algorithm, the nodes and links are not moved and remain at the same position as before the start of the algorithm. The result code in the layout report is IlvGraphLayoutReport.STOPPED_AND_INVALID in this case.
    
    Overrides:
    
    supportsAllowedTime in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayout.setAllowedTime(long), IlvGraphLayout.getAllowedTime(), IlvGraphLayoutReport.getCode()
  - supportsStopImmediately
```
public final boolean supportsStopImmediately()
```
    Indicates that this layout class can interrupt the current run of the layout immediately in a controlled way. If the algorithm is stopped before termination of the Tree Layout algorithm, the nodes and links are not moved and remain at the same position as before the start of the algorithm. The result code in the layout report is IlvGraphLayoutReport.STOPPED_AND_INVALID in this case.
    
    Overrides:
    
    supportsStopImmediately in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayout.stopImmediately(), IlvGraphLayout.isStoppedImmediately(), IlvGraphLayoutReport.getCode()
  - stopImmediately
```
public boolean stopImmediately()
```
    Stops the running layout algorithm as soon as possible. The Tree Layout algorithm has several steps. During the early steps, the layout algorithm can be stopped and the method returns true. In the last step, the layout algorithm cannot be stopped and the method returns false.
    
    Overrides:
    
    stopImmediately in class IlvGraphLayout
    
    Returns:
    
    true during the early steps of the layout algorithm and false in the last step when the layout algorithm cannot be stopped.
    
    See Also:
    
    IlvGraphLayoutReport.getCode(), IlvGraphLayout.supportsStopImmediately(), IlvGraphLayout.isStoppedImmediately()
  - supportsPercentageComplete
```
public final boolean supportsPercentageComplete()
```
    Indicates that this layout class can estimate the percentage of completion during the run of the layout.
    
    Overrides:
    
    supportsPercentageComplete in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayout.increasePercentageComplete(int), IlvGraphLayoutReport.getPercentageComplete(), IlvJGraphLayoutProgressBar
  - supportsLayoutOfConnectedComponents
```
public final boolean supportsLayoutOfConnectedComponents()
```
    Indicates that this layout class can use the generic connected component layout mechanism of the IlvGraphLayout base class. This mechanism cuts the attached graph into connected components, applies itself to each connected component separately, and then uses the layout instance returned by the method IlvGraphLayout.getLayoutOfConnectedComponents() to position the connected components. By default, this layout is an instance of IlvGridLayout which can be customized as needed.
    The generic connected component layout mechanism has the disadvantage that it moves connected components completely. Fixed nodes within a component do not preserve their old positions, and the resulting layout may be unstable on incremental changes in incremental mode, depending on which layout instance is used for the component layout.
    
    If the generic connected component layout mechanism is disabled, the algorithm uses its own specialized internal mechanism instead of the generic mechanism to lay out each component as a separate tree. This is usually faster and more stable on incremental changes than the generic mechanism. In addition, it enables the user to set the position of the layout.
    
    Overrides:
    
    supportsLayoutOfConnectedComponents in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayout.getLayoutOfConnectedComponents(), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean), IlvGraphLayout.performLayout(boolean, boolean), setIncrementalMode(boolean)
  - supportsLinkConnectionBox
```
public boolean supportsLinkConnectionBox()
```
    Indicates that this layout class can use a link connection box interface to calculate the end points of links. The link connection box interface is an object that provides the rectangle to which the links are connected for each node and the tangential shift offset at each side for the connection points. This is useful if the connection points of the links at a node should be relative to a rectangle that is smaller or larger than the real bounding box of the node.
    Link connection points are not calculated for links that have the no-reshape link style, that are fixed, or that are not tree links. Only the connection points of reshapeable tree links are calculated.
    
    If a connection box interface object is set using the method IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface), the layout algorithm uses this object together with the connector style to calculate the connection points for links.
    If a link clip interface is set additionally, the layout algorithm calculates the initial connection points at the node boxes with the link connection box interface and the connector style and obtains the final connection points at the border of the node shapes by clipping with the link clip interface. This works well particularly if the node box obtained by the link connection box interface is smaller than the real bounding box of the node.
    
    Overrides:
    
    supportsLinkConnectionBox in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface), IlvGraphLayout.setLinkClipInterface(IlvLinkClipInterface), setLinkStyle(Object, int), setConnectorStyle(int), getCalcNonTreeLinks(), supportsLinkClipping()
  - supportsLinkClipping
```
public boolean supportsLinkClipping()
```
    Indicates that this layout class can use a link clip interface to clip the end points of a link. The link clip interface is an object that provides the connection for a link clipped at the border of the shape of the end node. This is useful if the nodes have a nonrectangular shape such as a triangle, rhombus, or circle. If no link clip interface is used, the links are normally connected to the bounding boxes of the nodes, not to the border of the node shapes.
    Links are not clipped if they have the no-reshape link style, if they are fixed, or if they are not tree links. Only reshapeable tree links are clipped.
    
    If a clip interface object is set using the method setLinkClipInterface, the layout algorithm uses this object to calculate final clipped connection points for links at the border of the node shapes, after some initial connection points at the bounding box of the nodes were preliminarily obtained from the connector style (see setConnectorStyle(int)). The mechanism works best for straight links if the connector style CLIPPED_PINS is used in addition to the link clip interface. For orthogonal links, the connector style EVENLY_SPACED_PINS can be used.
    
    If a link connection box interface is set additionally, the layout algorithm calculates the initial connection points by respecting node boxes obtained by the link connection box interface (instead of the bounding box) and obtains the final connection points at the border of the node shaped by clipping with the link clip interface. This works well particularly if the node box obtained by the the link connection box interface is smaller than the real bounding box of the node.
    
    Overrides:
    
    supportsLinkClipping in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvGraphLayout.setLinkClipInterface(IlvLinkClipInterface), IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface), setLinkStyle(Object, int), setConnectorStyle(int), getCalcNonTreeLinks(), supportsLinkConnectionBox()
  - supportsSaveParametersToNamedProperties
```
public final boolean supportsSaveParametersToNamedProperties()
```
    Indicates that this layout class can transfer the layout parameters to named properties. This mechanism can be used if layout parameters must be stored persistently in an .ivl file.
    
    Overrides:
    
    supportsSaveParametersToNamedProperties in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()
  - supportsSplineRouting
```
public boolean supportsSplineRouting()
```
    Tests if this class supports the generic optimization of spline control points. If spline links such as IlvSplineLinkImage and IlvGeneralLink are used, the bend points calculated by the layout algorithm are often suboptimal. A generic optimization mechanism is available that can be enabled by calling IlvGraphLayout.setSplineRoutingEnabled(boolean).
    Due to the nature of a tree, the optimized spline routing is less seldom needed for tree layout, while it is highly useful for other layout styles such as hierarchical layout. Optimized spline routing is offered for tree layout for consistency reasons.
    
    Overrides:
    
    supportsSplineRouting in class IlvGraphLayout
    
    Returns:
    
    This implementation always returns true.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvGraphLayout.setSplineRoutingEnabled(boolean), IlvGraphLayout.setMinSplineCurveSize(double), IlvGraphLayout.setMaxSplineCurveSize(double), IlvGraphLayout.setBalanceSplineCurveThreshold(double), IlvGraphLayout.setSplineLinkFilter(IlvSplineLinkFilter)
  - setGlobalLinkStyle
```
public final void setGlobalLinkStyle(int style)
```
    Sets the global style of the shapes of links. Valid values are:
    - ORTHOGONAL_STYLE - all links have an orthogonal shape, that is, a shape consisting of a sequence of orthogonal line segments. This option is not available for the radial layout modes.
    - STRAIGHT_LINE_STYLE - all links have a straight-line shape.
    - NO_RESHAPE_STYLE - no reshape is performed on any link.
    - MIXED_STYLE - each link can have a different link style. The style of each individual link can be set by the method setLinkStyle(Object, int) so that different link shapes can occur in the same graph.
    Unless the global link style is MIXED_STYLE, all links have the same shape style.
    
    The default value is STRAIGHT_LINE_STYLE.
    
    Note that when the graph attached to the layout is of type IlvGrapher, the effect of the link reshaping depends on the type of the links and the connectors installed at the node. For all link styles, we recommend using links of type IlvPolylineLinkImage. For the orthogonal link style, we additionally recommend using link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinkTypes and method IlvGraphLayoutUtil.EnsureAppropriateLinkConnectors before layout, or the method IlvGraphLayoutUtil.EnsureAppropriateLinks when the exception is caught, to convert all links to an appropriate type.
    Since:
    
    JViews 3.5
    
    See Also:
    
    getGlobalLinkStyle(), setLinkStyle(Object, int), setLayoutMode(int)
  - getGlobalLinkStyle
```
public final int getGlobalLinkStyle()
```
    Returns the global style of the shapes of links.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalLinkStyle(int)
  - setConnectorStyle
```
public final void setConnectorStyle(int style)
```
    Sets the style of the connectors.
    Valid values are:
    - CENTERED_PINS - the link connector pins are placed in the center of the border of the node bounding box to which the link is attached.
    - CLIPPED_PINS - each link pointing to the center of the node is clipped at the bounding box of the node. This style affects straight links; it behaves like centered connector pins for orthogonal links.
    - EVENLY_SPACED_PINS - the link connector pins are evenly spaced along the border of the node bounding box.
    - AUTOMATIC_PINS - the connector style is selected depending on the link style.
    The default value is AUTOMATIC_PINS.
    
    The connector style is ignored in the radial layout modes because clipped pins are always used in this case . The placement of connector pins also depends on the link clip interface and the connection box interface, in the following way:
    1. First, the bounding box of an end node is obtained. If a link connection box interface was set via IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface), the bounding box and offsets are delivered by that interface. Otherwise, the node bounding box delivered by the graph model (see IlvGraphModel.boundingBox(Object) ) is used.
    2. Next, the initial connector pin of the link is placed at this bounding box in the manner specified by the connector style.
    3. Finally, if a link clip interface was set via setLinkClipInterface, the connector pins are corrected by clipping with that interface.
    Note that when the graph attached to the layout is of type IlvGrapher, the effect of the connector style depends on the type of the connectors installed at the node. We recommend using link connectors of type IlvFreeLinkConnector. Other connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinkConnectors before layout, or the method IlvGraphLayoutUtil.EnsureAppropriateLinks when the exception is caught, to install the appropriate connectors.
    Since:
    
    JViews 5.0
    
    See Also:
    
    setLayoutMode(int), getConnectorStyle(), supportsLinkClipping(), supportsLinkConnectionBox()
  - getConnectorStyle
```
public final int getConnectorStyle()
```
    Returns the style of the connectors.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setConnectorStyle(int)
  - setFlowDirection
```
public final void setFlowDirection(int direction)
```
    Sets the direction of the flow. Valid values are:
    - IlvDirection.Right - the root is on the left and the links flow to the right.
    - IlvDirection.Left - the root is on the right and the links flow to the left.
    - IlvDirection.Bottom - the root is at the top and the links flow to the bottom.
    - IlvDirection.Top - the root is at the bottom and the links flow to the top.
    Note that except for the radial layout modes, the compass direction SOUTH is identical to the flow direction.
    In the radial layout modes, all links flow radially from the center of the root outward. If connected component processing is disabled, the flow direction affects only the arrangement of disconnected trees in the radial modes.
    
    The default value is IlvDirection.Right .
    Since:
    
    JViews 3.5
    
    See Also:
    
    getFlowDirection(), setLayoutMode(int), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean)
  - getFlowDirection
```
public final int getFlowDirection()
```
    Returns the current direction of the flow.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFlowDirection(int)
  - setLayoutMode
```
public final void setLayoutMode(int mode)
```
    Sets the layout mode. Valid values are:
    - FREE - all links flow roughly in the flow direction. Nodes of different tree branches (that is, nodes with a different parent node) are not justified to each other; therefore, the level alignment parameter is ignored. Tip-over alignment is possible if specified as alignment. All link styles are possible. The aspect ratio is ignored.
    - LEVEL - all links flow roughly in the flow direction. Nodes are organized in levels and are justified to their borders or centered according to the level alignment parameter. Tip-over alignment is not possible, but all link styles are possible. The aspect ratio is ignored.
    - TIP_OVER - similar to the mode FREE. However, in mode TIP_OVER, the algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio. Using a fast heuristic, it chooses the local alignment TIP_OVER_EAST for some nodes but keeps the alignment of all other nodes as specified. This heuristic is a fast compromise between the modes TIP_LEAVES_OVER, TIP_ROOTS_OVER, and TIP_ROOTS_AND_LEAVES_OVER.
    - TIP_LEAVES_OVER - similar to the mode TIP_OVER. The algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio. This slow heuristic tries to tip over beginning with the leaves and then chooses the best layout. It checks the alignment mode TIP_OVER_EAST, but not TIP_OVER_BOTH_SIDES or other variants. It keeps the alignment of all nodes close to the root as specified.
    - TIP_ROOTS_OVER - similar to the mode TIP_OVER. The algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio. This slow heuristic tries to tip over beginning with the roots and then chooses the best layout. It checks the alignment mode TIP_OVER_EAST, but not TIP_OVER_BOTH_SIDES or other variants. It keeps the alignment of all nodes close to the leaves as specified.
    - TIP_ROOTS_AND_LEAVES_OVER - similar to the mode TIP_OVER. The algorithm tries to optimize the layout to automatically fit best to the specified aspect ratio. This slow heuristic tries to tip over beginning with the roots and with the leaves, and then chooses the best layout. It checks the alignment mode TIP_OVER_EAST, but not TIP_OVER_BOTH_SIDES or other variants. It keeps the alignment of all nodes in the middle between roots and leaves as specified.
    - RADIAL - the root node is in the center, the links flow radially away from the center, and the nodes are placed in circular layers around the root node according to the level alignment. Tip-over alignment and orthogonal link styles are not possible. Clipped connector pins are used as the connector style. If an aspect ratio is specified, the layers are ellipses around the center.
    - ALTERNATING_RADIAL - this is the same as mode RADIAL, with the exception that children of the same node are placed alternating in different circular layers when this results in a smaller radius and better usage of the space. Tip-over alignment and orthogonal link styles are not possible. Clipped connector pins are used as the connector style. If an aspect ratio is specified, the layers are ellipses around the center.
    - BALLOON - the root node is in the center and the subtrees are arranged as balloon circles around the root. It is very similar to the mode RADIAL, however each subtree froms its own balloon recursively. If an aspect ratio is specified, the balloons are ellipses instead of circles. Tip-over alignment and orthogonal link styles are not possible. Clipped connector pins are used as the connector style. The recursive leaf layout mode is not supported in combination with the balloon mode.
    The default value is FREE.
    
    Note that the tip-over layout modes work best if the node sizes are respected during layout.
    Since:
    
    JViews 3.5
    
    See Also:
    
    getLayoutMode(), setFlowDirection(int), setLevelAlignment(int), setConnectorStyle(int), setGlobalLinkStyle(int), setLinkStyle(Object, int), setGlobalAlignment(int), setAlignment(Object, int), setAspectRatio(double), setAspectRatio(IlvManagerView), setAspectRatio(IlvRect), setRespectNodeSizes(boolean), setRecursiveLeafLayoutMode(boolean)
  - getLayoutMode
```
public final int getLayoutMode()
```
    Returns the current layout mode.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int)
  - setBalloonAngleSpacing
```
public final void setBalloonAngleSpacing(int angleSpacing)
```
    Sets the current angle spacing for balloon layout mode. This setting has only an effect when the layout mode is BALLOON. Valid values are:
    - REGULAR - the available angle range at a node is evenly split so that each subtrees balloon at the node can occupy the same angle.
    - FAST_PROPORTIONAL - the available angle range at a node is proportonally split so that larger subtrees balloons at the node can occupy larger angles. The algorithm uses a fast heuristic to calculate the angle ranges. This heuristic is not very precise.
    - PROPORTIONAL - the available angle range at a node is proportonally split so that larger subtrees balloons at the node can occupy larger angles. The algorithm uses a slower heuristic to calculate the angle ranges. This heuristic is more precise than the fast heuristic.
    The default value is PROPORTIONAL.
    Since:
    
    JViews 8.7
    
    See Also:
    
    getBalloonAngleSpacing(), setLayoutMode(int)
  - getBalloonAngleSpacing
```
public final int getBalloonAngleSpacing()
```
    Returns the current angle spacing for balloon layout mode.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonAngleSpacing(int), setLayoutMode(int)
  - setBalloonRadiusMode
```
public final void setBalloonRadiusMode(int radiusMode)
```
    Sets the current radius mode for balloon layout mode. This setting has only an effect when the layout mode is BALLOON. Valid values are:
    - VARIABLE_RADIUS - the radius of different child balloons at the same parent node can vary.
    - OPTIMIZED_VARIABLE_RADIUS - the radius of different child balloons at the same parent node can vary. An additional optimization heuristic reduces the radius. This has the advantage of smaller space requirements but looses symmetries in the diagram.
    - UNIFORM_LEAVES_RADIUS - the radiuses of all leaves that are children of the same node are uniform. The radius of balloons that contain more than one node can still vary. Use this mode if symmetries of the layout are important.
    - OPTIMIZED_UNIFORM_LEAVES_RADIUS - the radiuses of all leaves that are children of the same node are uniform. The radius of balloons that contain more than one node can still vary. An additional optimization heuristic reduces the radius. This has the advantage of smaller space requirements but looses symmetries in the diagram.
    - UNIFORM_RADIUS - the radiuses of all subtree balloons that are children of the same node are uniform. This mode requires the most area but also shows the most symmetries in the layout.
    The default value is OPTIMIZED_UNIFORM_LEAVES_RADIUS.
    Since:
    
    JViews 8.7
    
    See Also:
    
    getBalloonRadiusMode(), setLayoutMode(int)
  - getBalloonRadiusMode
```
public final int getBalloonRadiusMode()
```
    Returns the radius mode for balloon layout mode.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRadiusMode(int), setLayoutMode(int)
  - setBalloonStartAngle
```
public final void setBalloonStartAngle(int angle)
```
    Sets the start angle of the layout in balloon mode. The angle must be between 0 and 360 degrees.
    The default value is 0.
    
    The angle orientation is clockwise for flow direction left and top and counter clockwise for flow direction right and bottom. The start angle 0 is always towards the right.
    
    This is an expert option. It has no effect in layout modes other than balloon.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getBalloonStartAngle(), setLayoutMode(int)
  - getBalloonStartAngle
```
public final int getBalloonStartAngle()
```
    Returns the start angle of the layout in balloon mode.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonStartAngle(int)
  - setBalloonRootChildrenAngle
```
public final void setBalloonRootChildrenAngle(int angle)
```
    Sets the maximum angle for children of the root node in balloon mode. This is the maximum angle between the two rays from the parent to its two outermost children. If the angle is 360 degree, outermost children do not really esist as the children cover the entire circle around the root. The angle must be between 1 and 360 degrees.
    The default value is 360.
    
    This is an expert option. It has no effect in layout modes other than balloon.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getBalloonRootChildrenAngle(), setLayoutMode(int)
  - getBalloonRootChildrenAngle
```
public final int getBalloonRootChildrenAngle()
```
    Returns the maximum angle for children of the root node in balloon mode.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonRootChildrenAngle(int)
  - setBalloonInnerChildrenAngle
```
public final void setBalloonInnerChildrenAngle(int angle)
```
    Sets the maximum angle for children of inner nodes in balloon mode. This is the maximum angle between the two rays from the parent to its two outermost children. If the angle is 360 degree, outermost children do not really esist as the children cover the entire circle around the node. The angle must be between 1 and 360 degrees.
    The default value is 360.
    
    This is an expert option. It has no effect in layout modes other than balloon.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getBalloonInnerChildrenAngle(), setLayoutMode(int)
  - getBalloonInnerChildrenAngle
```
public final int getBalloonInnerChildrenAngle()
```
    Returns the maximum angle for children of inner nodes in balloon mode.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonInnerChildrenAngle(int)
  - setBalloonLeafChildrenAngle
```
public final void setBalloonLeafChildrenAngle(int angle)
```
    Sets the maximum angle for children of nodes that have only leaves as children in balloon mode. Basically, it is the maximum angle for the leaf balloons. This is the maximum angle between the two rays from the parent to its two outermost children. If the angle is 360 degree, outermost children do not really esist as the children cover the entire circle around the node. The angle must be between 1 and 360 degrees.
    The default value is 360.
    
    This is an expert option. It has no effect in layout modes other than balloon.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getBalloonLeafChildrenAngle(), setLayoutMode(int)
  - getBalloonLeafChildrenAngle
```
public final int getBalloonLeafChildrenAngle()
```
    Returns the maximum angle for children of nodes that have only leaves as children in balloon mode. Basically, it is the maximum angle for the leaf balloons.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setBalloonLeafChildrenAngle(int)
  - setIncrementalMode
```
public final void setIncrementalMode(boolean enable)
```
    Sets the incremental mode.
    If the incremental mode is enabled, the algorithm tries to preserve the relative order of the children on incremental changes, unless a node comparator is specified. The logical order of children of nodes in the tree is calculated from their coordinates. In this case, the layout is stable when incremental changes are made. If nodes are added or removed after a layout, the next layout uses a heuristic to try to adjust the layout only minimally and to avoid major structural reorganization.
    
    If the incremental mode is disabled, the algorithm calculates the logical order of children of nodes in the tree by using the order in which nodes are returned by IlvGraphModel.getNodes().
    
    If a node comparator is specified, the algorithm calculate the logical order of children of nodes in the tree from the node comparator, independent from whether the incremental mode is enabled or disabled.
    
    The incremental mode is enabled by default.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isIncrementalMode(), setNodeComparator(Comparator)
  - isIncrementalMode
```
public final boolean isIncrementalMode()
```
    Returns true if the incremental mode is enabled.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalMode(boolean)
  - setNodeComparator
```
public final void setNodeComparator(Comparator comparator)
```
    Sets the comparator used for sorting the nodes. If the value null is passed, no comparator is used. If a node comparator is specified, the algorithm calculates the logical order of children of nodes in the tree by using this comparator.
    The default value is null (no comparator).
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getNodeComparator()
  - getNodeComparator
```
public Comparator getNodeComparator()
```
    Returns the comparator used for sorting the nodes.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setNodeComparator(java.util.Comparator)
  - setAllLevelsAlternating
```
public final void setAllLevelsAlternating(boolean enable)
```
    Sets whether at all levels, nodes are forced into alternating circular layers.
    This option has only an effect in layout mode ALTERNATING_RADIAL. Alternating placement means that the nodes of one level are placed alternating in several (normally 2) circular layers. Nonalternating placement means that the nodes of one level are placed in one circular layer. Normally, the layout analyses which levels must use the alternating placement in order to optimize space. If the alternating placement of a level does not improve the space usage, the nonalternating placement is used for the level even in alternating radial layout mode.
    
    This option allows to change this behavior: if the option is enabled, all levels use the alternating placement even if the alternating placement uses more space than the nonalternating placement. The option is ignored if the number of alternating circles is set to 0, because in that more, the number of alternating circles is automatically determined from the space usage.
    
    The option is disabled by default.
    
    Since:
    
    JViews 6.0
    
    See Also:
    
    isAllLevelsAlternating(), setNumberOfAlternatingCircles(int), setLayoutMode(int)
  - isAllLevelsAlternating
```
public final boolean isAllLevelsAlternating()
```
    Returns true if at all levels, nodes are forced into alternating circular layers.
    
    Since:
    
    JViews 6.0
    
    See Also:
    
    setAllLevelsAlternating(boolean)
  - setNumberOfAlternatingCircles
```
public final void setNumberOfAlternatingCircles(int numCircles)
```
    Sets the number of alternating circles.
    This option has only an effect in layout mode ALTERNATING_RADIAL. Alternating placement means that the nodes of one level are placed alternating in several circular layers. By default, it uses 2 circular layers for the alternating placement. Nonalternating placement means that the nodes of one level are placed in one circular layer.
    
    This option allows to define how many alternating layers are maximally used. You cannot have more layers than nodes in the level, hence it is only the maximum number of layers. Furthermore, the layout analyses which levels must use the alternating placement in order to optimize space, unless the option isAllLevelsAlternating() returns true.
    
    If you set the number to a positive value and isAllLevelsAlternating() returns true, each level has exactly that many circular layers, unless the level has not sufficient nodes. If you set the number to a positive value and isAllLevelsAlternating() returns false, each level has either exactly that many circular layers or one circular layer, depending on which version uses the space better. If you set the number to 0, a heuristic tries to determine for each level how many circular layers are needed in order to optimize the space. In this case, different levels can have different number of circular layers, and the value of isAllLevelsAlternating() is ignored.
    
    Note that the layout may have link crossings if a huge number of alternating circles per level is used.
    
    The default value is 2.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getNumberOfAlternatingCircles(), setLayoutMode(int)
  - getNumberOfAlternatingCircles
```
public final int getNumberOfAlternatingCircles()
```
    Returns the number of alternating circles. This option has only an effect in layout mode ALTERNATING_RADIAL.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setNumberOfAlternatingCircles(int)
  - setRespectNodeSizes
```
public void setRespectNodeSizes(boolean respect)
```
    Sets whether the algorithm must try to respect the size of the nodes. If the argument is true, the spacing parameters are interpreted as the minimum distance between the node borders. If the argument is false, the spacing parameters are interpreted as the minimum distance between the node centers.
    If respecting node sizes is disabled, the level alignment option has no effect.
    
    This is an expert option. The default is true. It makes sense to switch this option off only if all nodes already have approximately the same size and the spacing parameters are larger than the largest node. If the option is switched off, large nodes may otherwise overlap. In particular, it is recommended keeping the option enabled if orthogonal links are used.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setLevelAlignment(int), isRespectNodeSizes()
  - isRespectNodeSizes
```
public boolean isRespectNodeSizes()
```
    Returns true if the algorithm tries to respect the size of the nodes, and false otherwise.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setRespectNodeSizes(boolean)
  - setLevelAlignment
```
public final void setLevelAlignment(int alignment)
```
    Sets the alignment within the levels. Valid values are:
    - CENTER
    - NORTH
    - SOUTH
    This feature sets the alignment of the nodes within each level. It can be used in layout modes LEVEL, RADIAL, and ALTERNATING_RADIAL. It has an effect only if the respect node sizes option is enabled.
    
    If the nodes are center-justified, all nodes of the same level are placed with their centers along a line. Otherwise, all nodes of the same level are placed with the specified border justified to a line. For instance, if the link flow direction is to the right, the alignment NORTH means that the nodes are justified to the left and the alignment SOUTH means that the nodes are justified to the right.
    
    In the radial layout modes, the alignment NORTH means that the nodes are aligned along a circle with the border that is closer to the root, and the alignment SOUTH means that the nodes are aligned along a circle with the border that is farther away from the root.
    
    The default value is CENTER.
    Since:
    
    JViews 3.5
    
    See Also:
    
    getLevelAlignment(), setLayoutMode(int), setFlowDirection(int), setRespectNodeSizes(boolean)
  - getLevelAlignment
```
public final int getLevelAlignment()
```
    Returns the current alignment within the levels.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLevelAlignment(int)
  - setGlobalAlignment
```
public final void setGlobalAlignment(int alignment)
```
    Sets the global alignment option. This option has no effect in balloon layout mode. Valid values are:
    - CENTER - a parent is centered above its child nodes, taking the center of the child nodes into account.
    - BORDER_CENTER - a parent is centered above its child nodes, taking the border of the child nodes into account. This differs from the alignment CENTER if the Respect node sizes option is enabled.
    - EAST - a parent is aligned to the border of its easternmost child node.
    - WEST - a parent is aligned to the border of its westernmost child node.
    - TIP_OVER_EAST - a parent is outside the border of the child nodes, and the child nodes are placed sequentially instead of in parallel. The child nodes are on the east side of the parent. This alignment option is not possible in the radial or level layout modes.
    - TIP_OVER_WEST - a parent is outside the border of the child nodes, and the child nodes are placed sequentially instead of in parallel. The child nodes are on the west side of the parent. This alignment option is not possible in the radial or level layout modes.
    - TIP_OVER_EAST_WEST - similar to TIP_OVER_EAST or TIP_OVER_WEST, but the child nodes are arranged on both sides of the link segment that starts at the parent node. The first child node is placed on the east side. Further child nodes are placed on the east or west side, so that the space used on both sides is roughly the same, that is, the subtrees on the east side have roughly the same sum of heights as the subtrees on the west side. This alignment option is not possible in the radial or level layout modes.
    - TIP_OVER_BOTH_SIDES - similar to TIP_OVER_EAST or TIP_OVER_WEST, but the child nodes are arranged in pairs on both sides of the link segment that starts at the parent node. Unlike TIP_OVER_EAST_WEST, this style does not try to optimize the space used on both sides but always puts the odd-numbered child nodes to the west and the even-numbered child nodes to the east. The pairs of child nodes, one on the east side and one on the west side, are aligned with one another. This alignment option is not possible in the radial or level layout modes.
    - MIXED - each node can have a different alignment option. The alignment of each individual node can be set by the method setAlignment(Object, int) so that different alignments can occur in the same graph.
    The default value is CENTER.
    Since:
    
    JViews 3.5
    
    See Also:
    
    getGlobalAlignment(), setLayoutMode(int), setAlignment(Object, int), setRespectNodeSizes(boolean)
  - getGlobalAlignment
```
public final int getGlobalAlignment()
```
    Returns the global alignment option.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalAlignment(int)
  - setSiblingOffset
```
public final void setSiblingOffset(double offset)
```
    Sets the minimum offset between siblings, that is, between nodes that have the same parent in the tree structure.
    If the flow direction is towards the top or bottom and the layout mode is not radial, this is a horizontal offset. If the flow direction is towards the left or right and the layout mode is not radial, this is a vertical offset. If the layout mode is radial, this is an offset tangential to the circles or ellipses.
    
    This offset has no effect in balloon layout mode. Use the branch offset to control the spacing between all nodes in balloon layout mode.
    
    If the respect node sizes option is enabled, this is the minimum offset between node borders; otherwise, it is the minimum offset between node centers.
    
    The default value is 40.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getSiblingOffset(), setFlowDirection(int), setLayoutMode(int), setRespectNodeSizes(boolean), setBranchOffset(double)
  - getSiblingOffset
```
public final double getSiblingOffset()
```
    Returns the minimum offset between siblings.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setSiblingOffset(double)
  - setParentChildOffset
```
public final void setParentChildOffset(double offset)
```
    Sets the minimum offset between a parent and its children.
    If the flow direction is towards the top or bottom and the layout mode is not radial or balloon, this is a vertical offset. If the flow direction is towards the left or right and the layout mode is not radial or balloon, this is a horizontal offset. If the layout mode is radial or balloon, this is an offset radial to the circle or ellipses. In balloon mode, it corresponds to the minimal radius of the balloon.
    
    If the respect node sizes option is enabled, this is the minimum offset between node borders; otherwise, it is the minimum offset between node centers.
    
    The default value is 40.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getParentChildOffset(), setFlowDirection(int), setLayoutMode(int), setRespectNodeSizes(boolean)
  - getParentChildOffset
```
public final double getParentChildOffset()
```
    Returns the minimum offset between a parent and its children.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setParentChildOffset(double)
  - setBranchOffset
```
public final void setBranchOffset(double offset)
```
    Sets the minimum offset between neighbor nodes that belong to different branches in the tree. This is the offset between neighbor nodes that are not siblings. The offset is in the opposite direction of the link flow.
    If the flow direction is towards the top or bottom and the layout mode is not radial or balloon, this is a horizontal offset. If the flow direction is towards the left or right and the layout mode is not radial or balloon, this is a vertical offset. If the layout mode is radial, this is an offset tangential to the circles or ellipses.
    
    If the layout mode is balloon, this is the minimal offset between nodes in all directions. The balloon mode does not distinguish between siblings and branches, hence the branch offset is used for all nodes.
    
    If the respect node sizes option is enabled, this is the minimum offset between node borders; otherwise, it is the minimum offset between node centers.
    
    The default value is 40.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getBranchOffset(), setFlowDirection(int), setLayoutMode(int), setRespectNodeSizes(boolean)
  - getBranchOffset
```
public final double getBranchOffset()
```
    Returns the minimum offset between neighbor nodes that belong to different branches in the tree. This is the offset between neighbor nodes that are not siblings. The offset is in the opposite direction of the link flow.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFlowDirection(int), setBranchOffset(double)
  - setTipOverBranchOffset
```
public final void setTipOverBranchOffset(double offset)
```
    Sets the minimum offset in the flow direction between neighbor nodes that belong to different branches in the tree. This offset is used to separate the branches if their common parent node has tip-over alignment. It has no effect if the layout mode is radial or if no tip-over alignment occurs.
    If the flow direction is towards the top or bottom, this is a vertical offset. If the flow direction is towards the left or right, this is a horizontal offset.
    
    If the respect node sizes option is enabled, this is the minimum offset between node borders; otherwise, it is the minimum offset between node centers.
    
    The default value is 40.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getTipOverBranchOffset(), setFlowDirection(int), setLayoutMode(int), setRespectNodeSizes(boolean)
  - getTipOverBranchOffset
```
public final double getTipOverBranchOffset()
```
    Returns the minimum offset in the flow direction between neighbor nodes that belong to different branches in the tree. This offset is used to separate the branches if their common parent node has tip-over alignment.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFlowDirection(int), setTipOverBranchOffset(double)
  - setAssociateOffset
```
public final void setAssociateOffset(double offset)
```
    Sets the minimum offset between associates and the orthogonal link segment starting at the parent. This offset is used if a parent has associate nodes. This method has no effect if the layout mode is radial or if no associates occur.
    If the flow direction is toward the top or bottom, the orthogonal link segment starting at the parent is vertical, and the associates are placed left or right of this link segment. Hence it is a horizontal offset. If the flow direction is toward the left or right, the orthogonal link segment starting at the parent is horizontal, and the associates are placed above or below this link segment. Hence it is a vertical offset.
    
    If the Respect node sizes option is enabled, this is the minimum offset between node borders; otherwise, it is the minimum offset between node centers.
    
    The default value is 30.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getAssociateOffset(), addAssociate(Object, Object), setFlowDirection(int), setLayoutMode(int), setRespectNodeSizes(boolean)
  - getAssociateOffset
```
public final double getAssociateOffset()
```
    Returns the minimum offset between associates and the orthogonal link segment starting at the parent. This offset is used if a parent has associate nodes.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setAssociateOffset(double), addAssociate(Object, Object)
  - setParentChildAssociateOffset
```
public final void setParentChildAssociateOffset(double offset)
```
    Sets the minimum offset between the parent and the first associate. This offset is used if a parent has associate nodes. This method has no effect if the layout mode is radial or if no associates occur.
    If the flow direction is toward the top or bottom, the orthogonal link segment starting at the parent is vertical, and the associates are placed left or right of this link segment. In this case, it is a vertical offset between parent and child. If the flow direction is toward the left or right, the orthogonal link segment starting at the parent is horizontal, and the associates are placed above or below this link segment. In this case, it is a horizontal offset between parent and child.
    
    If the Respect node sizes option is enabled, this is the minimum offset between node borders; otherwise, it is the minimum offset between node centers.
    
    The default value is 30.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getParentChildAssociateOffset(), addAssociate(Object, Object), setFlowDirection(int), setLayoutMode(int), setRespectNodeSizes(boolean)
  - getParentChildAssociateOffset
```
public final double getParentChildAssociateOffset()
```
    Returns the minimum offset between the parent and the first associate. This offset is used if a parent has associate nodes.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setParentChildAssociateOffset(double), addAssociate(Object, Object)
  - setAspectRatio
```
public final void setAspectRatio(double aspectRatio)
```
    Sets the aspect ratio for the layout. This is the ratio width / height of the desired layout region.
    The effect of the aspect ratio depends on the layout mode:
    - In layout modes RADIAL and ALTERNATING_RADIAL, the nodes are placed in circular layers if the aspect ratio is 1. Otherwise, they are placed in elliptical layers.
    - In layout modes BALLOON, the nodes are placed in circular balloons if the aspect ratio is 1. Otherwise, they are placed in elliptical ballons.
    - In layout modes TIP_OVER, TIP_ROOTS_OVER, TIP_LEAVES_OVER, and TIP_ROOTS_AND_LEAVES_OVER, the nodes are placed as in in free mode, but local tip-over alignments are automatically added to better fit the layout to the aspect ratio.
    - The aspect ratio has no effect in other layout modes.
    Since:
    
    JViews 3.5
    
    See Also:
    
    getAspectRatio(), setLayoutMode(int), setAlignment(Object, int)
  - setAspectRatio
```
public final void setAspectRatio(IlvRect rect)
```
    Sets the aspect ratio for the layout from a given rectangle. This can be useful if the graph contains just one single tree and should be fit into the input rectangle.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setAspectRatio(double aspectRatio)
  - setAspectRatio
```
public final void setAspectRatio(IlvManagerView view)
```
    Sets the aspect ratio for the layout from a given view. This can be useful if the graph contains just one single tree and should be fit into the input view.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setAspectRatio(double aspectRatio)
  - getAspectRatio
```
public final double getAspectRatio()
```
    Returns the aspect ratio specified for the layout. This is the ratio width / height of the desired layout region.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setAspectRatio(double aspectRatio)
  - setOverlapPercentage
```
public final void setOverlapPercentage(double percentage)
```
    Sets the percentage for which a node is considered smaller in the flow direction. This allows nodes to be placed closer together. However, in layout modes FREE, TIP_OVER, TIP_ROOTS_OVER, TIP_LEAVES_OVER, and TIP_ROOTS_AND_LEAVES_OVER, outgoing links of a node may, in rare cases, cross the neighbor leaf nodes if the overlap percentage is high. To avoid this, set the parameter to 0%.
    The default value is 30%, which is a good compromise for many graphs between wasting space and the risk of having links cross nodes.
    
    This is an expert option. In all normal cases, it is not necessary to change the option. It is recommended choosing an orthogonal fork percentage that is always larger than the overlap percentage to obtain a good layout.
    
    This option has no effect if the respect node sizes option is disabled.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLayoutMode(int), setOrthForkPercentage(double), setRespectNodeSizes(boolean)
  - getOverlapPercentage
```
public final double getOverlapPercentage()
```
    Returns the percentage for which a node is considered smaller in the flow direction.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setOverlapPercentage(double)
  - setMaxChildrenAngle
```
public final void setMaxChildrenAngle(int angle)
```
    Sets the maximum angle for children that are placed in radial mode. This is the maximum angle between the two rays from the parent to its two outermost children. The angle must be between 0 and 360 degrees. The angle 0 means that the angle is unspecified,
    The default value is 0.
    
    In radial mode, children of a single node may cover nearly completely one circular layer. This sometime appears to be unbalanced, in particular because the links from the node to its outermost children are likely to cross other nodes. To avoid this effect, a maximum angle can be specified so that the children are placed more in the same direction and are not spread too widely around the parent. This angular restriction is applied to all children except the children of the root node. As a side effect, specifying a small maximum children angle enlarges the radius of the circles.
    
    It is recommended choosing a value between 30 and 180 degrees for good results. The algorithm uses a heuristic that has precision deviations below 30 degrees and above 180 degrees. If an aspect ratio is specified, the layout algorithm uses ellipses instead of circles. In this case, precision deviations may occur as well.
    
    This is an expert option. It has no effect in layout modes other than radial.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getMaxChildrenAngle(), setLayoutMode(int), setAspectRatio(double), setAspectRatio(IlvManagerView), setAspectRatio(IlvRect)
  - getMaxChildrenAngle
```
public final int getMaxChildrenAngle()
```
    Returns the maximum angle for children that are placed in radial mode.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setMaxChildrenAngle(int)
  - setFirstCircleEvenlySpacing
```
public final void setFirstCircleEvenlySpacing(boolean enable)
```
    Sets whether the nodes on the first circle must be evenly spaced in radial mode.
    By default, all nodes are placed as close as possible according to the offset parameters. In radial mode, this may cause the first circle to be only partially filled (that is, all nodes are placed close together at one part of the circle and there is a larger gap in another part of the circle).
    
    To avoid this effect, you can enable the evenly spacing of the first circle. In this case, the children of the root node are placed such that their centers are approximately evenly spaced on the first circle, filling the entire circle. This may, however, cause the final result to waste much more space on the other circles.
    
    It is disabled by default.
    
    This is an expert option. It has no effect in layout modes other than radial. If there is east-west neighboring of the nodes in the first circle, these neighbors will not be equally spaced.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isFirstCircleEvenlySpacing(), setLayoutMode(int), setSiblingOffset(double), setBranchOffset(double), setParentChildOffset(double), setEastWestNeighboring(Object, Object)
  - isFirstCircleEvenlySpacing
```
public final boolean isFirstCircleEvenlySpacing()
```
    Returns true if the nodes on the first circle must be evenly spaced in radial mode.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setFirstCircleEvenlySpacing(boolean)
  - setOrthForkPercentage
```
public final void setOrthForkPercentage(double percentage)
```
    Sets the percentage of the parent-child offset that determines the location where the orthogonal link routing places the bends in order to fork the routing towards the children. This has an effect only if the orthogonal link style is chosen.
    The default value is 45%.
    
    This is an expert option. In all normal cases, it is not necessary to change the option. It is recommended choosing an orthogonal fork percentage that is always larger than the overlap percentage to obtain a good layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), setParentChildOffset(double), setOverlapPercentage(double)
  - getOrthForkPercentage
```
public final double getOrthForkPercentage()
```
    Returns the percentage of the parent-child offset that determines the location where the orthogonal link routing places the bends in order to fork the routing towards the children.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setOrthForkPercentage(double)
  - setLinkStyle
```
public final void setLinkStyle(Object link,
                               int style)
```
    Sets the style of the shape of an individual link. This link style is used only if the global link style is set to MIXED_STYLE and the link is part of the spanning tree. If the global link style is not MIXED_STYLE, all links of the spanning tree have the style that is specified as the global link style. Links that are not part of the spanning tree have the link style NO_RESHAPE_STYLE.
    Valid values are:
    - ORTHOGONAL_STYLE - the link has an orthogonal shape, that is, a shape consisting of a sequence of orthogonal line segments. This option is not available for the radial layout modes.
    - STRAIGHT_LINE_STYLE - the link has a straight-line shape.
    - NO_RESHAPE_STYLE - no reshape is performed on the link.
    The default value is STRAIGHT_LINE_STYLE.
    
    When the graph attached to the layout is of type IlvGrapher, the effect of the link reshaping depends on the type of the links and the connectors installed at the node. For all link styles, you are recommended to use links of type IlvPolylineLinkImage. For the orthogonal link style, you are additionally recommended to use link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinkTypes and method IlvGraphLayoutUtil.EnsureAppropriateLinkConnectors before layout, or the method IlvGraphLayoutUtil.EnsureAppropriateLinks when the exception is caught, to convert all links to an appropriate type.
    Parameters:
    
    link - The link object.
    
    style - The style of the link shape.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getLinkStyle(Object), setLayoutMode(int), setGlobalLinkStyle(int)
  - getLinkStyle
```
public final int getLinkStyle(Object link)
```
    Returns the style of the shape of an individual link.
    
    Parameters:
    
    link - The individual link.
    
    Returns:
    
    The style of the link shape.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int)
  - setEastWestNeighboring
```
public final void setEastWestNeighboring(Object eastNode,
                                         Object westNode)
```
    Creates an east-west neighboring of two nodes. The westNode is placed as the first neighbor on the same level to the west of the eastNode. This implies, conversely, that the eastNode is the first neighbor on the same level to the east of the westNode.
    For instance, in free layout mode and with the flow direction towards the bottom, the east node is placed as the immediate neighbor to the right of the west node at approximately the same y coordinate. A link between both nodes is routed as a straight horizontal line between both nodes. In radial layout mode, the east node is placed as the immediate neighbor in the same circle as the west node. A link between both nodes is routed tangentially to the node circle as a straight line.
    
    Note that each node can have at most one east neighbor and one west neighbor.
    
    East-west neighboring is possible even though there is no link between both nodes. The layout algorithm considers both nodes as if they were conceptually connected by a link.
    
    Parameters:
    
    eastNode - The east neighbor of the westNode.
    
    westNode - The west neighbor of the eastNode.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getEastNeighbor(Object), getWestNeighbor(Object)
  - setWestEastNeighboring
```
public final void setWestEastNeighboring(Object westNode,
                                         Object eastNode)
```
    Creates an east-west neighboring of two nodes. The westNode is placed as the first neighbor on the same level to the west of the eastNode. This implies, conversely, that the eastNode is the first neighbor on the same level to the east of the westNode.
    This method is identical to setEastWestNeighboring(Object eastNode, Object westNode) with a reversed argument order, and is provided for convenience. Note that, for instance, when the flow direction is towards the bottom, east is to the right of west, and therefore resembles more the argument order of setWestEastNeighboring. When the flow direction is towards the top, east is to the left of west, and therefore resembles more the argument order of setEastWestNeighboring.
    
    Parameters:
    
    westNode - The west neighbor of the eastNode.
    
    eastNode - The east neighbor of the westNode.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getEastNeighbor(Object), getWestNeighbor(Object)
  - getEastNeighbor
```
public final Object getEastNeighbor(Object node)
```
    Returns the specified east neighbor node of the input node, or null if none was specified. It returns only the neighbor node if it was specified by setEastWestNeighboring(java.lang.Object, java.lang.Object) or setWestEastNeighboring(java.lang.Object, java.lang.Object), but not if the neighbor node was only specified by setChildAlignment(java.lang.Object, int).
    
    Parameters:
    
    node - The node object.
    
    Returns:
    
    The specified east neighbor node of the given node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getWestNeighbor(Object), setEastWestNeighboring(Object, Object), setWestEastNeighboring(Object, Object), setChildAlignment(Object, int)
  - getWestNeighbor
```
public final Object getWestNeighbor(Object node)
```
    Returns the specified west neighbor node of the input node, or null if none was specified. It returns only the neighbor node if it was specified by setEastWestNeighboring(java.lang.Object, java.lang.Object) or setWestEastNeighboring(java.lang.Object, java.lang.Object), but not if the neighbor node was only specified by setChildAlignment(java.lang.Object, int).
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The specified west neighbor node of the given node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getEastNeighbor(Object), setEastWestNeighboring(Object, Object), setWestEastNeighboring(Object, Object), setChildAlignment(Object, int)
  - addAssociate
```
public final void addAssociate(Object parentNode,
                               Object associateNode)
```
    Sets one node as associate of another node. Associate nodes are placed as children of the parent node below the parent node. They are arranged in a tip over style. Different to all other children, the alignment of the associates does not obey the alignment option of the parent node. By default, associates are aligned in style TIP_OVER_ASSOCIATE_BOTH_SIDES. It is further possible to specify the child alignment TIP_OVER_ASSOCIATE_EAST and TIP_OVER_ASSOCIATE_WEST for associate nodes.
    Associates can be laid out in free and level mode, but not in radial mode.
    
    Associate nodes are possible even though there is no link between the associate node and its parent node. The layout algorithm considers both nodes as if they were conceptually connected by a link.
    
    For instance, in free layout mode and with the flow direction towards the bottom, the first associate is placed to the left below the parent, the second associate at approximately the same y coordinate to the right below the parent, the third associate to the left below the first one, the forth to the right below the second one and so on. A link between parent and its associate node is always routed orthogonally.
    
    A parent can have many associate nodes, but each associate node can only have one parent.
    
    Parameters:
    
    parentNode - The parent node of the associateNode.
    
    associateNode - The associate node of the parentNode.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setChildAlignment(Object, int), getAssociates(Object), removeAssociate(Object, Object)
  - removeAssociate
```
public final void removeAssociate(Object parentNode,
                                  Object associateNode)
```
    Removes the associate node from its parent node.
    
    Parameters:
    
    parentNode - The parent node of the associateNode.
    
    associateNode - The associate node of the parentNode.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getAssociates(Object), addAssociate(Object, Object)
  - removeAllAssociates
```
public final void removeAllAssociates(Object parentNode)
```
    Removes all the associate nodes from the input parent node.
    
    Parameters:
    
    parentNode - The parent node of the associateNode.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getAssociates(Object), addAssociate(Object, Object)
  - getAssociateParent
```
public final Object getAssociateParent(Object node)
```
    Returns the parent node for which the input node is an associate. Returns null if the node was never added as an associate of a parent.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The parent node for which the given node is an associate or null if the node was never added as an associate of a parent.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getAssociates(Object), addAssociate(Object, Object), removeAssociate(Object, Object)
  - getAssociates
```
public final Enumeration getAssociates(Object parentNode)
```
    Returns all associate nodes of the input parent node. The returned nodes have the input node as associate parent. It returns only the associate nodes specified by addAssociate(java.lang.Object, java.lang.Object), but not the associate nodes that were only specified by setChildAlignment(java.lang.Object, int).
    
    Parameters:
    
    parentNode - The node instance.
    
    Returns:
    
    All associate nodes of the given parent node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getAssociateParent(Object), addAssociate(Object, Object), removeAssociate(Object, Object), setChildAlignment(Object, int)
  - setRoot
```
public final void setRoot(Object node)
```
    Allows you to specify the root(s) of the tree. If more than one connected component exists, it is possible to select a root for each component. If no root is specified, an appropriate node is automatically selected as root. For a directed tree, the canonical root node with degree 0 is selected unless otherwise specified.
    Setting the root node by this method is identical to setting the root preference of this node to 10000.
    
    Parameters:
    
    node - The root of the tree.
    
    Since:
    
    JViews 3.5 This method is no longer synchronized.
    
    See Also:
    
    getCalcRoots(), getSpecRoots(), setRootPreference(Object, int)
  - getSpecRoots
```
public final Enumeration getSpecRoots()
```
    Returns the nodes that were specified as root. Note that this does not necessarily mean that these nodes are selected as real roots, because the specification may have conflicts (for example, each connected component can only have one root, thus specifying two roots for the same connected component causes a conflict). To retrieve the nodes that were really used as roots during the layout, call the method getCalcRoots().
    
    Returns:
    
    The nodes that were specified as root.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getCalcRoots(), isSpecRoot(Object), setRoot(Object), setRootPreference(Object, int)
  - isSpecRoot
```
public final boolean isSpecRoot(Object node)
```
    Returns true if the input node was specified as root. This does not necessarily mean that this node is selected as real root, because the specification may have conflicts (for example, each connected component can only have one root, so specifying two roots for the same connected component causes a conflict). To check whether the node was really used as root during the layout, call the method isCalcRoot(Object).
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    true if the input node was specified as root.
    
    Since:
    
    JViews 6.0
    
    See Also:
    
    getSpecRoots(), isCalcRoot(Object), setRoot(Object), setRootPreference(Object, int)
  - getCalcRoots
```
public final Enumeration getCalcRoots()
```
    Returns the nodes that were used as roots during layout.
    This method can be called after layout. If more than one connected component exists, each component has a root. If no root was specified, the layout algorithm automatically selects an appropriate node. If too many roots were specified, some specified roots will not become calculated roots during layout.
    
    Returns:
    
    The nodes that were used as roots during layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getSpecRoots(), setRoot(Object), setRootPreference(Object, int)
  - isCalcRoot
```
public final boolean isCalcRoot(Object node)
```
    Returns true if the input node was used as root during layout. This method can be called after the layout. If more than one connected component exists, each component has a root. If no root was specified, the layout algorithm automatically selects an appropriate node. If too many roots were specified, some specified roots will not become calculated roots during layout.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    true if the input node was used as root during layout.
    
    Since:
    
    JViews 6.0
    
    See Also:
    
    getCalcRoots(), setRoot(Object), setRootPreference(Object, int)
  - setRootPreference
```
public final void setRootPreference(Object node,
                                    int preference)
```
    Specifies the preference of the node to become root node. The higher the preference, the more likely the node will be selected as root node.
    If a negative value is passed as input, the preference of the node is unspecified. In this case, the algorithm calculates a preference so that for directed trees the canonical root nodes with degree 0 have the highest preference.
    
    Parameters:
    
    node - The node instance.
    
    preference - The preference of the node to become a root node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getCalcRoots(), getSpecRoots(), getRootPreference(Object), setRoot(Object)
  - getRootPreference
```
public final int getRootPreference(Object node)
```
    Returns the specified preference of the node to become root node. The higher the preference, the more likely the node will be selected as root node. If no preference is specified for the node, it returns -1.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The specified preference of the node to become a root.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setRoot(Object), setRootPreference(Object, int)
  - setPosition
```
public final void setPosition(IlvPoint point,
                              boolean isRootPosition)
```
    Sets the position of the layout. This can be used if connected component processing is disabled, or if the graph is fully connected. It has no effect otherwise.
    If no position is specified, the layout algorithm keeps the position of the first root node unchanged.
    
    Parameters:
    
    point - The position.
    
    isRootPosition - If true, it specifies the position of the first root node. This is useful in incremental mode. If false, it specifies the position of the top-left border of the layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getPosition(), setRoot(Object), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean), setIncrementalMode(boolean)
  - setPosition
```
public final void setPosition(IlvPoint point)
```
    Sets the position of the layout. This can be used if connected component processing is disabled, or if the graph is fully connected. It has no effect otherwise.
    The meaning of the position depends on the flag isRootPosition(). If the flag is true, it specifies the position of the first root node. This is useful in incremental mode. If the flag is false, it specifies the position of the top-left border of the layout.
    
    If no position is specified, the layout algorithm keeps the position of the first root node unchanged.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setPosition(IlvPoint, boolean), setRootPosition(boolean), getPosition(), setRoot(Object), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean), setIncrementalMode(boolean)
  - getPosition
```
public final IlvPoint getPosition()
```
    Returns the specified position of the layout. This can be used if connected component processing is disabled, or if the graph is fully connected. It has no effect otherwise.
    
    Returns:
    
    The specified position of the layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setPosition(IlvPoint), setPosition(IlvPoint, boolean), isRootPosition(), setRoot(Object), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean)
  - setRootPosition
```
public final void setRootPosition(boolean isRootPosition)
```
    Sets the meaning of the specified position. The specified position is the one that can be obtained from getPosition(). If passed true the specified position means the position of the root node. Otherwise, it means the position of the top-left border of the layout. This can be used if connected component processing is disabled, or if the graph is fully connected. It has no effect otherwise.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setPosition(IlvPoint, boolean), setPosition(IlvPoint), isRootPosition(), setRoot(Object)
  - isRootPosition
```
public final boolean isRootPosition()
```
    Returns true if the specified position means the position of the root node. Otherwise, it means the position of the top-left border of the layout. This can be used if connected component processing is disabled, or if the graph is fully connected. It has no effect otherwise.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setPosition(IlvPoint), setPosition(IlvPoint, boolean), getPosition(), setRoot(Object)
  - setInvisibleRootUsed
```
public final void setInvisibleRootUsed(boolean flag)
```
    Sets whether an invisible root is used to combine components that are disconnected from each other. The roots that are specified by setRoot(Object) or setRootPreference(Object, int) are the roots of each individual component. If an invisible root is used, all roots of each individual component are added as children to an invisible dummy node and the layout is performed on the resulting connected graph. By doing this, the components are arranged in the same global structure. In particular, this is useful for the radial layout modes to fit all components into the same global circular layer structure instead of generating an individual circular layer structure for each component.
    Note that the layout is no longer stable on incremental changes if an invisible root is used. The layout heuristic cannot preserve the relative order of the components in this case. This means that the order of the components may change in subsequent layouts, and hence the next layout may look very different from the previous layout.
    
    The default value is false.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    isInvisibleRootUsed(), setRoot(Object), setRootPreference(Object, int), setLayoutMode(int), setIncrementalMode(boolean)
  - isInvisibleRootUsed
```
public final boolean isInvisibleRootUsed()
```
    Returns true if an invisible root is used to combine components that are disconnected from each other.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setInvisibleRootUsed(boolean)
  - setIntergraphConnectivityMode
```
public final void setIntergraphConnectivityMode(boolean flag)
```
    Sets whether the intergraph link connectivity is considered for the partitioning of the layout into subtrees. This affects nodes that represent subgraphs and that are only connected to other nodes by intergraph links (i.e. there are no normal intragraph links between the node and other nodes). If the option is disabled, these nodes are considered disconnected and are placed like disconnected nodes. If the option is enabled, the nodes are considered connected and arranged inside the tree structure (for instance as parent and child).
    Note that this option has no effect if the generic disconnected node placement is enabled (see IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean)).
    
    Even if this option is enabled, the Tree Layout algorithm does not route intergraph links. They should be routed by applying a Link Layout after the Tree Layout.
    
    Parameters:
    
    flag - true to set intergraph connectivity mode, or false to disable the mode.
    
    Since:
    
    JViews 8.5
  - isIntergraphConnectivityMode
```
public final boolean isIntergraphConnectivityMode()
```
    Returns true if the intergraph link connectivity is considered for the partitioning of the layout into subtrees.
    
    Since:
    
    JViews 8.5
  - setRecursiveLeafLayoutMode
```
public final void setRecursiveLeafLayoutMode(boolean flag)
```
    Sets whether the recursive layout of nested subgraphs in leaves of the tree is enabled. Normally, the tree layout can only handle flat graphs. The recursive leaf layout mode is a mode so that the tree layout handles nested graphs. This works if the leaves of the tree are subgraphs, but not if the inner nodes of the tree are subgraphs. If this option is enabled, the Tree Layout algorithm routes intergraph links that are part of the spanning tree after flattening the leaf subgraphs. It does not route all intergraph links.
    The layout is suited if the nodes and links have no labels that need to be placed around the nodes and links. (Labels in the center of nodes don't cause a problem). The layout may produce suboptimal results if the nodes or links of subgraphs have very long labels that must be placed by a label layout. Since the label layout can only run after the tree layout, it will influence the bounding boxes of the subgraphs after they are already placed, which is the cause for the suboptimal result.
    
    Parameters:
    
    flag - true to enable the recursive leaf layout mode, or false to disable the mode.
    
    Since:
    
    JViews 8.5
  - isRecursiveLeafLayoutMode
```
public final boolean isRecursiveLeafLayoutMode()
```
    Returns true if the recursive layout of nested subgraphs in leaves of the tree is enabled.
    
    Since:
    
    JViews 8.5
  - setRecursiveLayoutFromAncestorAllowed
```
public final void setRecursiveLayoutFromAncestorAllowed(boolean flag)
```
    Sets whether the layout instance of the ancestor graph is in principle allowed to treat this subgraph in a recursive layout. Whether the layout of the ancestor graph can handle the subgraph attached to this layout instance depends on the parameter settings of the ancestor layout. The layout instance of the ancestor graph must also be a tree layout and must have the recursive leaf layout mode enabled, otherwise the ancestor layout does not try to handle this subgraph.
    This option is enabled by default.
    
    Parameters:
    
    flag - true to allow the ancestor layout to treat the subgraph attached to this layout, or false otherwise.
    
    Since:
    
    JViews 8.5
  - isRecursiveLayoutFromAncestorAllowed
```
public final boolean isRecursiveLayoutFromAncestorAllowed()
```
    Returns true if the layout instance of an ancestor graph is in principle allowed to treat this subgraph in a recursive layout. Whether the layout of the ancestor graph can handle the subgraph attached to this layout instance depends on the parameter settings of the ancestor layout.
    
    Since:
    
    JViews 8.5
  - setCategorizingLinks
```
public final void setCategorizingLinks(boolean flag)
```
    Sets whether the layout algorithm stores the categorization of links into forward, backward, and non-tree links. If true, the next run of the layout algorithm makes the link categorization available through the methods getCalcForwardTreeLinks(), getCalcBackwardTreeLinks(), and getCalcNonTreeLinks(). If false, the link categorization is not made available. This saves memory and is faster. In this case, the methods getCalcForwardTreeLinks(), getCalcBackwardTreeLinks(), and getCalcNonTreeLinks() will return empty enumerations.
    Note that only normal links can be categorized. Intergraph links are never categorized, even if setIntergraphConnectivityMode(boolean) is set to true.
    
    The default value is false.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    isCategorizingLinks()
  - isCategorizingLinks
```
public final boolean isCategorizingLinks()
```
    Returns true if the layout algorithm stores the categorization of links into forward, backward, and non-tree links.
    Note that a run of the layout is necessary to make the categorization available. Even if this method returns true, the methods getCalcForwardTreeLinks(), getCalcBackwardTreeLinks(), and getCalcNonTreeLinks() return empty enumerations if there was no run of the layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setCategorizingLinks(boolean)
  - setCategorizingLinksWithoutLayout
```
public final void setCategorizingLinksWithoutLayout(boolean flag)
```
    Sets whether the layout algorithm does not really perform a full layout. It only calculates a spanning tree but does not move nodes or links. If categorizing links is additionally enabled, it stores the calculated root nodes and the categorization of links into forward, backward, and non-tree links. Since intergraph links are never categorized, this works only in nonrecursive mode.
    Note that a run of the layout is necessary to make the categorization available. Otherwise, the methods getCalcForwardTreeLinks(), getCalcBackwardTreeLinks(), and getCalcNonTreeLinks() return empty enumerations if there was no run of the layout.
    
    The default value is false.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    isCategorizingLinksWithoutLayout(), setCategorizingLinks(boolean), setRecursiveLeafLayoutMode(boolean)
  - isCategorizingLinksWithoutLayout
```
public final boolean isCategorizingLinksWithoutLayout()
```
    Returns true if the layout algorithm does not really perform a full layout. It only calculates a spanning tree but does not move nodes or links. If categorizing links is additionally enabled, it stores the calculated root nodes and the categorization of links into forward, backward, and non-tree links. Since intergraph links are never categorized, this works only in nonrecursive mode.
    Note that a run of the layout is necessary to make the categorization available. Otherwise, the methods getCalcForwardTreeLinks(), getCalcBackwardTreeLinks(), and getCalcNonTreeLinks() return empty enumerations if there was no run of the layout.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setCategorizingLinksWithoutLayout(boolean), setCategorizingLinks(boolean), setRecursiveLeafLayoutMode(boolean)
  - getCalcForwardTreeLinks
```
public final Enumeration getCalcForwardTreeLinks()
```
    Returns the forward links that were used as part of the spanning tree during layout. This can be called after layout if the link categorization option was set to true before layout by using the method setCategorizingLinks(boolean).
    The forward tree links have the property that the "from" node is the parent of the "to" node in the tree layout. These links are reshaped by the layout algorithm.
    
    If the graph was not a tree, some links will not be part of the spanning tree that forms the base structure for the layout. If the graph was not a directed tree, some links need to be reversed to form the spanning tree. These links are not part of this enumeration.
    Depending on whether recursive leaf mode is set, the enumeration may or may not contain intergraph links:
    - If recursive leaf mode is switched off, only normal links are categorized. Intergraph links are not categorized as forward tree links, even if setIntergraphConnectivityMode(boolean) is set to true.
    - If recursive leaf mode is switched on, intergraph links that were reshaped by the tree layout are categorized as forward or backward links.
    Returns:
    
    The forward links that were used as part of the spanning tree during layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getCalcBackwardTreeLinks(), getCalcNonTreeLinks(), setRoot(Object), setRecursiveLeafLayoutMode(boolean)
  - getCalcBackwardTreeLinks
```
public final Enumeration getCalcBackwardTreeLinks()
```
    Returns the backward links that were used in the reverse direction as part of the spanning tree during layout. This method can be called after layout if the link categorization option was set to true before the layout by using the method setCategorizingLinks(boolean).
    The backward tree links have the property that the "to" node is the parent of the "from" node in the tree layout. These links are reshaped by the layout algorithm.
    
    If the graph was not a tree, some links will not be part of the spanning tree that forms the base structure for the layout. These links are not part of this enumeration. Also, links that do not need to be reversed but form the spanning tree are not part of this enumeration.
    
    Depending on whether recursive leaf mode is set, the enumeration may contain intergraph links:
    - If recursive leaf mode is switched off, only normal links are categorized. Intergraph links are not categorized as backward tree links, even if setIntergraphConnectivityMode(boolean) is set to true.
    - If recursive leaf mode is switched on, intergraph links that were reshaped by the tree layout are categorized as forward or backward links.
    Returns:
    
    The backward links that were used in the reverse direction as part of the spanning tree during layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getCalcForwardTreeLinks(), getCalcNonTreeLinks(), setRoot(Object)
  - getCalcNonTreeLinks
```
public final Enumeration getCalcNonTreeLinks()
```
    Returns the links that were neither forward nor backward links in the spanning tree during layout. This can be called after the layout if the link categorization option was set to true before the layout by using the method setCategorizingLinks(boolean).
    The non-tree links have the property that neither the "from" node is the parent of the "to" node nor the "to" node is the parent of the "from" node in the tree layout. These links are not reshaped by the layout algorithm.
    
    If the graph was not a tree, some links will not be part of the spanning tree that forms the base structure for the layout. Only these links are part of this enumeration. If necessary, they can be treated by a link routing layout algorithm after the tree layout (for example, by IlvLinkLayout ).
    
    Note that links that are removed by a layout filter, and links that are specified as fixed links or that are adjacent to fixed nodes, are not part of this enumeration even though they are also not part of the spanning tree.
    
    Depending on the recursive leaf mode, it may contain intergraph links. If the recursive leaf mode is switched off, only only normal links are categorized. Intergraph links are not categorized as non-tree links, even if setIntergraphConnectivityMode(boolean) is set to true. However if the recursive leaf mode is switched on, intergraph links that could not get reshaped by the tree layout are categorized as non-tree links.
    
    Returns:
    
    The links that were neither forward nor backward links in the spanning tree during layout.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getCalcForwardTreeLinks(), getCalcBackwardTreeLinks(), setRoot(Object), IlvGrapherAdapter.setFilter(ilog.views.graphlayout.IlvLayoutGraphicFilter), IlvGraphLayout.setPreserveFixedLinks(boolean), IlvGraphLayout.isPreserveFixedLinks()
  - setNonTreeLinksStraight
```
public final void setNonTreeLinksStraight(boolean enable)
```
    Sets whether all non-tree links that don't have the no-reshape link style and that are not fixed and are not incident to fixed nodes are reshaped to be straight. Otherwise, the non-tree links are not changed at all.
    This option is disabled by default. When disabled, the tree layout only routes the links of the spanning tree, but no other link. When enabled, the tree layout iterates over the links obtained by getCalcNonTreeLinks() and makes them straight.
    
    It obeys the link clip interface and the link connection box interface when making the non-tree links straight. The tree layout can only obey the link style and the connector style of the tree links but not of the non-tree links. In particular, it is not able to route non-tree links orthogonally. Only tree-links can be routed orthogonally. Usually it is recommended to apply an additional link layout to the non-tree links if there are any. However, if the non-tree links should just be straight, this option comes in handy since an additional link layout can be omitted in this case.
    
    Since:
    
    JViews 6.5
    
    See Also:
    
    isNonTreeLinksStraight(), getCalcNonTreeLinks(), setGlobalLinkStyle(int), getConnectorStyle(), setLinkStyle(Object, int), IlvGraphLayout.setPreserveFixedLinks(boolean), IlvGraphLayout.isPreserveFixedLinks(), IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface), IlvGraphLayout.setLinkClipInterface(IlvLinkClipInterface)
  - isNonTreeLinksStraight
```
public final boolean isNonTreeLinksStraight()
```
    Returns true if all non-tree links that don't have the no-reshape link style and that are not fixed and are not incident to fixed nodes are reshaped to be straight. Otherwise, the non-tree links are not changed at all.
    
    Since:
    
    JViews 6.5
    
    See Also:
    
    setNonTreeLinksStraight(boolean)
  - setAlignment
```
public final void setAlignment(Object node,
                               int alignment)
```
    Sets the alignment option of an individual node. This alignment option is used only if the global alignment is set to MIXED. Otherwise, all nodes have the alignment that is specified as the global alignment. This option has no effect in balloon layout mode.
    Valid values are:
    - CENTER - the node is centered with respect to the centers of its child nodes.
    - BORDER_CENTER - the node is centered with respect to the border of its child nodes.
    - EAST - the node is aligned to the border of its easternmost child node.
    - WEST - the node is aligned to the border of its westernmost child node.
    - TIP_OVER_EAST - a parent is outside the border of the child nodes, and the child nodes are placed sequentially instead of in parallel on the east side of the parent. This alignment option is not possible in the radial or level layout modes.
    - TIP_OVER_WEST - a parent is outside the border of the child nodes, and the child nodes are placed sequentially instead of in parallel on the west side of the parent. This alignment option is not possible in the radial or level layout modes.
    - TIP_OVER_EAST_WEST - similar to TIP_OVER_EAST or TIP_OVER_WEST, but the child nodes are arranged on both sides of the link segment that starts at the parent node. The first child is placed on the east side. Further child nodes are placed on the east or west side, so that the space used on both sides is roughly the same, that is, the subtrees on the east side have roughly the same sum of heights as the subtrees on the west side. This alignment option is not possible in the radial or level layout modes.
    - TIP_OVER_BOTH_SIDES - similar to TIP_OVER_EAST or TIP_OVER_WEST, but the child nodes are arranged in pairs on both sides of the link segment that starts at the parent node. Unlike the behavior with TIP_OVER_EAST_WEST, the algorithm does not try to optimize the space used on both sides but always puts the odd-numbered child nodes to the west and the even-numbered child nodes to the east, and the pairs of child nodes, one on the east side and one on the west side, are aligned with one another. This alignment option is not possible in the radial or level layout modes.
    The default value is CENTER.
    Parameters:
    
    node - The node instance.
    
    alignment - The alignment option of the individual node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getAlignment(Object), setGlobalAlignment(int)
  - getAlignment
```
public final int getAlignment(Object node)
```
    Returns the local alignment option of the node.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The local alignment of the given node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setAlignment(Object, int), setGlobalAlignment(int)
  - setChildAlignment
```
public final void setChildAlignment(Object node,
                                    int alignment)
```
    Sets the child alignment option of the node. This child alignment option is used to specify exceptional alignments for the child that differ from the alignment specified at the parent for all child nodes. This method always overwrites the aligment specified using setAlignment(Object, int) and setGlobalAlignment(int) at the parent. Child alignments only take effect in free and level mode but not in radial or balloon mode, and only if the child node is not a root node of a tree.
    Valid values are:
    - UNSPECIFIED - no exceptional alignment is specified for this child node.
    - EAST_NEIGHBOR - the child node is made a neighbor on the east side of its parent node.
    - WEST_NEIGHBOR - the child node is made a neighbor on the west side of its parent node.
    - TIP_OVER_ASSOCIATE_BOTH_SIDES - the child is laid out like an associate node of its parent node. Associate nodes occur alternating on the east and west sides of their parent node.
    - TIP_OVER_ASSOCIATE_EAST - the child is laid out like an associate node of its parent node. This associate nodes occurs on the east side of its parent node.
    - TIP_OVER_ASSOCIATE_WEST - the child is laid out like an associate node of its parent node. This associate nodes occurs on the west side of its parent node.
    The default value is UNSPECIFIED.
    Parameters:
    
    node - The node instance.
    
    alignment - The child alignment option of the input node. This child alignment option is used to specify exceptional alignments for the child node that differ from the alignment specified at the parent for all child nodes.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getChildAlignment(Object), setAlignment(Object, int), setGlobalAlignment(int), setEastWestNeighboring(Object, Object), addAssociate(Object, Object)
  - getChildAlignment
```
public final int getChildAlignment(Object node)
```
    Returns the child alignment option of the node.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The child alignment of the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setChildAlignment(Object, int), setAlignment(Object, int), setGlobalAlignment(int)
  - setEastSubtreeBlockMargin
```
public final void setEastSubtreeBlockMargin(Object node,
                                            double margin)
```
    Sets the margin on the east side of the subtree starting at the input node. If the value is set to a positive number, the subtree starting at this node is considered a rectangular block, and other nodes not belonging to this subtree are moved at least the specified margin away from this block. Specifying subtree block margins is useful if you plan to draw a rectangle around the subtree, since it ensures that unrelated nodes do not extend into the rectangle.
    The default value is -1, which means no margin.
    
    Parameters:
    
    node - The node instance.
    
    margin - The margin on the east side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getEastSubtreeBlockMargin(Object)
  - getEastSubtreeBlockMargin
```
public final double getEastSubtreeBlockMargin(Object node)
```
    Returns the margin on the east side of the subtree starting at the input node.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The margin on the east side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setEastSubtreeBlockMargin(Object, double)
  - setWestSubtreeBlockMargin
```
public final void setWestSubtreeBlockMargin(Object node,
                                            double margin)
```
    Sets the margin on the west side of the subtree starting at the input node. If the value is set to a positive number, the subtree starting at this node is considered a rectangular block, and other nodes not belonging to this subtree are moved at least the specified margin away from this block. Specifying subtree block margins is useful if you plan to draw a rectangle around this subtree, since it ensures that unrelated nodes do not extend into this rectangle.
    The default value is -1, means no margin.
    
    Parameters:
    
    node - The node instance.
    
    margin - The margin on the west side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getWestSubtreeBlockMargin(Object)
  - getWestSubtreeBlockMargin
```
public final double getWestSubtreeBlockMargin(Object node)
```
    Returns the margin on the west side of the subtree starting at the input node.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The margin on the west side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setWestSubtreeBlockMargin(Object, double)
  - setNorthSubtreeBlockMargin
```
public final void setNorthSubtreeBlockMargin(Object node,
                                             double margin)
```
    Sets the margin on the north side of the subtree starting at the input node. If the value is set to a positive number, the subtree starting at this node is considered a rectangular block, and other nodes not belonging to this subtree are moved at least the specified margin away from this block. Specifying subtree block margins is useful if you plan to draw a rectangle around this subtree, since it ensures that unrelated nodes do not extend into the rectangle.
    The default value is -1, means no margin.
    
    Parameters:
    
    node - The node instance.
    
    margin - The margin on the north side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getNorthSubtreeBlockMargin(Object)
  - getNorthSubtreeBlockMargin
```
public final double getNorthSubtreeBlockMargin(Object node)
```
    Returns the margin on the north side of the subtree starting at the input node.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The margin on the north side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setNorthSubtreeBlockMargin(Object, double)
  - setSouthSubtreeBlockMargin
```
public final void setSouthSubtreeBlockMargin(Object node,
                                             double margin)
```
    Sets the margin on the south side of the subtree starting at the input node. If the value is set to a positive number, the subtree starting at this node is considered a rectangular block, and other nodes not belonging to this subtree are moved at least the specified margin away from this block. Specifying subtree block margins is useful if you plan to draw a rectangle around this subtree, since it ensures that unrelated nodes do not reach into the rectangle.
    The default value is -1, which means no margin.
    
    Parameters:
    
    node - The node instance.
    
    margin - The margin on the south side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getSouthSubtreeBlockMargin(Object)
  - getSouthSubtreeBlockMargin
```
public final double getSouthSubtreeBlockMargin(Object node)
```
    Returns the margin on the south side of the subtree starting at the input node.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The margin on the south side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setSouthSubtreeBlockMargin(Object, double)
  - setSubtreeBlockMargin
```
public final void setSubtreeBlockMargin(Object node,
                                        int side,
                                        double margin)
```
    Sets the margin on the specified side of the subtree starting at the input node. Possible values for the side parameter are EAST, WEST, NORTH, and SOUTH. If the value is set to a positive number, the subtree starting at this node is considered a rectangular block, and other nodes not belonging to this subtree are moved at least the specified margin away from this block. Specifying subtree block margins is useful if you plan to draw a rectangle around this subtree, since it ensures that unrelated nodes do not extend into the rectangle.
    The default value is -1, which means no margin on the specified side.
    
    Parameters:
    
    node - The node instance.
    
    side - The subtree side.
    
    margin - The margin on the specified side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    getSubtreeBlockMargin(Object, int)
  - getSubtreeBlockMargin
```
public final double getSubtreeBlockMargin(Object node,
                                          int side)
```
    Returns the margin on the specified side of the subtree starting at the input node. Possible values for the side parameter are EAST, WEST, NORTH, and SOUTH.
    
    Parameters:
    
    node - The node instance.
    
    side - The subtree side.
    
    Returns:
    
    The margin on the specified side of the subtree starting at the input node.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    setSubtreeBlockMargin(Object, int, double)
  - isLocalRecursiveLayoutNeeded
```
public boolean isLocalRecursiveLayoutNeeded(IlvLayoutProvider layoutProvider,
                                            IlvGraphLayout recLayout,
                                            IlvGraphModel rootModel,
                                            boolean traverse)
```
    Checks whether layout is needed when layout is performed recursively on a hierarchy of nested subgraphs.
    
    Overrides:
    
    isLocalRecursiveLayoutNeeded in class IlvGraphLayout
    
    Parameters:
    
    layoutProvider - The object that provides a layout instance to be used for laying out each subgraph.
    
    recLayout - The recursive layout that started the recursive application of layouts. This can be null.
    
    rootModel - The graph model that is the root of the nesting hierarchy of graph models.
    
    traverse - If false, this layout is intended to be only applied to its own graph model. If true, this layout is intended to be applied to its graph model and the layout instances provided by the layoutProvider are intended to be applied recursively to all nested subgraph models. The traverse flag is basically passed through from the call of IlvGraphLayout.performLayout(boolean, boolean, boolean).
    
    Returns:
    
    true if it is necessary to perform the layout, false otherwise.
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    IlvGraphLayout.isLayoutNeeded(), IlvGraphLayout.performLayout(boolean, boolean, boolean), IlvGraphLayout.PerformLayout(IlvGraphModel, IlvLayoutProvider, boolean, boolean, boolean), IlvRecursiveLayout
  - createLayoutGrapherProperty
```
protected IlvGraphLayoutGrapherProperty createLayoutGrapherProperty(String name,
                                                                    boolean withDefaults)
```
    Returns a new instance of IlvTreeLayoutGrapherProperty that stores the parameter settings of this layout class. The method is used by IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean) to create a named property that contains parameter settings of this layout instance.
    
    Overrides:
    
    createLayoutGrapherProperty in class IlvGraphLayout
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayoutGrapherProperty, IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()
  - createLayoutNodeProperty
```
protected IlvGraphLayoutNodeProperty createLayoutNodeProperty(String name,
                                                              IlvGraphic node,
                                                              boolean withDefaults)
```
    Returns a new instance of IlvTreeLayoutNodeProperty that stores the parameter settings of this layout class for nodes. The method is used by IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean) to create a named property for a node that contains parameter settings of this layout instance for the input node.
    
    Overrides:
    
    createLayoutNodeProperty in class IlvGraphLayout
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayoutNodeProperty, IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()
  - createLayoutLinkProperty
```
protected IlvGraphLayoutLinkProperty createLayoutLinkProperty(String name,
                                                              IlvGraphic link,
                                                              boolean withDefaults)
```
    Returns a new instance of IlvTreeLayoutLinkProperty that stores the parameter settings of this layout class for links. The method is used by IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean) to create a named property for a link that contains parameter settings of this layout instance for the input link.
    
    Overrides:
    
    createLayoutLinkProperty in class IlvGraphLayout
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayoutLinkProperty, IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()
  - layoutStepPerformed
```
public void layoutStepPerformed()
```
    This method can be called by the layout classes when a step of the layout algorithm has been performed. The method notifies the listeners of the layout events (if any). In addition to the base functionality, this method updates the percentage of completion value.
    
    Overrides:
    
    layoutStepPerformed in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.increasePercentageComplete(int)
  - checkAppropriateLinks
```
public void checkAppropriateLinks()
                           throws IlvInappropriateLinkException
```
    Throws an exception if the links are not appropriate for the layout.
    
    Overrides:
    
    checkAppropriateLinks in class IlvGraphLayout
    
    Throws:
    
    IlvInappropriateLinkException
    
    Since:
    
    JViews 8.5
    
    See Also:
    
    IlvGraphLayout.performLayout(boolean, boolean, boolean), IlvGraphLayout.performLayout(boolean, boolean), IlvGraphLayout.checkAppropriateLink(java.lang.Object), IlvGraphModel.setLinkCheckEnabled(boolean), IlvGraphModel.setConnectionPointCheckEnabled(boolean), IlvGraphLayoutUtil.EnsureAppropriateLinks(ilog.views.graphlayout.IlvGraphModel, ilog.views.graphlayout.IlvLayoutProvider), IlvInappropriateLinkException
  - checkAppropriateLink
```
public int checkAppropriateLink(Object link)
```
    Checks whether the input link is appropriate for this layout. You should not call this method directly. It is called by checkAppropriateLinks().
    
    Overrides:
    
    checkAppropriateLink in class IlvGraphLayout
    
    Parameters:
    
    link - The link to be checked.
    
    Returns:
    
    The exception type for the link.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    checkAppropriateLinks()
  - getMovingNodes
```
public IlvGraphicVector getMovingNodes()
```
    Returns the vector of nodes being moved by the graph layout algorithm. You should not call this method. It is only used when the graph model is an IlvGrapherAdaper in order to optimize for speed.
    
    Overrides:
    
    getMovingNodes in class IlvGraphLayout
    
    Since:
    
    JViews 5.5

Class IlvTreeLayout

Field Summary

Fields inherited from class ilog.views.graphlayout.IlvGraphLayout

Constructor Summary

Method Summary

Methods inherited from class ilog.views.graphlayout.IlvGraphLayout

Methods inherited from class java.lang.Object

Field Detail

NO_RESHAPE_STYLE

STRAIGHT_LINE_STYLE

ORTHOGONAL_STYLE

MIXED_STYLE

AUTOMATIC_PINS

CENTERED_PINS

CLIPPED_PINS

EVENLY_SPACED_PINS

EAST

WEST

NORTH

SOUTH

CENTER

BORDER_CENTER

TIP_OVER

TIP_OVER_EAST

TIP_OVER_WEST

TIP_OVER_EAST_WEST

TIP_OVER_BOTH_SIDES

MIXED

UNSPECIFIED

EAST_NEIGHBOR

WEST_NEIGHBOR

TIP_OVER_ASSOCIATE_BOTH_SIDES

TIP_OVER_ASSOCIATE_EAST

TIP_OVER_ASSOCIATE_WEST

FREE

LEVEL

RADIAL

ALTERNATING_RADIAL

BALLOON

TIP_LEAVES_OVER

TIP_ROOTS_OVER

TIP_ROOTS_AND_LEAVES_OVER

REGULAR

FAST_PROPORTIONAL

PROPORTIONAL

VARIABLE_RADIUS

OPTIMIZED_VARIABLE_RADIUS

UNIFORM_LEAVES_RADIUS

OPTIMIZED_UNIFORM_LEAVES_RADIUS

UNIFORM_RADIUS

Constructor Detail

IlvTreeLayout

IlvTreeLayout

Method Detail

init

copy

copyParameters

layout

detach

cleanNode

cleanLink

supportsPreserveFixedNodes

supportsPreserveFixedLinks

supportsAllowedTime

supportsStopImmediately

stopImmediately

supportsPercentageComplete

supportsLayoutOfConnectedComponents

supportsLinkConnectionBox

supportsLinkClipping

supportsSaveParametersToNamedProperties

supportsSplineRouting

setGlobalLinkStyle

getGlobalLinkStyle

setConnectorStyle

getConnectorStyle

setFlowDirection

getFlowDirection

setLayoutMode

getLayoutMode