IlvHierarchicalLayout (Rogue Wave JViews 9.2 API)

java.lang.Object
- ilog.views.graphlayout.IlvGraphLayout
- - ilog.views.graphlayout.hierarchical.IlvHierarchicalLayout

All Implemented Interfaces:

GraphModelListener, Serializable, EventListener
```
public class IlvHierarchicalLayout
extends IlvGraphLayout
```
The main class for the Hierarchical Layout algorithm.
The Hierarchical Layout arranges the nodes in horizontal or vertical levels such that the majority of the links point in the same direction and the number of link crossings is small.

Here is a sample drawing produced by the Hierarchical Layout algorithm with two levels of nodes that are top-justified within each level:

Another sample drawing with eight levels follows. This graph contains a cycle and a self-loop. The direction of the flow is from top to bottom. The nodes are organized in horizontal levels.

The Hierarchical Layout algorithm supports different styles of links in the same drawing. The following sample drawing shows orthogonal, straight, and polyline links. The direction of the flow is to the right and the node levels are vertical.

The Hierarchical Layout algorithm supports port specifications. The side and index of the port where a link connects to a node can be specified. The following sample drawing shows a drawing with port specifications and orthogonal link style. The direction of the flow is from top to bottom.

To simplify the explanations of the layout parameters, we use the compass directions north, south, east, and west. The first level of the layout is the north pole. If the flow direction is top to bottom, north is always upwards, south towards the bottom, west towards the left, and east towards the right side of the layout. If the flow direction is left to right, north is left and south is right.

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:
- The layout algorithm always takes into account the direction of links.
- The initial position of the nodes (at the moment you start the layout) does not affect the resulting layout.
- The algorithm supports self-links, cycles, and multiple links between the same pair of nodes.
Since:

JViews 3.0

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`AUTOMATIC_PINS` Automatic connector pin option.
`static int`	`CENTERED_PINS` Centered connector pin option.
`static int`	`CLIPPED_PINS` Clipped connector pin option.
`static int`	`EAST` East port side.
`static int`	`EVENLY_SPACED_PINS` Evenly spaced connector pin option.
`static int`	`FIXED_IN_X_MODE` Fixed movement mode for the x direction.
`static int`	`FIXED_IN_Y_MODE` Fixed movement mode for the y direction.
`static int`	`FIXED_MODE` Fixed movement mode.
`static int`	`FREE_MODE` Free movement mode.
`static int`	`HIGHER_LEVELS` The leveling strategy that utilizes higher-numbered levels.
`static int`	`LOWER_LEVELS` The leveling strategy to utilize lower numbered levels.
`static int`	`MIXED_MODE` Mixed movement mode.
`static int`	`MIXED_STYLE` Mixed link shape option.
`static int`	`NO_RESHAPE_STYLE` No reshape option.
`static int`	`NORTH` North port side.
`static int`	`OPTIMAL` The optimal leveling strategy.
`static int`	`ORTHOGONAL_STYLE` Orthogonal link shape option.
`static int`	`POLYLINE_STYLE` Polyline link shape option.
`static int`	`SEMI_OPTIMAL` The semioptimal leveling strategy.
`static int`	`SOUTH` South port side.
`static int`	`SPREAD_OUT` The leveling strategy to spread the nodes over all levels.
`static int`	`STRAIGHT_LINE_STYLE` Straight-line link shape option.
`static int`	`UNSPECIFIED` Unspecified port side.
`static int`	`WEST` West port side.

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

Constructor Summary

Constructors
Constructor and Description
`IlvHierarchicalLayout()` Creates a new instance of the Hierarchical Layout algorithm.
`IlvHierarchicalLayout(IlvHierarchicalLayout 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`	`addConstraint(IlvHierarchicalConstraint constraint)` Adds a constraint for the hierarchical layout.
`protected void`	`beforeLayout(boolean redraw)` Performs preprocessing operations before the layout of the entire graph.
`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 `IlvHierarchicalLayoutGrapherProperty` that stores the parameter settings of this layout class.
`protected IlvGraphLayoutLinkProperty`	`createLayoutLinkProperty(String name, IlvGraphic link, boolean withDefaults)` Returns a new instance of `IlvHierarchicalLayoutLinkProperty` 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 `IlvHierarchicalLayoutNodeProperty` that stores the parameter settings of this layout class for nodes.
`void`	`detach()` Detaches the graph model from the layout instance.
`long`	`getAllowedTime()` Returns the currently allowed time for the layout algorithm in milliseconds.
`int`	`getCalcNodeLevelIndex(Object node)` Returns the calculated level index of a node after performing a layout.
`int`	`getCalcNodePositionIndex(Object node)` Returns the calculated index of the node position within a level after performing a layout.
`int`	`getConnectorStyle()` Returns the style of the connectors.
`Enumeration`	`getConstraints()` Returns the constraints that have been added to the hierarchical layout.
`int`	`getDestinationPointMode(Object link)` Returns the destination point mode of an individual link.
`int`	`getEastNumberOfPorts(Object node)` Returns the number of relative ports on the east side of a node.
`int`	`getFlowDirection()` Returns the current direction of the link flow.
`int`	`getFromPortIndex(Object link)` Returns the port index of a link at the "from" side.
`int`	`getFromPortSide(Object link)` Returns the port side of a link at the "from" side.
`int`	`getGlobalDestinationPointMode()` Returns the global mode for the connection points of the links on the destination nodes.
`int`	`getGlobalIncrementalNodeMovementMode()` Returns the node movement mode used during incremental layout.
`int`	`getGlobalLinkStyle()` Returns the global style of the shapes of links.
`int`	`getGlobalOriginPointMode()` Returns the global mode for the connection points of the links on the origin nodes.
`double`	`getHorizontalLinkOffset()` Returns the horizontal offset between parallel segments of links.
`double`	`getHorizontalNodeLinkOffset()` Returns the horizontal offset between a node and a link segment that is parallel to the node border.
`double`	`getHorizontalNodeOffset()` Returns the horizontal offset between nodes.
`double`	`getIncrementalAbsoluteLevelPositionRange()` Returns the range that is considered very close to the previous node position.
`double`	`getIncrementalAbsoluteLevelPositionTendency()` Returns the percentage of how much the layout algorithm tries to place nodes to absolute positions within the level that are close to the previous positions during incremental layout.
`IlvRect`	`getIncrementalNodeBoxForExpand(Object expandedNode)` Returns the effective bounding rectangle of an expanded node during incremental layout.
`int`	`getIncrementalNodeMovementMode(Object node)` Returns the movement mode of an individual node used during incremental layout.
`IlvAnnealingLabelLayout`	`getLabelLayout()` Returns the label layout that handles the label in recursive mode.
`int`	`getLevelingStrategy()` Returns the current hierarchical layout leveling strategy.
`int`	`getLevelJustification()` Returns the current justification within the levels.
`float`	`getLinkPriority(Object link)` Returns the priority of a link.
`int`	`getLinkStyle(Object link)` Returns the style for the shape of an individual link.
`double`	`getMaxInterLevelApertureAngle()` Returns the maximum aperture angle of the links incident to a node.
`double`	`getMinEndSegmentLength()` Returns the minimum length of the last segment of each link, that is, the segment that is incident to the "to" node.
`double`	`getMinForkSegmentLength()` Returns the minimum length of the start or end segment of links if a fork shape is used for these links.
`double`	`getMinStartSegmentLength()` Returns the minimum length of the first segment of each link, that is, the segment that is incident to the "from" node.
`IlvGraphicVector`	`getMovingNodes()` Returns the vector of nodes being moved by the graph layout algorithm.
`double`	`getMultiLinkOptimizationMaxSpread()` Returns the maximum spread width for the bends introduced by the optimization of overlapping multiple links.
`double`	`getMultiLinkOptimizationOffset()` Returns the minimum distance between bends introduced by the optimization of overlapping multiple links.
`Enumeration`	`getNodeGroups()` Returns the node groups that occur in constraints that were added to the hierarchical layout.
`int`	`getNorthNumberOfPorts(Object node)` Returns the number of relative ports on the north side of a node.
`int`	`getNumberOfConstraints()` Returns the number of constraints that have been added to the hierarchical layout.
`int`	`getNumberOfLinkCrossingSweeps()` Returns the number of layer sweeps to remove link crossings.
`int`	`getNumberOfNodeGroups()` Returns the number of node groups that occur in constraints that were added to the hierarchical layout.
`int`	`getNumberOfPorts(Object node, int side)` Returns the specified number of relative ports of a node on the specified side.
`int`	`getOriginPointMode(Object link)` Returns the origin point mode of an individual link.
`IlvPoint`	`getPosition()` Returns the specified position of the layout.
`double`	`getPreferredForkAxisLength()` Returns the preferred length of the axis of a fork shape.
`int`	`getSelfLinkFromPortSide()` Returns the default port side of a self-link at the "from" side.
`int`	`getSelfLinkToPortSide()` Returns the default port side of a self-link at the "to" side.
`int`	`getSouthNumberOfPorts(Object node)` Returns the number of relative ports on the south side of a node.
`int`	`getSpecNodeLevelIndex(Object node)` Returns the index of the specified level for a node.
`int`	`getSpecNodePositionIndex(Object node)` Returns the index of the specified position of a node within a level.
`int`	`getToPortIndex(Object link)` Returns the port index of a link at the "to" side.
`int`	`getToPortSide(Object link)` Returns the port side of a link at the "to" side.
`double`	`getVerticalLinkOffset()` Returns the vertical offset between parallel segments of links.
`double`	`getVerticalNodeLinkOffset()` Returns the vertical offset between a node and a link segment that is parallel to the node border.
`double`	`getVerticalNodeOffset()` Returns the vertical offset between nodes.
`int`	`getWestNumberOfPorts(Object node)` Returns the number of relative ports on the west side of a node.
`protected void`	`init()` Initializes instance variables.
`boolean`	`isBacktrackCrossingReductionEnabled()` Returns `true` if the backtrack mechanism of the link crossing reduction phase is enabled.
`boolean`	`isCrossingReductionDuringIncremental()` Returns `true` if crossing reduction during incremental layout is enabled.
`boolean`	`isFromFork()` Returns `true` if the fork shape is enabled for links that start at the same source point.
`boolean`	`isIncrementalAbsoluteLevelPositioning()` Returns `true` if the algorithm tries to place the nodes within the level to absolute positions that are close to the previous positions during incremental layout.
`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 levels.
`boolean`	`isLabelLayoutEnabledDuringRecLayoutMode()` Returns `true` if the recursive layout mode places also the labels of the graph.
`boolean`	`isLinkCrossingFineTuningEnabled()` Returns `true` if the link crossing fine tuning phase is enabled.
`boolean`	`isLinkStraighteningEnabled()` Returns `true` if the link straightening phase is enabled.
`boolean`	`isLinkWidthUsed()` Returns `true` if the layout respects the width of links.
`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`	`isLongLinkCrossingReductionDuringIncremental()` Returns `true` if the handling of long links by the crossing reduction during incremental layout is enabled.
`boolean`	`isMedianCrossingValueEnabled()` Returns `true` if the median crossing value is used during crossing reduction.
`boolean`	`isMultiLinkOptimizationEnabled()` Returns `true` if the optimization of overlapping multiple links is enabled.
`boolean`	`isNeighborLinksAligned()` Returns `true` if links between neighbor nodes of the same level are aligned so that they are parallel.
`boolean`	`isNonorthogonalBendEliminationEnabled()` Returns `true` if the bend elimination phase for nonorthogonal links is enabled.
`boolean`	`isOrthogonalStairCaseEliminationEnabled()` Returns `true` if the stair case elimination phase for orthogonal links is enabled.
`boolean`	`isPolylineLinkOverlapReductionEnabled()` Returns `true` if the optimization of polyline links is enabled to avoid links overlapping large neighbor nodes.
`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`	`isRecursiveLayoutMode()` Returns `true` if this layout instance handles all subgraphs recursively that are nested into this graph.
`boolean`	`isSelfLinksSameSideNested()` Returns `true` if self-links that attach the same side of a node are nested.
`boolean`	`isToFork()` Returns `true` if the fork shape is enabled for links that end at the same target point.
`protected void`	`layout(boolean redraw)` Computes the layout using the Hierarchical Layout algorithm.
`void`	`layoutStepPerformed()` Can be called by the layout classes when a step of the layout algorithm has been performed.
`void`	`markForIncremental(Object nodeOrLink)` Marks the input node or link to be repositioned with the next call of `IlvGraphLayout.performLayout()` if incremental mode is enabled.
`void`	`removeAllConstraints()` Removes all the constraints from the hierarchical layout.
`void`	`removeConstraint()` Removes the constraint that was most recently added from the hierarchical layout.
`void`	`removeConstraint(IlvHierarchicalConstraint constraint)` Removes the specified constraint from the hierarchical layout.
`void`	`setAllowedTime(long time)` Sets the upper limit for the duration of the layout algorithm.
`void`	`setBacktrackCrossingReductionEnabled(boolean flag)` Sets whether the backtrack mechanism of the link crossing reduction phase is enabled.
`void`	`setConnectorStyle(int style)` Sets the style of connectors.
`void`	`setCrossingReductionDuringIncremental(boolean enable)` Sets whether crossing reduction during incremental layout is enabled.
`void`	`setDestinationPointMode(Object link, int mode)` Sets the mode for the connection point of an individual link on the destination node.
`void`	`setEastNumberOfPorts(Object node, int numberOfPorts)` Sets the number of relative ports on the east side of a node.
`void`	`setFlowDirection(int direction)` Sets the direction of the link flow.
`void`	`setFromFork(boolean enable)` Sets whether a fork shape is created for links that start at the same source point.
`void`	`setFromPortIndex(Object link, int portIndex)` Sets the port index of a link at the "from" side.
`void`	`setFromPortSide(Object link, int side)` Sets the port side of a link at the "from" side.
`void`	`setGlobalDestinationPointMode(int mode)` Sets the global mode for the connection point of the links on the destination nodes.
`void`	`setGlobalIncrementalNodeMovementMode(int mode)` Sets the node movement mode used during incremental layout.
`void`	`setGlobalLinkStyle(int style)` Sets the global style of the shapes of links.
`void`	`setGlobalOriginPointMode(int mode)` Sets the global mode for the connection point of the links on the origin nodes.
`void`	`setHorizontalLinkOffset(double offset)` Sets the horizontal offset between parallel segments of links.
`void`	`setHorizontalNodeLinkOffset(double offset)` Sets the horizontal offset between a node and a link segment that is parallel to the node border.
`void`	`setHorizontalNodeOffset(double offset)` Sets the horizontal offset between nodes.
`void`	`setIncrementalAbsoluteLevelPositioning(boolean enable)` Sets whether it is enabled to place nodes within the level to absolute positions that are close to the previous positions during incremental layout.
`void`	`setIncrementalAbsoluteLevelPositionRange(double range)` Sets the range that is considered very close to the previous node position.
`void`	`setIncrementalAbsoluteLevelPositionTendency(double percentage)` Sets the percentage how much the layout algorithm tries to place nodes to absolute positions within the level that are close to the previous positions during incremental layout.
`void`	`setIncrementalMode(boolean enable)` Sets whether the incremental layout mode is enabled.
`void`	`setIncrementalNodeBoxForExpand(Object expandedNode, IlvRect rect)` Sets the effective bounding rectangle of an expanded node during incremental layout.
`void`	`setIncrementalNodeMovementMode(Object node, int mode)` Sets the movement mode of an individual node used during incremental layout.
`void`	`setIntergraphConnectivityMode(boolean flag)` Sets whether the intergraph link connectivity is considered for the partitioning of the layout into levels.
`void`	`setLabelLayoutEnabledDuringRecLayoutMode(boolean flag)` Sets whether the recursive layout mode places also the labels of the graph.
`void`	`setLevelingStrategy(int strategy)` Sets the hierarchical layout leveling strategy.
`void`	`setLevelJustification(int justification)` Sets the justification within the levels.
`void`	`setLinkCrossingFineTuningEnabled(boolean flag)` Sets whether the link crossing fine tuning phase is enabled.
`void`	`setLinkPriority(Object link, float priority)` Sets the priority of a link.
`void`	`setLinkStraighteningEnabled(boolean flag)` Sets whether the link straightening phase is enabled.
`void`	`setLinkStyle(Object link, int style)` Sets the style of the shape of an individual link.
`void`	`setLinkWidthUsed(boolean used)` Sets whether the layout respects the width of links.
`void`	`setLongLinkCrossingReductionDuringIncremental(boolean enable)` Sets whether the handling of long links for crossing reduction during incremental layout is enabled.
`void`	`setMaxInterLevelApertureAngle(double angle)` Sets the maximum aperture angle of the links incident to a node.
`void`	`setMedianCrossingValueEnabled(boolean flag)` Sets whether the median crossing value is used during crossing reduction.
`void`	`setMinEndSegmentLength(double length)` Sets the minimum length of the last segment of each link, that is, the segment that is incident to the "to" node.
`void`	`setMinForkSegmentLength(double length)` Sets the minimum length of the start or end segment of links if a fork shape is used for these links.
`void`	`setMinStartSegmentLength(double length)` Sets the minimum length of the first segment of each link, that is, the segment that is incident to the "from" node.
`void`	`setMultiLinkOptimizationEnabled(boolean flag)` Sets whether the optimization of overlapping multiple links is enabled.
`void`	`setMultiLinkOptimizationMaxSpread(double maxSpread)` Sets the maximum spread width for the bends introduced by the optimization of overlapping multiple links.
`void`	`setMultiLinkOptimizationOffset(double offset)` Sets the minimum distance between bends introduced by the optimization of overlapping multiple links.
`void`	`setNeighborLinksAligned(boolean enable)` Sets whether links between neighbor nodes of the same level are aligned so that they are strictly horizontal or vertical.
`void`	`setNonorthogonalBendEliminationEnabled(boolean flag)` Sets whether the bend elimination phase for nonorthogonal links is enabled.
`void`	`setNorthNumberOfPorts(Object node, int numberOfPorts)` Sets the number of relative ports on the north side of a node.
`void`	`setNumberOfLinkCrossingSweeps(int numberOfSweeps)` Sets the number of layer sweeps to remove link crossings.
`void`	`setNumberOfPorts(Object node, int side, int numberOfPorts)` Sets the number of relative ports of a node on a given side.
`void`	`setOriginPointMode(Object link, int mode)` Sets the mode for the connection point on an individual link on the origin node.
`void`	`setOrthogonalStairCaseEliminationEnabled(boolean flag)` Sets whether the stair case elimination phase for orthogonal links is enabled.
`void`	`setPolylineLinkOverlapReductionEnabled(boolean flag)` Sets whether optimization of polyline links to avoid links overlapping large neighbor nodes is enabled.
`void`	`setPosition(IlvPoint point)` Sets the position of the layout.
`void`	`setPreferredForkAxisLength(double length)` Sets the preferred length of the axis of a fork shape.
`void`	`setQuickAndUgly(boolean flag)` This is a convenience method to set up for a "quick and ugly" 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`	`setRecursiveLayoutMode(boolean flag)` Sets whether this layout instance handles all subgraphs recursively that are nested into this graph.
`void`	`setSelfLinkFromPortSide(int side)` Sets the default port side of a self-link at the "from" side.
`void`	`setSelfLinksSameSideNested(boolean flag)` Sets whether self-links that attach the same side of a node are nested.
`void`	`setSelfLinkToPortSide(int side)` Sets the default port side of a self-link at the "to" side.
`void`	`setSouthNumberOfPorts(Object node, int numberOfPorts)` Sets the number of relative ports on the south side of a node.
`void`	`setSpecNodeLevelIndex(Object node, int index)` Sets the index of the specified level for a node.
`void`	`setSpecNodePositionIndex(Object node, int index)` Sets the index of the specified position of a node within a level.
`void`	`setToFork(boolean enable)` Sets whether a fork shape is created for links that end at the same target point.
`void`	`setToPortIndex(Object link, int portIndex)` Sets the port index of a link at the "to" side.
`void`	`setToPortSide(Object link, int side)` Sets the port side of a link at the "to" side.
`void`	`setVerticalLinkOffset(double offset)` Sets the vertical offset between parallel segments of links.
`void`	`setVerticalNodeLinkOffset(double offset)` Sets the vertical offset between a node and a link segment that is parallel to the node border.
`void`	`setVerticalNodeOffset(double offset)` Sets the vertical offset between nodes.
`void`	`setWestNumberOfPorts(Object node, int numberOfPorts)` Sets the number of relative ports on the west side of a 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 links.
`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 layout run.
`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()` Indicates if this class supports the generic optimization of spline control points.
`boolean`	`supportsStopImmediately()` Indicates that this layout class can interrupt the current run of layout immediately in a controlled way.
`void`	`validateConstraints()` Performs a validation check for the constraints.

Methods inherited from class ilog.views.graphlayout.IlvGraphLayout
addGraphLayoutEventListener, addGraphLayoutParameterEventListener, afterLayoutOfSubgraph, attach, attach, beforeLayoutOfSubgraph, callLayoutStepPerformedIfNeeded, cleanGraphModel, clipAllLinks, clipLink, connectAllLinksToCenter, connectLinkToCenter, contentsChanged, createLayoutReport, 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, 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 set at the layout parameter setGlobalLinkStyle(int), none of the links are reshaped. To specify the shape of an individual link, use it as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - STRAIGHT_LINE_STYLE
```
public static final int STRAIGHT_LINE_STYLE
```
    Straight-line link shape option. When set at the layout parameter setGlobalLinkStyle(int), all links get a straight-line shape. To specify the shape of an individual link, use it as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - ORTHOGONAL_STYLE
```
public static final int ORTHOGONAL_STYLE
```
    Orthogonal link shape option. When set at the layout parameter setGlobalLinkStyle(int), all links get a shape consisting of a sequence of orthogonal line segments. To specify the shape of an individual link, use it as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - POLYLINE_STYLE
```
public static final int POLYLINE_STYLE
```
    Polyline link shape option. When set at the layout parameter setGlobalLinkStyle(int), all links get a shape consisting of a sequence of line segments (not necessarily orthogonal). To specify the shape of an individual link, use it as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - MIXED_STYLE
```
public static final int MIXED_STYLE
```
    Mixed link shape option. When set at the layout parameter setGlobalLinkStyle(int), each link can have a different shape. The shape of an individual link can be set by setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - AUTOMATIC_PINS
```
public static final int AUTOMATIC_PINS
```
    Automatic connector pin option. When set at the layout parameter setConnectorStyle(int), the connector style is automatically selected depending on the global link style.
    
    See Also:
    
    setGlobalLinkStyle(int), Constant Field Values
  - CENTERED_PINS
```
public static final int CENTERED_PINS
```
    Centered connector pin option. When set at the layout parameter setConnectorStyle(int), the connector pins of links are placed at the center of the border the link is attached to.
    
    See Also:
    
    Constant Field Values
  - CLIPPED_PINS
```
public static final int CLIPPED_PINS
```
    Clipped connector pin option. When set at the layout parameter setConnectorStyle(int), the connector pins of links are placed such that the link pointing toward the node center is clipped at the node border.
    
    See Also:
    
    setConnectorStyle(int), Constant Field Values
  - EVENLY_SPACED_PINS
```
public static final int EVENLY_SPACED_PINS
```
    Evenly spaced connector pin option. When set at the layout parameter setConnectorStyle(int), the connector pins of links are evenly spaced along the border the link is attached to.
    
    See Also:
    
    Constant Field Values
  - EAST
```
public static final int EAST
```
    East port side. When used as an argument of the methods setFromPortSide(Object, int) or setToPortSide(Object, int), the link is connected to the east border of its end node at the "from" or "to" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortSide(Object, int), setToPortSide(Object, int), Constant Field Values
  - WEST
```
public static final int WEST
```
    West port side. When used as an argument of the methods setFromPortSide(Object, int) or setToPortSide(Object, int), the link is connected to the west border of its end node at the "from" or "to" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortSide(Object, int), setToPortSide(Object, int), Constant Field Values
  - NORTH
```
public static final int NORTH
```
    North port side. When used as an argument of the methods setFromPortSide(Object, int) or setToPortSide(Object, int), the link is connected to the north border of its end node at the "from" or "to" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortSide(Object, int), setToPortSide(Object, int), Constant Field Values
  - SOUTH
```
public static final int SOUTH
```
    South port side. When used as an argument of the methods setFromPortSide(Object, int) or setToPortSide(Object, int), the link is connected to the south border of its end node at the "from" or "to" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortSide(Object, int), setToPortSide(Object, int), Constant Field Values
  - UNSPECIFIED
```
public static final int UNSPECIFIED
```
    Unspecified port side. When used as an argument of the methods setFromPortSide(Object, int) or setToPortSide(Object, int), the link can be connected to any border of its end node at the "from" or "to" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortSide(Object, int), setToPortSide(Object, int), Constant Field Values
  - FREE_MODE
```
public static final int FREE_MODE
```
    Free movement mode. When this mode is used as an argument of the method setGlobalIncrementalNodeMovementMode(int), the incremental layout is free to move the nodes. Depending on the various parameters of the incremental mode, the layout shifts the nodes to optimize the space usage, but the shifting does not change the relative order of the nodes and links, so that the diagram after an incremental layout looks very similar to the previous diagram.
    To specify the mode of an individual node, use this mode as the argument of the method setIncrementalNodeMovementMode(Object, int).
    
    When this mode is used as the argument of the method setGlobalOriginPointMode(int) or setGlobalDestinationPointMode(int), the layout is free to choose the appropriate position of the connection points, except for "pinned" connection points (see IlvGraphModel.hasPinnedConnectionPoint(Object, boolean)). To specify the mode for the connection points of an individual link, use this mode as the argument of the method setOriginPointMode(Object, int) or setDestinationPointMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int), setGlobalOriginPointMode(int), setGlobalDestinationPointMode(int), setOriginPointMode(Object, int), setDestinationPointMode(Object, int), Constant Field Values
  - FIXED_MODE
```
public static final int FIXED_MODE
```
    Fixed movement mode. When this mode is used as an argument of the method setGlobalIncrementalNodeMovementMode(int), the incremental layout keeps all nodes fixed. Only nodes that are marked for incremental repositioning will be moved, and links are rerouted.
    To specify the mode of an individual node, use this mode as the argument of the method setIncrementalNodeMovementMode(Object, int).
    
    When this mode is used as the argument of the method setGlobalOriginPointMode(int) or setGlobalDestinationPointMode(int), the layout must keep the current position of the connection point. To specify the mode for the connection points of an individual link, use this mode as the argument of the method setOriginPointMode(Object, int) or setDestinationPointMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int), setGlobalDestinationPointMode(int), setGlobalOriginPointMode(int), setOriginPointMode(Object, int), setDestinationPointMode(Object, int), Constant Field Values
  - FIXED_IN_X_MODE
```
public static final int FIXED_IN_X_MODE
```
    Fixed movement mode for the x direction. When this mode is used as an argument of the method setGlobalIncrementalNodeMovementMode(int), the incremental layout is free to move the nodes in the y direction but keeps the nodes fixed in the x direction.
    To specify the mode of an individual node, use this mode as the argument of the method setIncrementalNodeMovementMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int), Constant Field Values
  - FIXED_IN_Y_MODE
```
public static final int FIXED_IN_Y_MODE
```
    Fixed movement mode for the y direction. When this mode is used as an argument of the method setGlobalIncrementalNodeMovementMode(int), the incremental layout is free to move the nodes in the x direction but keeps the nodes fixed in the y direction.
    To specify the mode of an individual node, use this mode as the argument of the method setIncrementalNodeMovementMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int), Constant Field Values
  - MIXED_MODE
```
public static final int MIXED_MODE
```
    Mixed movement mode. When this mode is used as the argument of the method setGlobalIncrementalNodeMovementMode(int), each node can have a different movement mode during incremental layout. The mode for an individual node can be set by the method setIncrementalNodeMovementMode(Object, int).
    When used as the argument of the method setGlobalOriginPointMode(int) or setGlobalDestinationPointMode(int), the connection point of each link can have a different mode. The mode for the connection points of an individual link can be set by the method setOriginPointMode(Object, int) or setDestinationPointMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int), setGlobalDestinationPointMode(int), setGlobalOriginPointMode(int), setOriginPointMode(Object, int), setDestinationPointMode(Object, int), Constant Field Values
  - OPTIMAL
```
public static final int OPTIMAL
```
    The optimal leveling strategy.
    When the layout parameter of setLevelingStrategy(int) is set to OPTIMAL, the layout algorithm tries to minimize the sum of level distances for all edges.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLevelingStrategy(int), Constant Field Values
  - SEMI_OPTIMAL
```
public static final int SEMI_OPTIMAL
```
    The semioptimal leveling strategy.
    When the layout parameter of setLevelingStrategy(int) is set to SEMI_OPTIMAL, the layout algorithm tries a quick heuristic to minimize the sum of level distances for all edges. The algorithm pulls root nodes to the highest-numbered level possible and leaf nodes to the lowest-numbered level possible.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLevelingStrategy(int), Constant Field Values
  - HIGHER_LEVELS
```
public static final int HIGHER_LEVELS
```
    The leveling strategy that utilizes higher-numbered levels.
    When the layout parameter of setLevelingStrategy(int) is set to HIGHER_LEVELS, the layout algorithm pulls nodes to the highest-numbered level possible. Root nodes in particular are affected.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLevelingStrategy(int), Constant Field Values
  - LOWER_LEVELS
```
public static final int LOWER_LEVELS
```
    The leveling strategy to utilize lower numbered levels.
    When the layout parameter of setLevelingStrategy(int) is set to LOWER_LEVELS, the layout algorithm pulls nodes to the lowest-numbered level possible. This particularly effects leaf nodes.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLevelingStrategy(int), Constant Field Values
  - SPREAD_OUT
```
public static final int SPREAD_OUT
```
    The leveling strategy to spread the nodes over all levels.
    This can be considered as the inverse of the semioptimal leveling strategy. It pulls root nodes to the lowest-numbered level possible and leaf nodes to the highest-numbered level possible.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLevelingStrategy(int), Constant Field Values
- Constructor Detail
  - IlvHierarchicalLayout
```
public IlvHierarchicalLayout()
```
    Creates a new instance of the Hierarchical 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(ilog.views.IlvGrapher), IlvGraphLayout.attach(ilog.views.graphlayout.IlvGraphModel), IlvGraphLayout.performLayout(), IlvGrapherAdapter.addLayer(ilog.views.IlvManagerLayer), IlvGrapherAdapter.setFilter(ilog.views.graphlayout.IlvLayoutGraphicFilter)
  - IlvHierarchicalLayout
```
public IlvHierarchicalLayout(IlvHierarchicalLayout 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. Hierarchical constraints are not copied. The layout position is not copied. Only the global parameters are copied.
    
    Specified by:
    
    copy in class IlvGraphLayout
    
    Returns:
    
    A copy of the layout instance.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copyParameters(IlvGraphLayout), setPosition(IlvPoint), addConstraint(IlvHierarchicalConstraint)
  - 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. Hierarchical constraints are not copied. The layout position is not copied. Only the global parameters are 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), addConstraint(IlvHierarchicalConstraint)
  - beforeLayout
```
protected void beforeLayout(boolean redraw)
```
    Performs preprocessing operations before the layout of the entire graph. This is called in each layout run once per graph.
    The default implementation calls IlvGraphModel.beforeLayout(IlvGraphLayout, boolean) . Subclasses can override this method to perform some initialization operations when appropriate.
    
    Overrides:
    
    beforeLayout in class IlvGraphLayout
    
    Since:
    
    JViews 8.0
    
    See Also:
    
    IlvGraphLayout.beforeLayoutOfSubgraph(IlvGraphModel)
  - layout
```
protected void layout(boolean redraw)
               throws IlvGraphLayoutException,
                      IlvInappropriateLinkException
```
    Computes the layout using the Hierarchical 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.
    
    IlvInappropriateLinkException
    
    See Also:
    
    IlvGraphLayout.performLayout()
  - setAllowedTime
```
public void setAllowedTime(long time)
```
    Sets the upper limit for the duration of the layout algorithm.
    The default value for Hierarchical layout is 100000000 (100000 seconds).
    
    Overrides:
    
    setAllowedTime in class IlvGraphLayout
    
    Parameters:
    
    time - The allowed time in milliseconds.
    
    See Also:
    
    supportsAllowedTime(), getAllowedTime(), IlvGraphLayout.isLayoutTimeElapsed(), IlvGraphLayoutReport.getCode()
  - getAllowedTime
```
public long getAllowedTime()
```
    Returns the currently allowed time for the layout algorithm in milliseconds.
    Note that the method performLayout does NOT automatically stop the layout when the allowed time is exceeded. It is entirely the responsibility of the implementation of the method layout(boolean) to do this.
    
    Overrides:
    
    getAllowedTime in class IlvGraphLayout
    
    See Also:
    
    supportsAllowedTime(), setAllowedTime(long), IlvGraphLayout.isLayoutTimeElapsed()
  - 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 Hierarchical Layout algorithm, which may lead to node overlaps.
    
    Overrides:
    
    supportsPreserveFixedNodes in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    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.
    
    Overrides:
    
    supportsPreserveFixedLinks in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    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 Hierarchical 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.
    
    See Also:
    
    IlvGraphLayout.setAllowedTime(long), IlvGraphLayout.getAllowedTime(), IlvGraphLayoutReport.getCode()
  - supportsStopImmediately
```
public boolean supportsStopImmediately()
```
    Indicates that this layout class can interrupt the current run of layout immediately in a controlled way. If the algorithm is stopped before termination of the Hierarchical 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 Hierarchical Layout algorithm has several steps. In the early steps, stopping the algorithm is possible and the method returns true. In the last step, stopping the algorithm is no longer possible and the method returns false.
    
    Overrides:
    
    stopImmediately in class IlvGraphLayout
    
    Returns:
    
    true if stopping the algorithm is possible.
    
    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 layout run.
    
    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 on each connected component separately, and uses the layout instance returned by the method IlvGraphLayout.getLayoutOfConnectedComponents() to place 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 previous positions. Nodes of different components with the same specified level index are no longer aligned in levels because each component has an individual level structure.
    
    If the generic connected component layout mechanism is disabled, the algorithm uses its own specialized internal mechanism instead of the generic mechanism. All components are merged into the same global level structure.
    
    Overrides:
    
    supportsLayoutOfConnectedComponents in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    IlvGraphLayout.setLayoutOfConnectedComponents(IlvGraphLayout), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean), IlvGraphLayout.performLayout(boolean, 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 calculated for all links except those with the no-reshape link style and fixed links. The tangential offsets provided by the link connection box interface are currently ignored.
    
    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 in particular 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), supportsLinkClipping()
  - supportsLinkClipping
```
public boolean supportsLinkClipping()
```
    Indicates that this layout class can use a link clip interface to clip the end points of a links. 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 non-rectangular 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 or if they are fixed. 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 after some initial connection points were preliminarily obtained from the connector style (see setConnectorStyle(int)). The mechanism works best for polyline 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, 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 in particular 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), supportsLinkConnectionBox()
  - supportsSaveParametersToNamedProperties
```
public boolean supportsSaveParametersToNamedProperties()
```
    Indicates that this layout class can transfer the layout parameters to named properties. This mechanism is 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()
  - setFlowDirection
```
public final void setFlowDirection(int direction)
```
    Sets the direction of the link flow. Valid values are:
    - IlvDirection.Right - the majority of the links flow to the right.
    - IlvDirection.Left - the majority of the links flow to the left.
    - IlvDirection.Bottom - the majority of the links flow to the bottom.
    - IlvDirection.Top - the majority of the links flow to the top.
    This feature sets the direction of the flow for the majority of the links in a directed graph. The layout algorithm may need to direct some links in the opposite direction of the general link flow. If the links flow to the left or right, the nodes are placed in vertical levels. If the links flow to the top or bottom, the nodes are placed in horizontal levels.
    
    The default value is IlvDirection.Right .
    Parameters:
    
    direction - The direction of the link flow.
    
    See Also:
    
    getFlowDirection()
  - getFlowDirection
```
public final int getFlowDirection()
```
    Returns the current direction of the link flow.
    
    See Also:
    
    setFlowDirection(int)
  - setLevelingStrategy
```
public final void setLevelingStrategy(int strategy)
```
    Sets the hierarchical layout leveling strategy.
    This strategy determines how nodes are distributed in the hierarchical levels. Valid values are:
    - OPTIMAL: the optimal leveling strategy. The layout algorithm tries to minimize the sum of level distances for all edges.
    - SEMI_OPTIMAL: the semioptimal leveling strategy. This strategy often gives the same result as the optimal strategy. The layout algorithm tries a quick heuristic to minimize the sum of level distances for all edges. It pulls root nodes to the highest-numbered level possible and leaf nodes to the lowest-numbered level possible.
    - HIGHER_LEVELS: the leveling strategy to utilize higher numbered levels. This layout algorithm pulls nodes to the highest-numbered level possible. Root nodes in particular are effected.
    - LOWER_LEVELS: the leveling strategy to utilize lower numbered levels. the layout algorithm pulls nodes to the lowest-numbered level possible. Leaf nodes in particular are effected.
    - SPREAD_OUT: the leveling strategy to spread the nodes out over all levels. This can be considered as the inverse of the semioptimal leveling strategy. It pulls root nodes to the lowest-numbered level possible and leaf nodes to the highest-numbered level possible.
    The default value is SEMI_OPTIMAL.
    
    The calculation of node levels can also be influenced by the following node constraints:
    If the incremental mode is switched on, the leveling strategy has no effect. The levels are calculated from the node positions, except for those nodes that are marked for incremental recalculation. See markForIncremental(Object) for more information.
    Parameters:
    
    strategy - The leveling strategy.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    getLevelingStrategy(), markForIncremental(Object)
  - getLevelingStrategy
```
public final int getLevelingStrategy()
```
    Returns the current hierarchical layout leveling strategy.
    
    Returns:
    
    The current hierarchical layout leveling strategy.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setLevelingStrategy(int), markForIncremental(Object)
  - setLevelJustification
```
public final void setLevelJustification(int justification)
```
    Sets the justification within the levels. Valid values are:
    This feature sets the justification of the nodes within each level. 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. If the link flow direction is to the left or right, the nodes can be justified to the left, center, or right. If the link flow direction is to the top or bottom, the nodes can be justified to the top, center, or bottom.
    
    The default value is IlvDirection.Center .
    Parameters:
    
    justification - The justification value.
    
    See Also:
    
    getLevelJustification(), getFlowDirection()
  - getLevelJustification
```
public final int getLevelJustification()
```
    Returns the current justification within the levels.
    
    See Also:
    
    setLevelJustification(int)
  - setConnectorStyle
```
public final void setConnectorStyle(int style)
```
    Sets the style of connectors. Valid values are:
    - CENTERED_PINS - The link connector pins are placed in the center of the border the link is attached to.
    - CLIPPED_PINS - Each link pointing to the center of the node is clipped at the node border.
    - EVENLY_SPACED_PINS - The link connector pins are evenly spaced along the node border.
    - AUTOMATIC_PINS - The connector style is selected depending on the link style.
    The default value is AUTOMATIC_PINS.
    
    The connector style is used to place the connector pins of links that have the free origin or destination point mode and no specified port index. Links with fixed point mode do not change their connection point at the origin node. Links with specified port indexes are connected to the corresponding connector pin of the port instead. 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(ilog.views.graphlayout.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 IlvGraphLayout.setLinkClipInterface(IlvLinkClipInterface), the connector pins are corrected by clipping with that interface.
    If you specify port sides but no port numbers for links (see setFromPortSide(Object, int) and setToPortSide(Object, int)), then it is recommended to avoid CLIPPED_PINS, since they do not reflect the port side precisely enough. Only centered or evenly spaced link connector pins display the port side precisely.
    
    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. For links that have free origin or destination point mode, we recommend using link connectors of type IlvFreeLinkConnector. Other connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinks(ilog.views.graphlayout.IlvGraphModel, ilog.views.graphlayout.IlvLayoutProvider) when the exception is caught to install the appropriate connectors.
    Parameters:
    
    style - The connector style.
    
    See Also:
    
    getConnectorStyle(), setFromPortIndex(Object, int), setToPortIndex(Object, int), supportsLinkClipping(), supportsLinkConnectionBox(), setGlobalOriginPointMode(int), setOriginPointMode(Object, int), setGlobalDestinationPointMode(int), setDestinationPointMode(Object, int)
  - getConnectorStyle
```
public final int getConnectorStyle()
```
    Returns the style of the connectors.
    
    See Also:
    
    setConnectorStyle(int)
  - setFromFork
```
public final void setFromFork(boolean enable)
```
    Sets whether a fork shape is created for links that start at the same source point. A fork shape is a link shape where several links start at the same point, share a link segment, and then branch into separate link paths. The fork shape is used only in the orthogonal link style, and only in the following cases: if the connector style is CENTERED_PINS, or if the links start at the same specified port index at the north or south side of a node, or if the links have the fixed origin point mode and are placed at exactly the same coordinate.
    The default value is false.
    
    Parameters:
    
    enable - true to enable fork shape creation, or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setConnectorStyle(int), setFromPortIndex(Object, int), setGlobalOriginPointMode(int), setOriginPointMode(Object, int), isFromFork()
  - isFromFork
```
public final boolean isFromFork()
```
    Returns true if the fork shape is enabled for links that start at the same source point.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setFromFork(boolean)
  - setToFork
```
public final void setToFork(boolean enable)
```
    Sets whether a fork shape is created for links that end at the same target point. A fork shape is a link shape where several links join from different branches into a final link segment that ends at the same point. The fork shape is used only in the orthogonal link style, and only in the following cases: if the connector style is CENTERED_PINS, or if the links start at the same specified port index at the north or south side of a node, or if the links have the fixed origin point mode and are placed at exactly the same coordinate.
    The default value is false.
    
    Parameters:
    
    enable - true to enable fork shape creation, or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setToPortIndex(Object, int), setGlobalDestinationPointMode(int), setDestinationPointMode(Object, int), isToFork()
  - isToFork
```
public final boolean isToFork()
```
    Returns true if the fork shape is enabled for links that end at the same target point.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setToFork(boolean)
  - setMinForkSegmentLength
```
public void setMinForkSegmentLength(double length)
```
    Sets the minimum length of the start or end segment of links if a fork shape is used for these links.
    The default value is 10.
    
    Parameters:
    
    length - The minimum length of forking segments.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setFromFork(boolean), getMinForkSegmentLength()
  - getMinForkSegmentLength
```
public final double getMinForkSegmentLength()
```
    Returns the minimum length of the start or end segment of links if a fork shape is used for these links.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setMinForkSegmentLength(double)
  - setPreferredForkAxisLength
```
public void setPreferredForkAxisLength(double length)
```
    Sets the preferred length of the axis of a fork shape. If a fork shape is used for n links that start at the same point, and the flow direction is towards the bottom, then the fork will have a horizontal segment as the axis. This horizontal segment has the preferred length calculated from this parameter multiplied by n.
    Note this length is only a hint for the layout algorithm. If there is not enough free space, the layout algorithm decreases the length of the axis below the preferred length. If there is enough free space, it may also increase the length of the axis in order to reduce unnecessary link bends.
    
    The default value is 10.
    
    Parameters:
    
    length - The preferred length of the axis of a fork shape.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setFromFork(boolean), setToFork(boolean), getPreferredForkAxisLength()
  - getPreferredForkAxisLength
```
public final double getPreferredForkAxisLength()
```
    Returns the preferred length of the axis of a fork shape.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setPreferredForkAxisLength(double)
  - setGlobalLinkStyle
```
public final void setGlobalLinkStyle(int style)
```
    Sets the global style of the shapes of links. Valid values are:
    - POLYLINE_STYLE - All links get a polyline shape, that is, a shape consisting of a sequence of line segments.
    - ORTHOGONAL_STYLE - All links get an orthogonal shape, that is, a shape consisting of a sequence of orthogonal line segments.
    - STRAIGHT_LINE_STYLE - All links get 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 style of shape.
    
    The default value is POLYLINE_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 and, for links that have free origin or destination point mode, link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinks(ilog.views.graphlayout.IlvGraphModel, ilog.views.graphlayout.IlvLayoutProvider) before layout or when the exception is caught to convert all links and link connectors to an appropriate type.
    Parameters:
    
    style - The global style value.
    
    See Also:
    
    getGlobalLinkStyle(), setLinkStyle(Object, int)
  - getGlobalLinkStyle
```
public final int getGlobalLinkStyle()
```
    Returns the global style of the shapes of links.
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int)
  - 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. Otherwise, all links have the style that is specified as the global link style.
    Valid values are:
    - POLYLINE_STYLE - The link gets a polyline shape, that is, a shape consisting of a sequence of line segments.
    - ORTHOGONAL_STYLE - The link gets an orthogonal shape, that is, a shape consisting of a sequence of orthogonal line segments.
    - STRAIGHT_LINE_STYLE - The link gets a straight-line shape.
    - NO_RESHAPE_STYLE - No reshape is performed on the link.
    The default value is POLYLINE_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 and, for links that have free origin or destination point mode, link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinks(ilog.views.graphlayout.IlvGraphModel, ilog.views.graphlayout.IlvLayoutProvider) before layout or when the exception is caught to convert all links to an appropriate type.
    Parameters:
    
    link - The link.
    
    style - The shape style.
    
    See Also:
    
    setGlobalLinkStyle(int), getLinkStyle(Object)
  - getLinkStyle
```
public final int getLinkStyle(Object link)
```
    Returns the style for the shape of an individual link.
    
    Parameters:
    
    link - The link.
    
    Returns:
    
    The style for the shape of the specified link.
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int)
  - setHorizontalNodeOffset
```
public final void setHorizontalNodeOffset(double offset)
```
    Sets the horizontal offset between nodes. If the levels are horizontal, this is the minimum distance between the nodes of the same level. If the levels are vertical, this is the minimum distance between the nodes of different levels.
    The default value is 40.
    
    Parameters:
    
    offset - The horizontal offset value.
    
    See Also:
    
    getHorizontalNodeOffset()
  - getHorizontalNodeOffset
```
public final double getHorizontalNodeOffset()
```
    Returns the horizontal offset between nodes.
    
    See Also:
    
    setHorizontalNodeOffset(double)
  - setVerticalNodeOffset
```
public final void setVerticalNodeOffset(double offset)
```
    Sets the vertical offset between nodes. If the levels are vertical, this is the minimum distance between the nodes of the same level. If the levels are horizontal, this is the minimum distance between the nodes of different levels.
    The default value is 40.
    
    Parameters:
    
    offset - The vertical offset value.
    
    See Also:
    
    getVerticalNodeOffset()
  - getVerticalNodeOffset
```
public final double getVerticalNodeOffset()
```
    Returns the vertical offset between nodes.
    
    See Also:
    
    setVerticalNodeOffset(double)
  - setHorizontalLinkOffset
```
public final void setHorizontalLinkOffset(double offset)
```
    Sets the horizontal offset between parallel segments of links. In the orthogonal link style, the segments attached directly to the node may have a smaller offset if the node is too small or the number of incident links is too large to satisfy the specified offset.
    The default value is 15.
    
    Parameters:
    
    offset - The horizontal offset value.
    
    See Also:
    
    getHorizontalLinkOffset()
  - getHorizontalLinkOffset
```
public final double getHorizontalLinkOffset()
```
    Returns the horizontal offset between parallel segments of links.
    
    See Also:
    
    setHorizontalLinkOffset(double)
  - setVerticalLinkOffset
```
public final void setVerticalLinkOffset(double offset)
```
    Sets the vertical offset between parallel segments of links. In the orthogonal link style, the segments attached directly to the node may have a smaller offset if the node is too small or the number of incident links is too large to satisfy the specified offset.
    The default value is 15.
    
    Parameters:
    
    offset - The vertical offset value.
    
    See Also:
    
    getVerticalLinkOffset()
  - getVerticalLinkOffset
```
public final double getVerticalLinkOffset()
```
    Returns the vertical offset between parallel segments of links.
    
    See Also:
    
    setVerticalLinkOffset(double)
  - setHorizontalNodeLinkOffset
```
public final void setHorizontalNodeLinkOffset(double offset)
```
    Sets the horizontal offset between a node and a link segment that is parallel to the node border.
    The default value is 20.
    
    Parameters:
    
    offset - The horizontal offset value.
    
    See Also:
    
    getHorizontalNodeLinkOffset()
  - getHorizontalNodeLinkOffset
```
public final double getHorizontalNodeLinkOffset()
```
    Returns the horizontal offset between a node and a link segment that is parallel to the node border.
    
    See Also:
    
    setHorizontalNodeLinkOffset(double)
  - setVerticalNodeLinkOffset
```
public final void setVerticalNodeLinkOffset(double offset)
```
    Sets the vertical offset between a node and a link segment that is parallel to the node border.
    The default value is 20.
    
    Parameters:
    
    offset - The vertical offset value.
    
    See Also:
    
    getVerticalNodeLinkOffset()
  - getVerticalNodeLinkOffset
```
public final double getVerticalNodeLinkOffset()
```
    Returns the vertical offset between a node and a link segment that is parallel to the node border.
    
    See Also:
    
    setVerticalNodeLinkOffset(double)
  - setMaxInterLevelApertureAngle
```
public final void setMaxInterLevelApertureAngle(double angle)
```
    Sets the maximum aperture angle of the links incident to a node.
    This parameter only has an effect if none of the links has the orthogonal link style. It is best suited if the link style is for polyline links. It defines the maximum angle of the link segments that run between the levels of the hierarchical layout.
    
    The maximum angle is given in degrees, it must be between 10 and 90 degrees.
    
    If the flow direction of the layout is vertical, that is, to the bottom or to the top, a strictly vertical link segment has an aperture of 0, and a strictly horizontal link segment has aperture of 90. By limiting the maximum aperture angle, you ensure that the slope of segments between levels is more vertical than horizontal. That is to say, the slope of the link is in the flow direction of the layout. To ensure the slope of the segments, the vertical space between the levels is enlarged.
    
    If the flow direction of the layout is horizontal, that is, to the left or to the right, a strictly vertical link segment has an aperture of 90, and a strictly horizontal link segment has an aperture of 0. By limiting the maximum aperture angle, you ensure that the slope of segments between levels is more horizontal than vertical. To ensure the slope of the segments, the horizontal space between the levels is enlarged.
    
    If the maximum aperture is set to 90, the aperture angle has no influence on the space between levels. This is the default.
    
    Very small maximum aperture angles are not recommended. The resulting layout may waste too much space between the node levels.
    
    Parameters:
    
    angle - The maximum aperture angle of the links incident to a node.
    
    Since:
    
    JViews 6.5
    
    See Also:
    
    getMaxInterLevelApertureAngle(), setFlowDirection(int), setGlobalLinkStyle(int)
  - getMaxInterLevelApertureAngle
```
public final double getMaxInterLevelApertureAngle()
```
    Returns the maximum aperture angle of the links incident to a node. The maximum angle is given in degree.
    
    Returns:
    
    The maximum aperture angle of the links incident to a node.
    
    Since:
    
    JViews 6.5
    
    See Also:
    
    setMaxInterLevelApertureAngle(double)
  - setLinkWidthUsed
```
public final void setLinkWidthUsed(boolean used)
```
    Sets whether the layout respects the width of links. This option affects the calculation of connector pins that must be evenly spaced. It has no effect on the link connector pins with the connector style CLIPPED_PINS or CENTERED_PINS.
    If true is passed as the argument, the distribution of the connector pins varies depending on the link width. The horizontal or vertical offset between pairs of links or links and nodes is with respect to the link border. If false is passed as the argument, the distribution of connector pins is independent of the link width. The horizontal or vertical offset between pairs of links or links and nodes is with respect to the link center.
    
    The default is false.
    
    Parameters:
    
    used - true to take link width into account when spacing connector pins, or false to ignore link width (the default).
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    isLinkWidthUsed(), setHorizontalNodeLinkOffset(double), setVerticalNodeLinkOffset(double), setHorizontalLinkOffset(double), setVerticalLinkOffset(double), getConnectorStyle()
  - isLinkWidthUsed
```
public final boolean isLinkWidthUsed()
```
    Returns true if the layout respects the width of links.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setLinkWidthUsed(boolean)
  - setMinStartSegmentLength
```
public final void setMinStartSegmentLength(double length)
```
    Sets the minimum length of the first segment of each link, that is, the segment that is incident to the "from" node.
    The default value is 0.
    
    Parameters:
    
    length - The minimum starting link segment.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getMinStartSegmentLength(), setMinEndSegmentLength(double)
  - getMinStartSegmentLength
```
public final double getMinStartSegmentLength()
```
    Returns the minimum length of the first segment of each link, that is, the segment that is incident to the "from" node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setMinStartSegmentLength(double)
  - setMinEndSegmentLength
```
public final void setMinEndSegmentLength(double length)
```
    Sets the minimum length of the last segment of each link, that is, the segment that is incident to the "to" node.
    The default value is 0.
    
    Parameters:
    
    length - The minimum ending link segment.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getMinEndSegmentLength(), setMinStartSegmentLength(double)
  - getMinEndSegmentLength
```
public final double getMinEndSegmentLength()
```
    Returns the minimum length of the last segment of each link, that is, the segment that is incident to the "to" node.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setMinEndSegmentLength(double)
  - 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.
    If a position is specified, the layout algorithm places the graph such that the specified point is the upper-left corner. If no position is specified, in incremental mode the layout algorithm places the graph close to its previous position before layout started, and in nonincremental mode it places the graph so that (0, 0) is the upper-left corner.
    
    The default value is null.
    
    Parameters:
    
    point - The position.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    getPosition(), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean), setIncrementalMode(boolean)
  - getPosition
```
public final IlvPoint getPosition()
```
    Returns the specified position of the layout.
    Returns null if no position was specified. 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), IlvGraphLayout.setLayoutOfConnectedComponentsEnabled(boolean)
  - setLinkPriority
```
public final void setLinkPriority(Object link,
                                  float priority)
```
    Sets the priority of a link. The layout algorithm tries to place the links in such a way that the majority of the links are short and point in the same direction. However, this is not always possible for all links. Low priority links are more likely to be longer or point in the opposite direction than the high priority links. The link priority should be smaller than 10000.
    
    Parameters:
    
    link - The link.
    
    priority - The link priority value, a number up to 10000.
    
    See Also:
    
    getLinkPriority(Object)
  - getLinkPriority
```
public final float getLinkPriority(Object link)
```
    Returns the priority of a link.
    
    Parameters:
    
    link - The link instance.
    
    Returns:
    
    The priority of the link. Low priority links are more likely to be longer or to point in the opposite direction to the high-priority links.
    
    See Also:
    
    setLinkPriority(Object, float)
  - setFromPortIndex
```
public final void setFromPortIndex(Object link,
                                   int portIndex)
```
    Sets the port index of a link at the "from" side. This allows you to specify the relative ports of the links on the node border. Using relative ports is a way to specify the relative order of how the links connect to the "from" node. The specification is only used if the free origin point mode is used for the link.
    Port numbers are between 0 and n - 1, where n is the number of ports at the node side where the link is connected. Links with an unspecified or negative port index are connected on the node border according to the global connector style. A link with a specified port index i is connected at the ith relative port, and the connector pins of ports are evenly spaced on the corresponding node border.
    
    Parameters:
    
    link - The link.
    
    portIndex - The relative port index starting from 0.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getFromPortIndex(Object), setToPortIndex(Object, int), setFromPortSide(Object, int), setNumberOfPorts(Object, int, int), setConnectorStyle(int), setGlobalOriginPointMode(int), setOriginPointMode(Object, int)
  - getFromPortIndex
```
public int getFromPortIndex(Object link)
```
    Returns the port index of a link at the "from" side. Returns -1 if the port index is unspecified.
    
    Parameters:
    
    link - The link instance.
    
    Returns:
    
    The port index of the specified link at the "from" side, or -1 if the port index is unspecified.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortIndex(Object, int)
  - setToPortIndex
```
public final void setToPortIndex(Object link,
                                 int portIndex)
```
    Sets the port index of a link at the "to" side. This allows you to specify the relative ports of the links on the node border. Using the relative ports is a way to specify the relative order of how the links connect to the "to" node. The specification is only used if the free destination point mode is used for the link.
    Port numbers are between 0 and n - 1, where n is the number of ports at the node side where the link is connected. Links with an unspecified or negative port index are connected on the node border according to the global connector style. A link with specified port index i is connected at the ith relative port, and the connector pins of ports are evenly spaced on the corresponding node border.
    
    Parameters:
    
    link - The link.
    
    portIndex - The relative port index starting from 0.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getToPortIndex(Object), setFromPortIndex(Object, int), setToPortSide(Object, int), setNumberOfPorts(Object, int, int), setConnectorStyle(int), setGlobalDestinationPointMode(int), setDestinationPointMode(Object, int)
  - getToPortIndex
```
public int getToPortIndex(Object link)
```
    Returns the port index of a link at the "to" side. Returns -1 if the port index is unspecified.
    
    Parameters:
    
    link - The link instance.
    
    Returns:
    
    The port index of the specified link at the "to" side, or -1 if the port index is unspecified.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setToPortIndex(Object, int)
  - setFromPortSide
```
public final void setFromPortSide(Object link,
                                  int side)
```
    Sets the port side of a link at the "from" side. This allows you to specify at which side of the node the starting point of the link is connected.
    Possible values for the side parameter are EAST, WEST, NORTH, SOUTH, and the default UNSPECIFIED.
    If a port side is unspecified, the link can connect to any border side of the node. Otherwise, the link connects only to the specified node border.
    
    Parameters:
    
    link - The link.
    
    side - The side of the node from which the link is connected.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getFromPortSide(Object), setToPortSide(Object, int), setSelfLinkFromPortSide(int), setFromPortIndex(Object, int), setConnectorStyle(int)
  - getFromPortSide
```
public int getFromPortSide(Object link)
```
    Returns the port side of a link at the "from" side.
    
    Parameters:
    
    link - The link instance.
    
    Returns:
    
    The port side of the specified link at the "from" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setFromPortSide(Object, int)
  - setToPortSide
```
public final void setToPortSide(Object link,
                                int side)
```
    Sets the port side of a link at the "to" side. This allows you to specify at which side of the node the end point of the link is connected.
    Possible values for the side parameter are EAST, WEST, NORTH, SOUTH, and the default UNSPECIFIED.
    If a port side is unspecified, the link can connect to any border side of the node. Otherwise, the link connects only to the specified node border.
    
    Parameters:
    
    link - The link.
    
    side - The side of the node to which the link is connected.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getToPortSide(Object), setFromPortSide(Object, int), setSelfLinkToPortSide(int), setToPortIndex(Object, int), setConnectorStyle(int)
  - getToPortSide
```
public int getToPortSide(Object link)
```
    Returns the port side of a link at the "to" side.
    
    Parameters:
    
    link - The link instance.
    
    Returns:
    
    The port side of the specified link at the "to" side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setToPortSide(Object, int)
  - setSelfLinkFromPortSide
```
public final void setSelfLinkFromPortSide(int side)
```
    Sets the default port side of a self-link at the "from" side. Self-links are links that start and end at the same node. This is used as port side for those self-links that have no explicit port side specification at the "from" side. It specifies at which side of the node the starting point of the self-link is connected.
    Possible values for the side parameter are EAST, WEST, NORTH, SOUTH. The default value is SOUTH.
    
    Parameters:
    
    side - The side of the node to which the self-link is connected.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getSelfLinkFromPortSide(), setSelfLinkToPortSide(int), setFromPortSide(Object, int)
  - getSelfLinkFromPortSide
```
public final int getSelfLinkFromPortSide()
```
    Returns the default port side of a self-link at the "from" side. Self-links are links that start and end at the same node. This is used as port side for those self-links that have no explicit port side specification at the "from" side. It specifies at which side of the node the starting point of the self-link is connected.
    
    Returns:
    
    The default port side of a self-link at the "from" side.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setSelfLinkFromPortSide(int), setFromPortSide(Object, int)
  - setSelfLinkToPortSide
```
public final void setSelfLinkToPortSide(int side)
```
    Sets the default port side of a self-link at the "to" side. Self-links are links that start and end at the same node. This is used as port side for those self-links that have no explicit port side specification at the "to" side. It specifies at which side of the node the end point of the self-link is connected.
    Possible values for the side parameter are EAST, WEST, NORTH, SOUTH. The default value is WEST.
    
    Parameters:
    
    side - The side of the node to which the self-link is connected.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getSelfLinkToPortSide(), setSelfLinkFromPortSide(int), setToPortSide(Object, int)
  - getSelfLinkToPortSide
```
public final int getSelfLinkToPortSide()
```
    Returns the default port side of a self-link at the "to" side. Self-links are links that start and end at the same node. This is used as port side for those self-links that have no explicit port side specification at the "to" side. It specifies at which side of the node the end point of the self-link is connected.
    
    Returns:
    
    The default port side of a self-link at the "to" side.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setSelfLinkToPortSide(int), setToPortSide(Object, int)
  - setSelfLinksSameSideNested
```
public final void setSelfLinksSameSideNested(boolean flag)
```
    Sets whether self-links that attach the same side of a node are nested. If multiple self-links attach the same side of a node and they are not nested, they are routed next to each other. If they are nested, they are routed link a multilink bundle.
    This is an expert option. It is enabled by default.
    
    Parameters:
    
    flag - true to enable the nesting of self-links or false to disable it.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    isSelfLinksSameSideNested()
  - isSelfLinksSameSideNested
```
public final boolean isSelfLinksSameSideNested()
```
    Returns true if self-links that attach the same side of a node are nested.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setSelfLinksSameSideNested(boolean)
  - setNumberOfPorts
```
public final void setNumberOfPorts(Object node,
                                   int side,
                                   int numberOfPorts)
```
    Sets the number of relative ports of a node on a given side. Possible values for the side parameter are EAST, WEST, NORTH, and SOUTH.
    Using the relative ports is a way to specify the relative order of how the links connect to the node. The ports of a node side can be considered as connector pins that are evenly spaced on the node border. Links can connect to specific pins by setting the "from" port index or the "to" port index of the link.
    
    If the "from" port index or the "to" port index of any link connecting to the node is greater than the specified number of ports of this node, the number of ports is automatically adjusted.
    
    Parameters:
    
    node - The node.
    
    side - The side of the node for the ports.
    
    numberOfPorts - The number of relative ports.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    getNumberOfPorts(Object, int), setFromPortIndex(Object, int), setToPortIndex(Object, int)
  - getNumberOfPorts
```
public int getNumberOfPorts(Object node,
                            int side)
```
    Returns the specified number of relative ports of a node on the specified side. Possible values for the side parameter are EAST, WEST, NORTH, SOUTH. Returns -1 if the number of ports is unspecified.
    
    Parameters:
    
    node - The node.
    
    side - The side of the node.
    
    Returns:
    
    The specified number of relative ports of the specified node on the specified side.
    
    Since:
    
    JViews 3.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), setFromPortIndex(Object, int), setToPortIndex(Object, int)
  - setEastNumberOfPorts
```
public final void setEastNumberOfPorts(Object node,
                                       int numberOfPorts)
```
    Sets the number of relative ports on the east side of a node.
    
    Parameters:
    
    node - The node.
    
    numberOfPorts - The number of relative ports.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), getEastNumberOfPorts(Object)
  - getEastNumberOfPorts
```
public final int getEastNumberOfPorts(Object node)
```
    Returns the number of relative ports on the east side of a node. The method returns -1 if the number of ports is unspecified.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The number of relative ports on the east side of the specified node, or -1 if the number is unspecified.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), setEastNumberOfPorts(Object, int)
  - setWestNumberOfPorts
```
public final void setWestNumberOfPorts(Object node,
                                       int numberOfPorts)
```
    Sets the number of relative ports on the west side of a node.
    
    Parameters:
    
    node - The node.
    
    numberOfPorts - The number of relative ports.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), getWestNumberOfPorts(Object)
  - getWestNumberOfPorts
```
public final int getWestNumberOfPorts(Object node)
```
    Returns the number of relative ports on the west side of a node. The method returns -1 if the number of ports is unspecified.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The number of relative ports on the west side of the specified node, or -1 if the number is unspecified.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), setWestNumberOfPorts(Object, int)
  - setNorthNumberOfPorts
```
public final void setNorthNumberOfPorts(Object node,
                                        int numberOfPorts)
```
    Sets the number of relative ports on the north side of a node.
    
    Parameters:
    
    node - The node.
    
    numberOfPorts - The number of relative ports.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), getNorthNumberOfPorts(Object)
  - getNorthNumberOfPorts
```
public final int getNorthNumberOfPorts(Object node)
```
    Returns the number of relative ports on the north side of a node. The method returns -1 if the number of ports is unspecified.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The number of relative ports on the north side of the node, or -1 if the number is unspecified.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), setNorthNumberOfPorts(Object, int)
  - setSouthNumberOfPorts
```
public final void setSouthNumberOfPorts(Object node,
                                        int numberOfPorts)
```
    Sets the number of relative ports on the south side of a node.
    
    Parameters:
    
    node - The node.
    
    numberOfPorts - The number of relative ports.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), getSouthNumberOfPorts(Object)
  - getSouthNumberOfPorts
```
public final int getSouthNumberOfPorts(Object node)
```
    Returns the number of relative ports on the south side of a node. The method returns -1 if the number of ports is unspecified.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The number of relative ports on the south side of the specified node, or -1 if the number is unspecified.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfPorts(Object, int, int), setSouthNumberOfPorts(Object, int)
  - setSpecNodeLevelIndex
```
public final void setSpecNodeLevelIndex(Object node,
                                        int index)
```
    Sets the index of the specified level for a node. Nodes are organized in horizontal or vertical levels numbered from 0 to n. If the link flow direction is from top to bottom, the nodes with level index 0 are placed in the topmost level, and the nodes with higher level indexes are placed in the levels below. If the link flow direction is from left to right, the nodes with level index 0 are placed in the leftmost level, and the nodes with higher level indexes are placed in the levels farther to the right.
    This method allows you to specify the level where a node should be placed. If the level index of a node is set to a negative value, it means that there is no preference for the level of the node. In this case, the layout algorithm calculates an appropriate level index.
    
    The default level index of a node is -1; that is, the layout algorithm determines the appropriate level automatically.
    
    Note that specified level indexes can cause conflicts to constraints that are solved depending on the constraint priorities. The index specification or some of the constraints may be ignored in this case. Furthermore, note that if the generic connected component layout mechanism of the IlvGraphLayout base class is enabled, each connected component uses its own level structure. If it is disabled, there is only one global level structure.
    
    Parameters:
    
    node - The node.
    
    index - The level index.
    
    See Also:
    
    getFlowDirection(), getSpecNodeLevelIndex(Object), addConstraint(IlvHierarchicalConstraint), supportsLayoutOfConnectedComponents()
  - getSpecNodeLevelIndex
```
public final int getSpecNodeLevelIndex(Object node)
```
    Returns the index of the specified level for a node. If no level index is specified for the node, it returns a negative number.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The index of the specified level for the given node or a negative number if no level is specified.
    
    See Also:
    
    setSpecNodeLevelIndex(Object, int), getCalcNodeLevelIndex(Object)
  - getCalcNodeLevelIndex
```
public final int getCalcNodeLevelIndex(Object node)
```
    Returns the calculated level index of a node after performing a layout. If there was no previous call of performLayout, it returns -1. Nodes are organized in horizontal or vertical levels numbered from 0 to n. If the link flow direction is from top to bottom, the nodes with level index 0 are placed in the topmost level, and the nodes with higher level indexes are placed in the levels below. If the link flow direction is from left to right, the nodes with level index 0 are placed in the leftmost level, and the nodes with higher level indexes are placed in the levels more to the right.
    Note the difference between calculated and specified level index: The layout algorithm assigns level indexes to all nodes even if no level index is specified. Therefore, the method getSpecNodeLevelIndex(Object) returns -1 for nodes that have no level index specified, but the method getCalcNodeLevelIndex(Object) returns a nonnegative number, that is, the real index of the level after layout.
    
    Note that if the generic connected component layout mechanism of the IlvGraphLayout base class is enabled, each connected component uses its own level structure. If it is disabled, there is only one global level structure.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The calculated level index of the node, or -1 if no layout has been performed.
    
    See Also:
    
    getFlowDirection(), getSpecNodeLevelIndex(Object), detach(), IlvGraphLayout.performLayout(), supportsLayoutOfConnectedComponents()
  - setSpecNodePositionIndex
```
public final void setSpecNodePositionIndex(Object node,
                                           int index)
```
    Sets the index of the specified position of a node within a level. Nodes are organized in horizontal or vertical levels. Within each level, the nodes are placed sequentially at relative positions numbered from 0 to n. If the link flow direction is from top to bottom, the node with position index 0 is placed leftmost within its level, and the nodes with higher position indexes are placed farther to the right. If the link flow direction is from right to left, the node with position index 0 is placed topmost within its level, and the nodes with higher position indexes are placed below.
    This method allows you to specify the relative position where a node should be placed within its level. If the position index of a node is set to a negative value, it means that there is no preference for the position of the node. In this case, the layout algorithm calculates an appropriate position index. If the position index is higher than the number of nodes in the level, the position index is ignored. If two nodes of the same level have the same position index, one of the indexes is ignored. The layout algorithm calculates an appropriate position index for the nodes that have inappropriate or conflicting position indexes.
    
    The default position index of a node is -1; that is, the layout algorithm determines the appropriate position automatically.
    
    Note that specified position indexes can cause conflicts to constraints that are solved depending on the constraint priorities. The index specification or some of the constraints may be ignored in this case. Furthermore, note that if the generic connected component layout mechanism of the IlvGraphLayout base class is enabled, each connected component uses its own level structure. If it is disabled, there is only one global level structure.
    
    Parameters:
    
    node - The node.
    
    index - The position index within a level, starting from 0.
    
    See Also:
    
    getFlowDirection(), getSpecNodePositionIndex(Object), addConstraint(IlvHierarchicalConstraint), supportsLayoutOfConnectedComponents()
  - getSpecNodePositionIndex
```
public final int getSpecNodePositionIndex(Object node)
```
    Returns the index of the specified position of a node within a level. If no position index is specified for the node, this method returns a negative number.
    
    Parameters:
    
    node - The node instance.
    
    Returns:
    
    The index of the specified position of the node within a level, or a negative value if no index is specified.
    
    See Also:
    
    setSpecNodePositionIndex(Object, int), getCalcNodePositionIndex(Object)
  - getCalcNodePositionIndex
```
public final int getCalcNodePositionIndex(Object node)
```
    Returns the calculated index of the node position within a level after performing a layout. If there was no previous call of performLayout, it returns -1. Nodes are organized in horizontal or vertical levels. Within each level, the nodes are placed sequentially at relative positions numbered from 0 to n. If the link flow direction is from top to bottom, the node with position index 0 is placed leftmost within its level, and the nodes with higher position indexes are placed farther to the right. If the link flow direction is from right to left, the node with position index 0 is placed topmost within its level, and the nodes with higher position indexes are placed below.
    Note the difference between calculated and specified position index: The layout algorithm assigns position indexes to all nodes, even if no position index is specified. Therefore, the method getSpecNodePositionIndex(Object) returns -1 for nodes that have no position index specified, but the method getCalcNodePositionIndex(Object) returns a nonnegative number, that is, the real index of the position within its level after layout.
    
    Note, if the generic connected component layout mechanism of the IlvGraphLayout base class is enabled, each connected component uses its own level structure. If it is disabled, there is only one global level structure.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The calculated position index of the node, or -1 if no layout has been performed.
    
    See Also:
    
    getFlowDirection(), getSpecNodePositionIndex(Object), detach(), IlvGraphLayout.performLayout(), supportsLayoutOfConnectedComponents()
  - setGlobalOriginPointMode
```
public final void setGlobalOriginPointMode(int mode)
```
    Sets the global mode for the connection point of the links on the origin nodes. Valid values are:
    - FREE_MODE - For all links, the layout is free to choose the appropriate position of the connection point on the origin node, except for "pinned" connection points (see IlvGraphModel.hasPinnedConnectionPoint(Object, boolean)). The choice can further be influenced by specifying the side and the port index of the links.
    - FIXED_MODE - For all links, the layout must keep the current position of the connection point on the origin node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.
      The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.
      
      Note that if the mode is fixed, specifications of the port index of links at the "from" side are ignored.
    - MIXED_MODE - Each link can have a different mode for the connection point on the origin node. The mode of each individual link can be set by the method setOriginPointMode(Object, int).
    Unless the global mode is MIXED_MODE, the connection points on the origin node have the same mode for all the links.
    
    The default value is FREE_MODE.
    Parameters:
    
    mode - The global mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getGlobalOriginPointMode(), setFromPortIndex(Object, int), IlvPinLinkConnector
  - getGlobalOriginPointMode
```
public final int getGlobalOriginPointMode()
```
    Returns the global mode for the connection points of the links on the origin nodes.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalOriginPointMode(int)
  - setGlobalDestinationPointMode
```
public final void setGlobalDestinationPointMode(int mode)
```
    Sets the global mode for the connection point of the links on the destination nodes. Valid values are:
    - FREE_MODE - For all links, the layout is free to choose the appropriate position of the connection point on the destination node, except for "pinned" connection points (see IlvGraphModel.hasPinnedConnectionPoint(Object, boolean)). The choice can further be influenced by specifying the side and the port index of the links.
    - FIXED_MODE - For all links, the layout must keep the current position of the connection point on the destination node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.
      The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.
      
      Note that if the mode is fixed, specifications of the port index of links at the "to" side are ignored.
    - MIXED_MODE - Each link can have a different mode for the connection point on the destination node. The mode of each individual link can be set by the method setDestinationPointMode(Object, int).
    Unless the global mode is MIXED_MODE, the connection points on the destination node have the same mode for all the links.
    
    The default value is FREE_MODE.
    Parameters:
    
    mode - The global mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getGlobalDestinationPointMode(), setToPortIndex(Object, int), IlvPinLinkConnector
  - getGlobalDestinationPointMode
```
public final int getGlobalDestinationPointMode()
```
    Returns the global mode for the connection points of the links on the destination nodes.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalDestinationPointMode(int)
  - setOriginPointMode
```
public final void setOriginPointMode(Object link,
                                     int mode)
```
    Sets the mode for the connection point on an individual link on the origin node. This mode is used only if the global "from" point mode is set to MIXED_MODE. Otherwise, the connection points on the origin nodes have, for all the links, the mode that is specified as the global origin point mode.
    Valid values are:
    - FREE_MODE - The layout is free to choose, for this link, the appropriate position of the connection point on the origin node, except for "pinned" connection points (see IlvGraphModel.hasPinnedConnectionPoint(Object, boolean)). The choice can further be influenced by specifying the side and the port index of the links.
    - FIXED_MODE - The layout must keep, for this link, the current position of the connection point on the origin node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.
      The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.
      
      Note that if the mode is fixed, specifications of the port index of links at the "from" side are ignored.
    The default value is FREE_MODE.
    Parameters:
    
    link - The link.
    
    mode - The mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getOriginPointMode(Object), setGlobalOriginPointMode(int), setFromPortIndex(Object, int)
  - getOriginPointMode
```
public int getOriginPointMode(Object link)
```
    Returns the origin point mode of an individual link.
    
    Parameters:
    
    link - The link.
    
    Returns:
    
    The mode for the connection point of an individual link on the origin node.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalOriginPointMode(int), setOriginPointMode(Object, int)
  - setDestinationPointMode
```
public final void setDestinationPointMode(Object link,
                                          int mode)
```
    Sets the mode for the connection point of an individual link on the destination node. This mode is used only if the global "from" point mode is set to MIXED_MODE. Otherwise, the connection points on the destination nodes have, for all the links, the mode that is specified as the global destination point mode.
    Valid values are:
    - FREE_MODE - The layout is free to choose, for this link, the appropriate position of the connection point on the destination node, except for "pinned" connection points (see IlvGraphModel.hasPinnedConnectionPoint(Object, boolean)). The choice can further be influenced by specifying the side and the port index of the links.
    - FIXED_MODE - The layout must keep, for this link, the current position of the connection point on the destination node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.
      The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.
      
      Note that if the mode is fixed, specifications of the port index of links at the "to" side are ignored.
    The default value is FREE_MODE.
    Parameters:
    
    link - The link.
    
    mode - The mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getDestinationPointMode(Object), setGlobalDestinationPointMode(int), setToPortIndex(Object, int)
  - getDestinationPointMode
```
public int getDestinationPointMode(Object link)
```
    Returns the destination point mode of an individual link.
    
    Parameters:
    
    link - The link.
    
    Returns:
    
    The mode for the connection point of an individual link on the destination node.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalDestinationPointMode(int), setDestinationPointMode(Object, int)
  - setIncrementalMode
```
public final void setIncrementalMode(boolean enable)
```
    Sets whether the incremental layout mode is enabled. If the argument is true, the layout respects the current coordinates of nodes and links, and it tries to create a layout with similar positions. Depending on the incremental node movement mode, the layout may need to shift all nodes to optimize the space usage, but the shifting does not change the relative order of the nodes and links, so that the diagram after an incremental layout looks very similar to the previous diagram.
    The levels are arranged based on the current coordinates of the nodes. Thus, the specified node level and position indexes are ignored during incremental layout.
    
    The incremental mode is disabled by default.
    
    Parameters:
    
    enable - true to enable the incremental layout mode, or false to disable it.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isIncrementalMode(), setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int), markForIncremental(Object), setSpecNodeLevelIndex(Object, int), setSpecNodePositionIndex(Object, int)
  - isIncrementalMode
```
public final boolean isIncrementalMode()
```
    Returns true if the incremental mode is enabled.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalMode(boolean)
  - markForIncremental
```
public final void markForIncremental(Object nodeOrLink)
```
    Marks the input node or link to be repositioned with the next call of IlvGraphLayout.performLayout() if incremental mode is enabled. Normally, the incremental layout tries to preserve the relative order of nodes and links. By setting a mark on a node, the level assignment and relative position of this node will be calculated from scratch. By setting a mark on a link, this link will be rerouted completely by the next layout. The mark is transient, that is, it is automatically cleared after an incremental layout is done.
    
    Parameters:
    
    nodeOrLink - The input node or link to mark.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalMode(boolean), IlvGraphLayout.performLayout()
  - setCrossingReductionDuringIncremental
```
public final void setCrossingReductionDuringIncremental(boolean enable)
```
    Sets whether crossing reduction during incremental layout is enabled. This option has no effect if the incremental mode is disabled. If the incremental mode is enabled and the argument is false, the layout preserves the relative order of the nodes and the links within the levels. If the argument is true, the layout preserves the level structure but reorders the nodes within the levels to avoid link crossings.
    It is disabled by default.
    
    Parameters:
    
    enable - true to enable crossing reduction during incremental layout, or false to disable it.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isCrossingReductionDuringIncremental(), setIncrementalMode(boolean), IlvGraphLayout.performLayout()
  - isCrossingReductionDuringIncremental
```
public final boolean isCrossingReductionDuringIncremental()
```
    Returns true if crossing reduction during incremental layout is enabled.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setCrossingReductionDuringIncremental(boolean)
  - setLongLinkCrossingReductionDuringIncremental
```
public final void setLongLinkCrossingReductionDuringIncremental(boolean enable)
```
    Sets whether the handling of long links for crossing reduction during incremental layout is enabled. This option has no effect if the incremental mode is disabled. If the incremental mode is enabled and the argument is false, the layout preserves the relative order of the nodes and the links within the levels. If the argument is true, the layout preserves the level structure and the relative order of the nodes, but reroutes the links in order to avoid link crossings. This means a long link may cross a level between a different pair of nodes than before layout.
    It is disabled by default.
    
    Parameters:
    
    enable - true to enable long link crossing reduction during incremental layout, or false to disable it.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isLongLinkCrossingReductionDuringIncremental(), setIncrementalMode(boolean), IlvGraphLayout.performLayout()
  - isLongLinkCrossingReductionDuringIncremental
```
public final boolean isLongLinkCrossingReductionDuringIncremental()
```
    Returns true if the handling of long links by the crossing reduction during incremental layout is enabled.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setLongLinkCrossingReductionDuringIncremental(boolean)
  - setIncrementalAbsoluteLevelPositioning
```
public final void setIncrementalAbsoluteLevelPositioning(boolean enable)
```
    Sets whether it is enabled to place nodes within the level to absolute positions that are close to the previous positions during incremental layout. This option has no effect if the incremental mode is disabled. It has also no effect if crossing reduction during incremental layout is enabled.
    If the incremental mode is enabled and crossing reduction during incremental layout is disabled, the layout arranges the nodes such that the relative order of the nodes within each level is preserved. If this parameter is set to false, nodes may be placed at absolute positions far from the previous positions, even though their relative order does not change, because the main objective of the algorithm is to produce a balanced layout.
    
    To help the user preserve a mental map of the graph, this parameter should be set to true. In this case, the nodes are placed closer to their previous positions, even though this may result in a less balanced layout.
    
    The freedom of incremental level positioning can be controlled by the tendency to preserve the previous node position (see setIncrementalAbsoluteLevelPositionTendency(double)) and the range that is considered to be close enough to the previous node position setIncrementalAbsoluteLevelPositionRange(double)).
    
    It is enabled by default.
    
    Parameters:
    
    enable - true to enable close repositioning of nodes during incremental layout, at the expense of completely balancing the layout. A value of false will give priority to balancing the layout regardless of node displacements.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isIncrementalAbsoluteLevelPositioning(), setIncrementalMode(boolean), setCrossingReductionDuringIncremental(boolean), IlvGraphLayout.performLayout()
  - isIncrementalAbsoluteLevelPositioning
```
public final boolean isIncrementalAbsoluteLevelPositioning()
```
    Returns true if the algorithm tries to place the nodes within the level to absolute positions that are close to the previous positions during incremental layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalAbsoluteLevelPositioning(boolean)
  - setIncrementalAbsoluteLevelPositionTendency
```
public final void setIncrementalAbsoluteLevelPositionTendency(double percentage)
```
    Sets the percentage how much the layout algorithm tries to place nodes to absolute positions within the level that are close to the previous positions during incremental layout. This option has an effect only if the incremental absolute level positioning is used.
    In nonincremental mode, nodes are placed within the level in order to balance the layout. If the incremental absolute level positioning is used, nodes should be placed close to their previous positions, but the layout should also be balanced. Both criteria compete with each other. The position tendency influences how the competing criteria are resolved. A high position tendency has the effect that the nodes stay closer to their previous positions, and a low position tendency has the effect that the nodes stay closer to the balanced position. Passing the position tendency 0 has basically the same effect as disabling the incremental absolute level positioning.
    
    The input value is a percentage between 0 and 100. The default value is 70 percent.
    
    Parameters:
    
    percentage - The percentage value for the absolute level position tendency, a number between 0 and 100.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    getIncrementalAbsoluteLevelPositionTendency(), setIncrementalAbsoluteLevelPositioning(boolean), setIncrementalMode(boolean), setCrossingReductionDuringIncremental(boolean), IlvGraphLayout.performLayout()
  - getIncrementalAbsoluteLevelPositionTendency
```
public final double getIncrementalAbsoluteLevelPositionTendency()
```
    Returns the percentage of how much the layout algorithm tries to place nodes to absolute positions within the level that are close to the previous positions during incremental layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalAbsoluteLevelPositionTendency(double)
  - setIncrementalAbsoluteLevelPositionRange
```
public final void setIncrementalAbsoluteLevelPositionRange(double range)
```
    Sets the range that is considered very close to the previous node position. This option has an effect only if the incremental absolute level positioning is used.
    In nonincremental mode, nodes are placed within the level in order to balance the layout. If the incremental absolute level positioning is used, nodes should be placed close to their previous positions, but the layout should also be balanced. Both criteria compete with each other. The position range influences how the competing criteria are resolved. If a node is placed within this range to its previous position, the balance criteria is used to determine its position. If the node is placed farther away from its previous position, the position tendency is used to determine its position.
    
    A node that is placed within the incremental position range to its previous position is placed at the best balanced position. This avoids having the balance of nodes that are already close to the previous position being disturbed by an additional tendency towards the previous position.
    
    The default value is 20.
    
    Parameters:
    
    range - The value of the absolute level position range.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    getIncrementalAbsoluteLevelPositionRange(), setIncrementalAbsoluteLevelPositioning(boolean), setIncrementalMode(boolean), setCrossingReductionDuringIncremental(boolean), IlvGraphLayout.performLayout()
  - getIncrementalAbsoluteLevelPositionRange
```
public final double getIncrementalAbsoluteLevelPositionRange()
```
    Returns the range that is considered very close to the previous node position. This value is used by the incremental absolute level positioning.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalAbsoluteLevelPositionRange(double)
  - setIncrementalNodeBoxForExpand
```
public final void setIncrementalNodeBoxForExpand(Object expandedNode,
                                                 IlvRect rect)
```
    Sets the effective bounding rectangle of an expanded node during incremental layout.
    In this context, we call expand any interactive operation that changes the size of the node to make it very large while preserving the center position of the node. The typical purpose of an expand operation is to change the graphical representation of the node to show more details in the inner of the node. For instance, an expand operation may show a subgraph in the inner of the node. Often, an incremental re-layout is desired after an expand operation.
    
    The challenge of the re-layout after an expand operation consists of the fact that the node may become so large that it overlaps many nodes. This may yield undesired effects during incremental layout, because incremental layout is unable to determine the level structure from the coordinates of the nodes if some node overlaps many other nodes completely.
    
    To facilitate the incremental layout, the old bounding box of the expanded node, as it was before the expand operation, must be specified as the effective bounding box. This helps the incremental layout determine the proper level structure.
    
    The effective bounding box has no effect if incremental layout is disabled, or if the node is marked for incremental recalculation. The effective bounding box is transient, that is, it is automatically removed after each successful layout and not stored into .ivl files.
    
    Parameters:
    
    expandedNode - The expanded node.
    
    rect - The effective bounding rectangle.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    getIncrementalNodeBoxForExpand(Object), setIncrementalMode(boolean), markForIncremental(Object), IlvGraphLayout.performLayout()
  - getIncrementalNodeBoxForExpand
```
public final IlvRect getIncrementalNodeBoxForExpand(Object expandedNode)
```
    Returns the effective bounding rectangle of an expanded node during incremental layout. Note that this parameter is transient, that is, it is automatically removed after each successful layout and returns null in this case. It returns a meaningful value only when the effective bounding box was set but layout was not yet performed.
    
    Parameters:
    
    expandedNode - The expanded node.
    
    Returns:
    
    The effective bounding rectangle.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setIncrementalNodeBoxForExpand(Object, IlvRect)
  - setGlobalIncrementalNodeMovementMode
```
public final void setGlobalIncrementalNodeMovementMode(int mode)
```
    Sets the node movement mode used during incremental layout. This option has no effect if the incremental mode is disabled. Valid values are:
    - FREE_MODE - The incremental layout preserves the relative order of nodes but does not preserve the exact position of nodes. It may move the nodes a little bit to optimize the space usage. The shifting does not change the level structure of the graph. If crossing reduction is disabled during incremental layout (see setCrossingReductionDuringIncremental(boolean)), the shifting also does not change the order of the nodes within the levels.
    - FIXED_IN_X_MODE - The incremental layout preserves the relative order of nodes and keeps the nodes fixed in the x direction. The nodes may shift in the y direction.
    - FIXED_IN_Y_MODE - The incremental layout preserves the relative order of nodes and keeps the nodes fixed in the y direction. The nodes may shift in the x direction.
    - FIXED_MODE - The nodes do not move at all during incremental layout. Only nodes that are marked for incremental repositioning will be moved, and links are rerouted.
    - MIXED_MODE - Each node that is not marked for incremental can have a different mode. The mode of each individual node can be set by the method setIncrementalNodeMovementMode(Object, int). Mixing fixed and free nodes should only be done in exceptional cases, because it may create overlaps or a messy arrangement.
    Nodes that are marked for incremental are placed in a nonincremental way without respecting the previous position. The incremental movement mode has no effect for these nodes. Unless the global mode is MIXED_MODE, all nodes that are not marked for incremental are placed according to the same mode.
    
    The default mode is FREE_MODE.
    
    If the incremental mode is enabled and nodes are fixed in the x or y direction, it works well if the graph has a coarsely level structure (for example, if it was created by a previous layout in free mode or in nonincremental mode) but it may create overlaps or a messy arrangement otherwise. Fixing nodes has several consequences: The spacing options are obeyed only if there is enough space between the fixed nodes. The specified position of the layout is not obeyed, because it would require shifting the fixed nodes. The crossing reduction during incremental layout has no effect (see isCrossingReductionDuringIncremental()). However, you can decide whether to enable the crossing reduction of long links (see isLongLinkCrossingReductionDuringIncremental()). If the long link crossing reduction is enabled, it will rearrange the long links that span several levels to avoid crossings.
    
    Furthermore, note that if the generic connected component layout mechanism of the IlvGraphLayout base class is enabled, it will move nodes even if they are specified as fixed. Therefore, it is recommended disabling the generic connected component layout mechanism.
    Parameters:
    
    mode - The node movement mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getGlobalIncrementalNodeMovementMode(), setIncrementalNodeMovementMode(Object, int), setIncrementalMode(boolean), markForIncremental(Object), setHorizontalNodeOffset(double), setHorizontalLinkOffset(double), setHorizontalNodeLinkOffset(double), setVerticalNodeOffset(double), setVerticalLinkOffset(double), setVerticalNodeLinkOffset(double), setPosition(IlvPoint)
  - getGlobalIncrementalNodeMovementMode
```
public final int getGlobalIncrementalNodeMovementMode()
```
    Returns the node movement mode used during incremental layout. This option has no effect if the incremental mode is disabled.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int)
  - setIncrementalNodeMovementMode
```
public final void setIncrementalNodeMovementMode(Object node,
                                                 int mode)
```
    Sets the movement mode of an individual node used during incremental layout. This movement mode is used only if the incremental mode is enabled, the global movement mode is set to MIXED_MODE, and the node is not marked for incremental recalculation. If the global movement mode is not MIXED_MODE, all nodes have the mode that is specified as the global movement mode.
    Valid values are:
    - FREE_MODE - The incremental layout preserves the relative order of the node with respect to all other nodes (except those that are marked for incremental recalculation). It does not preserve the exact position. It may move the node a little bit to optimize the space usage. The shifting does not change the level structure of the graph. If the crossing reduction is disabled during incremental layout (see setCrossingReductionDuringIncremental(boolean)), the shifting also does not change the order of the node within the levels with respect to the other nodes.
    - FIXED_IN_X_MODE - The incremental layout preserves the relative order of the node with respect to all other nodes (except those that are marked for incremental recalculation), and it keeps the node fixed in the x direction. The node may shift in the y direction.
    - FIXED_IN_Y_MODE - The incremental layout preserves the relative order of the node with respect to all other nodes (except those that are marked for incremental recalculation), and it keeps the node fixed in the y direction. The nodes may shift in the x direction.
    - FIXED_MODE - The node does not move at all during incremental layout.
    The default mode is FREE_MODE.
    
    If the incremental mode is enabled and some nodes are fixed in the x or y direction, it often works well if the graph has a coarsely level structure (for example, if it was created by a previous layout in free mode or in nonincremental mode) but it may create overlaps or a messy arrangement otherwise, in particular if only few nodes are fixed and many nodes are free to move. Fixing nodes has several consequences: The spacing options are obeyed only if there is enough space between the fixed nodes. The specified position of the layout is not obeyed, because it would require shifting the fixed nodes. The crossing reduction during incremental layout has no effect (see isCrossingReductionDuringIncremental()). However, you can decide whether to enable the crossing reduction of long links (see isLongLinkCrossingReductionDuringIncremental()). If the long link crossing reduction is enabled, it will rearrange the long links that span several levels to avoid crossings.
    
    Furthermore, note that if the generic connected component layout mechanism of the IlvGraphLayout base class is enabled, it will move nodes even if they are specified as fixed. Therefore it is recommended disabling the generic connected component layout mechanism.
    Parameters:
    
    node - The node.
    
    mode - The movement mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), getIncrementalNodeMovementMode(Object), setIncrementalMode(boolean), markForIncremental(Object), setHorizontalNodeOffset(double), setHorizontalLinkOffset(double), setHorizontalNodeLinkOffset(double), setVerticalNodeOffset(double), setVerticalLinkOffset(double), setVerticalNodeLinkOffset(double), setPosition(IlvPoint)
  - getIncrementalNodeMovementMode
```
public final int getIncrementalNodeMovementMode(Object node)
```
    Returns the movement mode of an individual node used during incremental layout.
    
    Parameters:
    
    node - The node.
    
    Returns:
    
    The movement mode of an individual node used during incremental layout.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalIncrementalNodeMovementMode(int), setIncrementalNodeMovementMode(Object, int)
  - addConstraint
```
public final void addConstraint(IlvHierarchicalConstraint constraint)
```
    Adds a constraint for the hierarchical layout. Constraints can be used to force the nodes to be placed in a certain way relative to other nodes. For instance, you can force a node to be placed in the same level as another node, or you can force nodes to be no more than a specified number of levels apart.
    If many constraints are specified, it may happen that the constraints are contradicting (for instance, node A cannot be below node B and above node B at the same time). In this case, a constraint conflict resolution is automatically started. It takes the constraint priorities into account when deciding which constraints cannot be satisfied. The more conflicts, the more layout time is necessary. Therefore, it is recommended specifying constraints without obvious conflicts when possible.
    
    When the graph model gets detached, all constraints are removed.
    
    Parameters:
    
    constraint - The constraint to add.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvSameLevelConstraint, IlvLevelRangeConstraint, IlvRelativeLevelConstraint, IlvGroupSpreadConstraint, removeConstraint(IlvHierarchicalConstraint), getConstraints(), getNumberOfConstraints(), detach()
  - removeAllConstraints
```
public final void removeAllConstraints()
```
    Removes all the constraints from the hierarchical layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    addConstraint(IlvHierarchicalConstraint)
  - removeConstraint
```
public final void removeConstraint(IlvHierarchicalConstraint constraint)
```
    Removes the specified constraint from the hierarchical layout.
    
    Parameters:
    
    constraint - The constraint to be removed.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    addConstraint(IlvHierarchicalConstraint)
  - removeConstraint
```
public final void removeConstraint()
```
    Removes the constraint that was most recently added from the hierarchical layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    addConstraint(IlvHierarchicalConstraint)
  - getNumberOfConstraints
```
public final int getNumberOfConstraints()
```
    Returns the number of constraints that have been added to the hierarchical layout.
    
    Returns:
    
    The number of constraints that have been added to the hierarchical layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    addConstraint(IlvHierarchicalConstraint)
  - getConstraints
```
public final Enumeration getConstraints()
```
    Returns the constraints that have been added to the hierarchical layout. Note: during iteration, it is safe to remove the current constraint (that is, the constraint obtained by enumeration.nextElement()). However, it is unsafe to remove any other constraint from the layout during the iteration.
    
    Returns:
    
    The constraints that have been added to the hierarchical layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    addConstraint(IlvHierarchicalConstraint), removeConstraint(IlvHierarchicalConstraint)
  - validateConstraints
```
public final void validateConstraints()
```
    Performs a validation check for the constraints. If nodes are removed from the graph, the constraint manager may still contain constraints that are related to these nodes. These constraints merely waste memory. They are removed by the validation check.
    The validation check is automatically performed during layout. In the most cases, it is not necessary to call this method directly. Only in a memory-critical application may you want to perform the validation check explicitly, if you added many constraints and removed many constrained nodes from the graph without performing any layout.
    
    Do not confuse the validation check with the automatic constraint conflict resolution. The validation check removes constraints that no longer make sense in the current graph. After the validation check, there may still be conflicting constraints in the hierarchical layout. The constraint conflict resolution also happens automatically during layout. However, the resolution does not remove conflicting constraints from the layout. It only decides not to satisfy them.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    addConstraint(IlvHierarchicalConstraint), removeConstraint(IlvHierarchicalConstraint), IlvGraphLayout.performLayout()
  - getNumberOfNodeGroups
```
public int getNumberOfNodeGroups()
```
    Returns the number of node groups that occur in constraints that were added to the hierarchical layout.
    
    Returns:
    
    The number of node groups that occur in constraints that were added to the hierarchical layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvNodeGroup, addConstraint(IlvHierarchicalConstraint), getNodeGroups()
  - getNodeGroups
```
public Enumeration getNodeGroups()
```
    Returns the node groups that occur in constraints that were added to the hierarchical layout. Node groups can be shared by different constraints.
    
    Returns:
    
    The node groups that occur in constraints that were added to the hierarchical layout.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvNodeGroup, IlvLevelRangeConstraint, IlvRelativeLevelConstraint, IlvGroupSpreadConstraint, addConstraint(IlvHierarchicalConstraint), getNumberOfNodeGroups()
  - setPolylineLinkOverlapReductionEnabled
```
public final void setPolylineLinkOverlapReductionEnabled(boolean flag)
```
    Sets whether optimization of polyline links to avoid links overlapping large neighbor nodes is enabled. If this option is enabled, the algorithm introduces additional bends if polyline links are routed at a flat angle, to avoid overlapping large neighbor nodes. The option does not affect orthogonal links.
    If the graph has a huge number of links, it is recommended switching this optimization off, because it is very time-consuming.
    
    The optimization is enabled by default.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isPolylineLinkOverlapReductionEnabled()
  - isPolylineLinkOverlapReductionEnabled
```
public final boolean isPolylineLinkOverlapReductionEnabled()
```
    Returns true if the optimization of polyline links is enabled to avoid links overlapping large neighbor nodes.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setPolylineLinkOverlapReductionEnabled(boolean)
  - setMultiLinkOptimizationEnabled
```
public final void setMultiLinkOptimizationEnabled(boolean flag)
```
    Sets whether the optimization of overlapping multiple links is enabled. If you have multiple links between the same pair of directly neighbored nodes, and this option is disabled, it may happen that these links overlap. If the option is enabled and the link style of the links allow bend points, then additional bends are introduced to avoid those overlaps. The offset between these bends of the same multilink bundle can be controlled by setMultiLinkOptimizationOffset(double).
    The optimization is enabled by default.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    isMultiLinkOptimizationEnabled()
  - isMultiLinkOptimizationEnabled
```
public final boolean isMultiLinkOptimizationEnabled()
```
    Returns true if the optimization of overlapping multiple links is enabled.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setMultiLinkOptimizationEnabled(boolean)
  - setMultiLinkOptimizationOffset
```
public final void setMultiLinkOptimizationOffset(double offset)
```
    Sets the minimum distance between bends introduced by the optimization of overlapping multiple links. These are bends of links in the same bundle between nodes that are directly neighbored. These bends are shifted relative to each other by the multi link optimization offset unless the number of links times the offset exceeds the max spread value. In that case, the offset is limited by the max spread value.
    The default value is 10.
    
    Parameters:
    
    offset - The offset value.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getMultiLinkOptimizationOffset(), setMultiLinkOptimizationEnabled(boolean), setMultiLinkOptimizationMaxSpread(double)
  - getMultiLinkOptimizationOffset
```
public final double getMultiLinkOptimizationOffset()
```
    Returns the minimum distance between bends introduced by the optimization of overlapping multiple links. These are bends of links in the same bundle between nodes that are directly neighbored.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setMultiLinkOptimizationOffset(double), setMultiLinkOptimizationEnabled(boolean)
  - setMultiLinkOptimizationMaxSpread
```
public final void setMultiLinkOptimizationMaxSpread(double maxSpread)
```
    Sets the maximum spread width for the bends introduced by the optimization of overlapping multiple links. These are bends of links in the same bundle between nodes that are directly neighbored. These bends are shifted relative to each other by the multi link optimization offset unless the number of links times the offset exceeds the max spread value. In that case, the offset is limited by the max spread value.
    The default value is 50.
    
    Parameters:
    
    maxSpread - The maximum spread value.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    getMultiLinkOptimizationMaxSpread(), setMultiLinkOptimizationOffset(double), setMultiLinkOptimizationEnabled(boolean)
  - getMultiLinkOptimizationMaxSpread
```
public final double getMultiLinkOptimizationMaxSpread()
```
    Returns the maximum spread width for the bends introduced by the optimization of overlapping multiple links. These are bends of links in the same bundle between nodes that are directly neighbored.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setMultiLinkOptimizationMaxSpread(double), setMultiLinkOptimizationEnabled(boolean)
  - setNeighborLinksAligned
```
public final void setNeighborLinksAligned(boolean enable)
```
    Sets whether links between neighbor nodes of the same level are aligned so that they are strictly horizontal or vertical. For instance, in a top-down layout, the links between neighbor nodes of the same level can be drawn roughly horizontal while all other links are drawn roughly vertical. However, if one end node is larger than the other end node and both nodes are aligned at the top, the link between both would normally not be drawn strictly horizontal because it connects to the smaller node at a different y coordinate than to the larger node. (Reason: the y coordinate of the center of the nodes is different when they are aligned at the top and do not have the same size). In the orthogonal link style, the link would have a bend. If the alignment mode is enabled, these links between neighbor nodes are connected to the nodes so that they are strictly straight and have no bends. The connector style is ignored for these links.
    It is enabled by default.
    
    If neighbor links are not aligned and have the orthogonal style, the spacing between the link segments may be slightly smaller than the specified offset between links. If the incremental node movement mode is fixed, it is not always possible to create aligned links between neighbor nodes, due to the fixed positions of the nodes.
    
    Parameters:
    
    enable - true to enable alignment of neighbor nodes regardless of link style, or false to disable the strict alignment option.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    isNeighborLinksAligned(), setConnectorStyle(int), setGlobalLinkStyle(int), setHorizontalLinkOffset(double), setVerticalLinkOffset(double)
  - isNeighborLinksAligned
```
public final boolean isNeighborLinksAligned()
```
    Returns true if links between neighbor nodes of the same level are aligned so that they are parallel.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNeighborLinksAligned(boolean)
  - setIntergraphConnectivityMode
```
public final void setIntergraphConnectivityMode(boolean flag)
```
    Sets whether the intergraph link connectivity is considered for the partitioning of the layout into levels. If this option is enabled, the algorithm tries to distribute the nodes that represent subgraphs into the levels so that the majority of intergraph links point roughly in the flow direction.
    This is an expert option. It is disabled by default.
    
    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 Hierarchical Layout algorithm does not route intergraph links. They should be routed by applying a Link Layout after the Hierarchical Layout.
    
    Parameters:
    
    flag - true to set intergraph connectivity mode, or false to disable the mode.
    
    Since:
    
    JViews 5.5
  - isIntergraphConnectivityMode
```
public final boolean isIntergraphConnectivityMode()
```
    Returns true if the intergraph link connectivity is considered for the partitioning of the layout into levels.
    
    Since:
    
    JViews 5.5
  - setRecursiveLayoutMode
```
public final void setRecursiveLayoutMode(boolean flag)
```
    Sets whether this layout instance handles all subgraphs recursively that are nested into this graph. Normally, the hierarchical layout handles only the flat graph attached to this layout. If the recursive layout is enabled, it handles also all subgraphs recursively nested into this layout and also routes all intergraph links. The recursive mode is disabled by default.
    In detail: the recursive mode causes the hierarchical layout instances of the subgraphs to delegate the work to this layout. If the layout instance of a subgraph is no IlvHierarchicalLayout, the subgraph is not handled by this layout. Layout parameters per node and link must be set on the layout instance of the subgraph the node or link belongs to.
    
    Parameters:
    
    flag - true to enable the recursive layout mode, or false to disable the mode.
    
    Since:
    
    JViews 8.5
  - isRecursiveLayoutMode
```
public final boolean isRecursiveLayoutMode()
```
    Returns true if this layout instance handles all subgraphs recursively that are nested into this graph.
    
    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 hierarchical layout and must have the recursive 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
  - getLabelLayout
```
public IlvAnnealingLabelLayout getLabelLayout()
```
    Returns the label layout that handles the label in recursive mode.
    
    Returns:
    
    The label layout that handles labels in recursive mode.
    
    Since:
    
    JViews 8.5
  - setLabelLayoutEnabledDuringRecLayoutMode
```
public final void setLabelLayoutEnabledDuringRecLayoutMode(boolean flag)
```
    Sets whether the recursive layout mode places also the labels of the graph. This option has only an effect when the recursive layout mode is enabled. It places the labels obtained from getLabelLayout(), which is attached at the same grapher as this layout instance. The placement of labels is enabled by default.
    
    Parameters:
    
    flag - true to enable the placement of labels. or false to disable it.
    
    Since:
    
    JViews 8.5
  - isLabelLayoutEnabledDuringRecLayoutMode
```
public final boolean isLabelLayoutEnabledDuringRecLayoutMode()
```
    Returns true if the recursive layout mode places also the labels of the graph.
    
    Since:
    
    JViews 8.5
  - setLinkStraighteningEnabled
```
public final void setLinkStraighteningEnabled(boolean flag)
```
    Sets whether the link straightening phase is enabled. This phase analyzes long orthogonal links and tries to remove bends.
    This is an expert option. It is enabled by default. It is normally not necessary to disable link straightening, except if you need to speed up the layout.
    
    Parameters:
    
    flag - true to enable the link straightening phase, or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    isLinkStraighteningEnabled()
  - isLinkStraighteningEnabled
```
public final boolean isLinkStraighteningEnabled()
```
    Returns true if the link straightening phase is enabled.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setLinkStraighteningEnabled(boolean)
  - setOrthogonalStairCaseEliminationEnabled
```
public final void setOrthogonalStairCaseEliminationEnabled(boolean flag)
```
    Sets whether the stair case elimination phase for orthogonal links is enabled. This phase analyzes orthogonal links and tries to remove staircase pattens in the links shape.
    This is an expert option. It is enabled by default. It is normally not necessary to disable stair case elimination, except if you need to speed up the layout.
    
    Parameters:
    
    flag - true to enable the stair case elimination phase, or false to disable it.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    isOrthogonalStairCaseEliminationEnabled()
  - isOrthogonalStairCaseEliminationEnabled
```
public final boolean isOrthogonalStairCaseEliminationEnabled()
```
    Returns true if the stair case elimination phase for orthogonal links is enabled.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setOrthogonalStairCaseEliminationEnabled(boolean)
  - setNonorthogonalBendEliminationEnabled
```
public final void setNonorthogonalBendEliminationEnabled(boolean flag)
```
    Sets whether the bend elimination phase for nonorthogonal links is enabled. This phase analyzes nonorthogonal links and tries to remove bends in the links shape. This is not always desired for very long links since they often look aesthetically better if they are split by two bend into an orthogonal middle part and nonorthogonal end parts.
    This is an expert option. It is disabled by default. Enabling the bend elimination produces more straight links but also slows down the algorithm. In recursive mode, it might be useful to enable this option since the recursive mode produces many small link segments between bends.
    
    Parameters:
    
    flag - true to enable the bend elimination phase, or false to disable it.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    isNonorthogonalBendEliminationEnabled(), setRecursiveLayoutMode(boolean)
  - isNonorthogonalBendEliminationEnabled
```
public final boolean isNonorthogonalBendEliminationEnabled()
```
    Returns true if the bend elimination phase for nonorthogonal links is enabled.
    
    Since:
    
    JViews 8.7
    
    See Also:
    
    setNonorthogonalBendEliminationEnabled(boolean)
  - setBacktrackCrossingReductionEnabled
```
public final void setBacktrackCrossingReductionEnabled(boolean flag)
```
    Sets whether the backtrack mechanism of the link crossing reduction phase is enabled. The layout algorithm uses a sweep heuristic to resolve link crossings which includes a backtracking mechanism. If a sweep made the result worse, it sets the results back to the previous situation.
    This is an expert option. It is enabled by default. It is normally not necessary to disable the backtrack mechanism, except if you need to speed up the layout.
    
    Parameters:
    
    flag - true to enable backtracking during link crossing reduction (the default), or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    isBacktrackCrossingReductionEnabled()
  - isBacktrackCrossingReductionEnabled
```
public final boolean isBacktrackCrossingReductionEnabled()
```
    Returns true if the backtrack mechanism of the link crossing reduction phase is enabled.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setBacktrackCrossingReductionEnabled(boolean)
  - setMedianCrossingValueEnabled
```
public final void setMedianCrossingValueEnabled(boolean flag)
```
    Sets whether the median crossing value is used during crossing reduction. The layout algorithm uses a heuristic to resolve link crossings. This heuristic uses a "barycenter" weight on the nodes to determine how the crossings are resolved. If this option is enabled, it additionally uses a "median" weight as a tie breaker if two nodes have the same "barycenter" weight. Statistically, this results in fewer crossings.
    This is an expert option. It is enabled by default. It is normally not necessary to change this value. However, if many nodes have very high numbers of incoming or outgoing links, the calculation of the "median" weight may slow down the layout. In this case, you can switch this option off.
    
    Parameters:
    
    flag - true to enable use of the median crossing value, or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    isMedianCrossingValueEnabled()
  - isMedianCrossingValueEnabled
```
public final boolean isMedianCrossingValueEnabled()
```
    Returns true if the median crossing value is used during crossing reduction.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setMedianCrossingValueEnabled(boolean)
  - setNumberOfLinkCrossingSweeps
```
public final void setNumberOfLinkCrossingSweeps(int numberOfSweeps)
```
    Sets the number of layer sweeps to remove link crossings. The layout algorithm uses a sweep algorithm to resolve link crossings. This is a heuristic that cannot always remove all link crossings. The number of sweeps influences the number of crossings that are resolved. However, there is no simple formula to decide whether more sweeps would resolve more crossings or result in the converse. On some occasions it may be useful to increase or decrease the number of sweeps in order to resolve more link crossings.
    This is an expert option. The default value is 5. It is normally not necessary to change this value.
    
    Parameters:
    
    numberOfSweeps - The number of sweeps to remove link crossings.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getNumberOfLinkCrossingSweeps()
  - getNumberOfLinkCrossingSweeps
```
public final int getNumberOfLinkCrossingSweeps()
```
    Returns the number of layer sweeps to remove link crossings.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setNumberOfLinkCrossingSweeps(int)
  - setLinkCrossingFineTuningEnabled
```
public final void setLinkCrossingFineTuningEnabled(boolean flag)
```
    Sets whether the link crossing fine tuning phase is enabled. This is an additional heuristic that tries to resolve more link crossings.
    This is an expert option. It is enabled by default. It is normally not necessary to disable fine tuning, except if you need to speed up the layout.
    
    Parameters:
    
    flag - true to enable the link crossing fine tuning phase, or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    isLinkCrossingFineTuningEnabled()
  - isLinkCrossingFineTuningEnabled
```
public final boolean isLinkCrossingFineTuningEnabled()
```
    Returns true if the link crossing fine tuning phase is enabled.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setLinkCrossingFineTuningEnabled(boolean)
  - supportsSplineRouting
```
public boolean supportsSplineRouting()
```
    Indicates 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, it is enabled by calling IlvGraphLayout.setSplineRoutingEnabled(boolean).
    
    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)
  - setQuickAndUgly
```
public final void setQuickAndUgly(boolean flag)
```
    This is a convenience method to set up for a "quick and ugly" layout. If you pass true, it changes various layout parameters so that the algorithm runs maximally fast. However, the quality of the result may decrease. If you pass false, it sets the parameters back to the original values.
    It is normally not necessary to use a quick and ugly layout, because the default layout parameters are chosen carefully so that the speed difference should be very small. However, if you lay out a huge graph and the performance is too slow, you can easily test with the quick and ugly layout whether changing parameters would improve the performance noticeably.
    
    Parameters:
    
    flag - true to enable "QuickAndUgly" flag, or false to disable it.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setLinkStraighteningEnabled(boolean), setBacktrackCrossingReductionEnabled(boolean), setMedianCrossingValueEnabled(boolean), setNumberOfLinkCrossingSweeps(int)
  - 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 IlvHierarchicalLayoutGrapherProperty 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 IlvHierarchicalLayoutNodeProperty 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 IlvHierarchicalLayoutLinkProperty 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()
  - 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 attach. The detach method performs cleaning operations on the graph model. In addition to the cleaning operations in the base class, Hierarchical Layout removes all local specifications per node or link. It also removes the calculated level index and calculated position index from the nodes.
    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(IlvGraphModel), setSpecNodeLevelIndex(Object, int), setSpecNodePositionIndex(Object, int), getCalcNodeLevelIndex(Object), getCalcNodePositionIndex(Object), setNumberOfPorts(Object, int, int), setLinkPriority(Object, float), setLinkStyle(Object, int), setFromPortIndex(Object, int), setFromPortSide(Object, int), setToPortIndex(Object, int), setToPortSide(Object, int)
  - 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, Hierarchical Layout removes all local specifications per node. It also removes the calculated level index and calculated position index from the nodes.
    
    Overrides:
    
    cleanNode in class IlvGraphLayout
    
    Parameters:
    
    graphModel - The graph model to which the 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, Hierarchical Layout removes all local specifications per link.
    
    Overrides:
    
    cleanLink in class IlvGraphLayout
    
    Parameters:
    
    graphModel - The graph model to which the link belongs.
    
    link - The link to be cleaned.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    detach()
  - 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
  - layoutStepPerformed
```
public void layoutStepPerformed()
```
    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)

Class IlvHierarchicalLayout

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

POLYLINE_STYLE

MIXED_STYLE

AUTOMATIC_PINS

CENTERED_PINS

CLIPPED_PINS

EVENLY_SPACED_PINS

EAST

WEST

NORTH

SOUTH

UNSPECIFIED

FREE_MODE

FIXED_MODE

FIXED_IN_X_MODE

FIXED_IN_Y_MODE

MIXED_MODE

OPTIMAL

SEMI_OPTIMAL

HIGHER_LEVELS

LOWER_LEVELS

SPREAD_OUT

Constructor Detail

IlvHierarchicalLayout

IlvHierarchicalLayout

Method Detail

init

copy

copyParameters

beforeLayout

layout

setAllowedTime

getAllowedTime

supportsPreserveFixedNodes

supportsPreserveFixedLinks

supportsAllowedTime

supportsStopImmediately

stopImmediately

supportsPercentageComplete

supportsLayoutOfConnectedComponents

supportsLinkConnectionBox

supportsLinkClipping

supportsSaveParametersToNamedProperties

setFlowDirection

getFlowDirection

setLevelingStrategy

getLevelingStrategy

setLevelJustification

getLevelJustification

setConnectorStyle

getConnectorStyle

setFromFork

isFromFork

setToFork

isToFork

setMinForkSegmentLength

getMinForkSegmentLength

setPreferredForkAxisLength

getPreferredForkAxisLength

setGlobalLinkStyle

getGlobalLinkStyle

setLinkStyle

getLinkStyle

setHorizontalNodeOffset

getHorizontalNodeOffset

setVerticalNodeOffset

getVerticalNodeOffset

setHorizontalLinkOffset

getHorizontalLinkOffset

setVerticalLinkOffset