IlvLinkLayout (Perforce JViews 10.0 API)

java.lang.Object
- ilog.views.graphlayout.IlvGraphLayout
- - ilog.views.graphlayout.link.IlvLinkLayout

All Implemented Interfaces:

GraphModelListener, Serializable, EventListener
```
public class IlvLinkLayout
extends IlvGraphLayout
```
The main class for the Link Layout algorithm.
The Link Layout algorithm reshapes the links of a graph without moving the nodes. By default, the algorithm computes orthogonal links (that is, links composed of alternating horizontal and vertical segments). Optionally, direct links can be computed. See the method setGlobalLinkStyle(int).

The layout algorithm has two modes: short link mode and long link mode. The short link mode places the links freely in the plane by choosing the best shape from a fixed number of link shapes. A link has a maximum of 4 bends. The long link mode searches for routes on a grid by avoiding obstacles. By doing this, any link shape can occur (that is, the number of link shapes is unlimited) but a long link route can have many bends.

The long link mode is slower and uses more memory on very large graphs than the short link mode. The short link mode should be used if any of the following conditions apply:
- Most of the links are short and it is not fatal if long links overlap obstacles.
- The link routes must be placed freely and cannot be restricted to a grid.
- It is important to limit the number of bends.
- Maximal speed and minimal memory usage are important on huge graphs.
The long link mode should be used if any of the following conditions apply:
- Many links are long and it is important that long orthogonal links do not overlap obstacles.
- Routing on a grid is preferred because it guarantees a minimal distance between link segments.
- An increasing number of bends is acceptable if this avoids any overlaps. The long link mode can be used to find an orthogonal route without overlaps in a labyrinth of node obstacles.
Here are sample drawings produced by the Link Layout algorithm:

The short link mode works very well with thick links produced by Java 2D:

Here are sample drawings produced by the Link Layout algorithm in long link mode:

The long link mode can be used to find a route through a labyrinth:

The Link Layout algorithm is a wrapper that allows simplified access to two sublayouts: the Short Link Layout algorithm and the Long Link Layout algorithm. It calls these sublayouts internally to perform the layout. This is useful for applications that need to use both layout modes at the same time. Applications that use the short link mode exclusively can use the Short Link Layout algorithm (IlvShortLinkLayout) directly. Applications that use the long link mode exclusively can use the Long Link Layout algorithm (IlvLongLinkLayout) directly.
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 algorithm never moves any nodes. It only reshapes links.
- The algorithm normally routes normal links. It has a special mode to route the intergraph links of the graph model.
- The algorithm has an incremental mode and a nonincremental mode. In nonincremental mode, the initial shape of the links (at the moment you start the layout) does not affect the resulting layout. However, links specified as fixed while setPreserveFixedLinks(boolean) is enabled, or links that have the link style NO_RESHAPE_STYLE, are not reshaped. The incremental mode cannot be used for intergraph links.
- In incremental mode, the initial shape of the link does affect the resulting layout. The algorithm tries to preserve the shape of links that already fit the layout situation.
- The algorithm supports self-links and multiple links between the same pair of nodes.
Since:

JViews 3.5.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DIRECT_STYLE` Direct link style option.
`static int`	`FIXED_MODE` Fixed connection point mode.
`static int`	`FREE_MODE` Free connection point mode.
`static int`	`LONG_LINKS` Long links layout mode.
`static int`	`MIXED_MODE` Mixed connection point mode.
`static int`	`MIXED_STYLE` Mixed link style option.
`static int`	`NO_RESHAPE_STYLE` No reshape link style option.
`static int`	`ORTHOGONAL_STYLE` Orthogonal link style option.
`static int`	`SHORT_LINKS` Short links layout mode.

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

Constructor Summary

Constructors
Constructor and Description
`IlvLinkLayout()` Creates a new instance of the Link Layout algorithm.
`IlvLinkLayout(IlvLinkLayout 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`	`attach(IlvGraphModel graphModel)` Allows you to specify the graph model you want to lay out.
`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.
`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 `IlvLinkLayoutGrapherProperty` that stores the parameter settings of this layout class.
`protected IlvGraphLayoutLinkProperty`	`createLayoutLinkProperty(String name, IlvGraphic link, boolean withDefaults)` Returns a new instance of `IlvLinkLayoutLinkProperty` that stores the parameter settings of this layout class for links.
`void`	`detach()` Detaches the graph model from the layout instance.
`int`	`getDestinationPointMode(Object link)` Returns the destination point mode of an individual link.
`int`	`getGlobalDestinationPointMode()` Returns the global mode for the connection points of the links on the destination nodes.
`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`	`getHorizontalGridBase()` Returns the horizontal base coordinate of the grid.
`double`	`getHorizontalGridOffset()` Returns the horizontal offset between the grid lines.
`double`	`getHorizontalMinOffset()` Returns the minimal horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
`int`	`getLayoutMode()` Returns the current layout mode.
`double`	`getLinkOffset()` Returns the offset between links connected on the same side of the node.
`int`	`getLinkStyle(Object link)` Returns the shape style of an individual link.
`IlvLongLinkLayout`	`getLongLinkLayout()` Returns the Long Link Layout instance that is used internally by this Link Layout instance in layout mode `LONG_LINKS`.
`double`	`getMinFinalSegmentLength()` Returns the minimum length of the first and last segments of each link.
`double`	`getMinNodeCornerOffset()` Returns the minimum offset between a node corner and a link starting at this node.
`IlvNodeBoxInterface`	`getNodeBoxInterface()` Returns the node box interface used during the layout, or `null` if none is specified.
`IlvNodeSideFilter`	`getNodeSideFilter()` Returns the node-side filter used during layout, or `null` if none is specified.
`int`	`getOriginPointMode(Object link)` Returns the origin point mode of an individual link.
`IlvShortLinkLayout`	`getShortLinkLayout()` Returns the Short Link Layout instance that is used internally by this Link Layout instance in layout mode `SHORT_LINKS`.
`double`	`getVerticalGridBase()` Returns the vertical base coordinate of the grid.
`double`	`getVerticalGridOffset()` Returns the vertical offset between the grid lines.
`double`	`getVerticalMinOffset()` Returns the minimal vertical offset between the node border and a link segment that is (horizontally) parallel to the node border.
`protected void`	`init()` Initializes instance variables.
`boolean`	`isCombinedInterGraphLinksMode()` Returns `true` if the routing of normal links in addition to intergraph links is enabled.
`boolean`	`isGeometryUpToDate()` Returns `false` if at least one node, link, label or obstacle was moved or reshaped since the last time the layout was successfully performed on the same graph or if the layout has never been performed successfully on the same graph.
`boolean`	`isIncrementalMode()` Returns `true` if the incremental mode is enabled.
`boolean`	`isInterGraphLinksMode()` Returns `true` if the routing of intergraph links is enabled.
`boolean`	`isParametersUpToDate()` Returns `false` if at least one parameter was modified since the last time the layout was successfully performed on the same graph or if the layout has never been performed successfully on the same graph.
`boolean`	`isStructureUpToDate()` Returns `false` if at least one modification occurred in the structure of the graph since the last time the layout was successfully performed on the same graph or if the layout has never been performed successfully on the same graph.
`protected void`	`layout(boolean redraw)` Computes the layout using the Link Layout algorithm.
`void`	`markForIncremental(Object link)` Marks the input link to be rerouted with the next call of `performLayout` if incremental mode is enabled.
`void`	`setAllowedTime(long time)` Sets an upper limit for the duration of the layout algorithm.
`void`	`setAnimate(boolean option)` Enables the animation mechanism.
`boolean`	`setAutoCheckAppropriateLinksEnabled(boolean enable)` Sets whether the layout checks whether links are appropriate.
`void`	`setAutoLayout(boolean enable)` Enables the auto layout mode.
`void`	`setBalanceSplineCurveThreshold(double threshold)` Sets the threshold for spline curves on arcs until the optimized spline control point routing tries to balance the curve.
`void`	`setCombinedInterGraphLinksMode(boolean enable)` Enables the routing of normal links in addition to intergraph links.
`void`	`setCoordinatesMode(int mode)` Sets the coordinates mode.
`void`	`setDestinationPointMode(Object link, int mode)` Sets the mode for the connection point on an individual link on the destination node.
`void`	`setFixed(Object nodeOrLink, boolean fixed)` Allows you to specify whether a link is fixed.
`void`	`setGeometryUpToDate(boolean uptodate)` This method is normally called with a `false` argument if the geometry of the graph changed.
`void`	`setGlobalDestinationPointMode(int mode)` Sets the global mode for the connection point of the links on the destination nodes.
`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`	`setGraphModel(IlvGraphModel graphModel)` Sets the graph model to be laid out.
`void`	`setHorizontalGridBase(double coordinate)` Sets the horizontal base coordinate of the grid.
`void`	`setHorizontalGridOffset(double offset)` Sets the horizontal offset between the grid lines.
`void`	`setHorizontalMinOffset(double offset)` Sets the minimal horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
`void`	`setIncrementalMode(boolean enable)` Enables the incremental layout mode.
`void`	`setInputCheckEnabled(boolean enable)` Enables the checks for the nodes and/or links provided as arguments for the different methods of this layout algorithm.
`void`	`setInterGraphLinksMode(boolean enable)` Enables the routing of intergraph links.
`void`	`setLayoutMode(int mode)` Sets the layout mode.
`void`	`setLayoutRunning(boolean running, boolean fromParents)` Sets whether layout is running.
`void`	`setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface connectionBoxInterface)` Allows you to specify a link connection box interface for the connection points of links.
`void`	`setLinkOffset(double offset)` Sets the offset between links connected on the same side of the node.
`void`	`setLinkStyle(Object link, int style)` Sets the shape style of an individual link.
`void`	`setMaxSplineCurveSize(double size)` Sets the maximum curve size used when optimized spline control point routing is enabled.
`void`	`setMinBusyTime(long time)` Sets the minimal time that the layout algorithm can be busy between two calls of `layoutStepPerformed` when the method `callLayoutStepPerformedIfNeeded` is used.
`void`	`setMinFinalSegmentLength(double length)` Sets the minimum length of the first and last segments of each link.
`void`	`setMinNodeCornerOffset(double offset)` Sets the minimum offset between a node corner and a link starting at this node.
`void`	`setMinSplineCurveSize(double size)` Sets the minimum curve size used when optimized spline control point routing is enabled.
`void`	`setNodeBoxInterface(IlvNodeBoxInterface nodeBoxInterface)` Allows you to specify a node box interface for the obstacle area.
`void`	`setNodeSideFilter(IlvNodeSideFilter filter)` Allows you to install a node-side filter, that is, an object that allows or prohibits the connection of the links on a given side of the nodes.
`void`	`setOriginPointMode(Object link, int mode)` Sets the mode for the connection point on an individual link on the origin node.
`void`	`setParametersUpToDate(boolean uptodate)` This method is automatically called with a `false` argument each time the value of a parameter is changed.
`void`	`setPreserveFixedLinks(boolean option)` If the argument is `true`, specifies that the layout is not allowed to reshape the links indicated as fixed by the user.
`void`	`setSplineLinkFilter(IlvSplineLinkFilter filter)` Sets the filter that detects which links are suitable for optimized spline routing.
`void`	`setSplineRoutingEnabled(boolean flag)` Sets whether the calculation of optimized spline control points is enabled.
`void`	`setStructureUpToDate(boolean uptodate)` This method is normally called with a `false` argument if the structure of the graph changed.
`void`	`setUseDefaultParameters(boolean option)` If the argument is `true`, specifies that the layout use the default values of all the parameters; that is, the "get..." and "is..." methods return the default values.
`void`	`setVerticalGridBase(double coordinate)` Sets the vertical base coordinate of the grid.
`void`	`setVerticalGridOffset(double offset)` Sets the vertical offset between the grid lines.
`void`	`setVerticalMinOffset(double offset)` Sets the minimal vertical offset between the node border and a link segment that is (horizontally) parallel to the node border.
`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`	`supportsAnimation()` Indicates that this layout class supports the animation mechanism; that is, it can perform redraws to animate the layout process in some way.
`boolean`	`supportsLinkConnectionBox()` Indicates that this layout class can use a link connection box interface to calculate the end points of a link.
`boolean`	`supportsPreserveFixedLinks()` Indicates that this layout class allows the user to specify fixed links.
`boolean`	`supportsSaveParametersToNamedProperties()` Indicates that this layout class can transfer the layout parameters to named properties.
`boolean`	`supportsSplineRouting()` Indicates that this class supports the generic optimization of spline control points.
`boolean`	`supportsStopImmediately()` Indicates that this layout class can interrupt the current run of the layout immediately in a controlled way.

Methods inherited from class ilog.views.graphlayout.IlvGraphLayout
addGraphLayoutEventListener, addGraphLayoutParameterEventListener, afterLayoutOfSubgraph, attach, beforeLayout, beforeLayoutOfSubgraph, callLayoutStepPerformedIfNeeded, cleanGraphModel, cleanLink, cleanNode, clipAllLinks, clipLink, connectAllLinksToCenter, connectLinkToCenter, contentsChanged, createLayoutNodeProperty, createLayoutReport, getAllowedTime, getAutoLayoutHandler, getBalanceSplineCurveThreshold, getCalcLayoutRegion, getCoordinatesMode, getGrapher, getGraphModel, getInstanceId, getLayout, getLayoutOfConnectedComponents, getLayoutOfConnectedComponentsReport, getLayoutRegion, getLayoutReport, getLayouts, getLinkClipInterface, getLinkConnectionBoxInterface, getMaxSplineCurveSize, getMinBusyTime, getMinSplineCurveSize, getMovingNodes, getParentLayout, getProperty, getProperty, getRecursiveLayout, getRemainingAllowedTime, getSeedValueForRandomGenerator, getSpecLayoutRegion, getSplineLinkFilter, increasePercentageComplete, isAnimate, isAutoLayout, isFitToView, isFixed, isInputCheckEnabled, isLayoutNeeded, isLayoutOfConnectedComponentsEnabled, isLayoutOfConnectedComponentsEnabledByDefault, isLayoutRunning, isLayoutRunning, isLayoutTimeElapsed, isLocalRecursiveLayoutNeeded, isMemorySavings, isPreserveFixedLinks, isPreserveFixedNodes, isSplineRoutingEnabled, isStoppedImmediately, isUseDefaultParameters, isUseSeedValueForRandomGenerator, layoutStepPerformed, onParameterChanged, onParameterChanged, performAutoLayout, performLayout, performLayout, performLayout, PerformLayout, performSublayout, removeGraphLayoutEventListener, removeGraphLayoutParameterEventListener, setAutoLayoutHandler, setGrapher, setLayoutOfConnectedComponents, setLayoutOfConnectedComponentsEnabled, setLayoutRegion, setLayoutRegion, setLayoutRegion, setLayoutReport, setLinkClipInterface, setMemorySavings, setParentLayout, setPreserveFixedNodes, setProperty, setProperty, setSeedValueForRandomGenerator, setUseSeedValueForRandomGenerator, supportsLayoutOfConnectedComponents, supportsLayoutRegion, supportsLinkClipping, supportsMemorySavings, supportsPercentageComplete, supportsPreserveFixedNodes, supportsRandomGenerator, unfixAllLinks, unfixAllNodes, useAnimateRedraw

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

- Field Detail
  - ORTHOGONAL_STYLE
```
public static final int ORTHOGONAL_STYLE
```
    Orthogonal link style option. When used as the argument of the method setGlobalLinkStyle(int), all links have an orthogonal shape (alternating horizontal and vertical segments). To specify the style of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - DIRECT_STYLE
```
public static final int DIRECT_STYLE
```
    Direct link style option. When used as the argument of the method setGlobalLinkStyle(int), all links have a (semi)direct shape. To specify the style of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - MIXED_STYLE
```
public static final int MIXED_STYLE
```
    Mixed link style option. When used as the argument of the method setGlobalLinkStyle(int), each link can have a different shape. The shape of an individual link can be set by the method setLinkStyle(java.lang.Object, int).
    
    See Also:
    
    Constant Field Values
  - NO_RESHAPE_STYLE
```
public static final int NO_RESHAPE_STYLE
```
    No reshape link style option. This can be used for individual links if the global link style is MIXED_STYLE. To specify the style of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    Constant Field Values
  - SHORT_LINKS
```
public static final int SHORT_LINKS
```
    Short links layout mode. When used as the argument of the method setLayoutMode(int), links are placed freely in the plane by choosing the best shape from a fixed number of link shapes. A link can have a maximum of 4 bends.
    
    See Also:
    
    Constant Field Values
  - LONG_LINKS
```
public static final int LONG_LINKS
```
    Long links layout mode.
    When used as the argument of the method setLayoutMode(int), links of link style ORTHOGONAL_STYLE are routed on a grid and avoid obstacles. By so doing, any orthogonal link shape can occur (that is, the number of link shapes is unlimited) and a long link route can have many bends.
    
    Links of link style DIRECT_STYLE are routed with the end segments on the grid, but the middle segment may overlap obstacles.
    
    See Also:
    
    Constant Field Values
  - FREE_MODE
```
public static final int FREE_MODE
```
    Free connection point mode. When 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(java.lang.Object, boolean)). To specify the mode for the connection points of an individual link, use this mode as the argument of the method setOriginPointMode(java.lang.Object, int) or setDestinationPointMode(java.lang.Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    Constant Field Values
  - FIXED_MODE
```
public static final int FIXED_MODE
```
    Fixed connection point mode. When 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(java.lang.Object, int) or setDestinationPointMode(java.lang.Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    Constant Field Values
  - MIXED_MODE
```
public static final int MIXED_MODE
```
    Mixed connection point mode. 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(java.lang.Object, int) or setDestinationPointMode(java.lang.Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - IlvLinkLayout
```
public IlvLinkLayout()
```
    Creates a new instance of the Link Layout algorithm.
    To indicate the grapher you want to lay out, use the method IlvGraphLayout.attach(ilog.views.IlvGrapher).
    To indicate the graph model you want to lay out, use the method attach(ilog.views.graphlayout.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)
  - IlvLinkLayout
```
public IlvLinkLayout(IlvLinkLayout 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(ilog.views.graphlayout.IlvGraphLayout).
    
    Parameters:
    
    source - The layout instance that is copied.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copy(), copyParameters(ilog.views.graphlayout.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 on a nested graph, IlvLayoutProvider uses this method to "clone" the layout instance of a parent graph. Note that the parameters which are specific to a node or a link are not copied. Only the global parameters are copied. The customization interfaces (node side filter, node box interface) are also copied.
    
    Specified by:
    
    copy in class IlvGraphLayout
    
    Returns:
    
    A copy of the layout instance.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copyParameters(ilog.views.graphlayout.IlvGraphLayout), setNodeBoxInterface(ilog.views.graphlayout.IlvNodeBoxInterface), setNodeSideFilter(ilog.views.graphlayout.IlvNodeSideFilter)
  - copyParameters
```
public void copyParameters(IlvGraphLayout source)
```
    Copies the parameters from a given layout instance.
    Note that the parameters which are specific to a node or a link are not copied. Only the global parameters are copied. The customization interfaces (node side filter, node box interface) are also copied.
    
    Overrides:
    
    copyParameters in class IlvGraphLayout
    
    Parameters:
    
    source - The layout instance from which the parameters are copied.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copy(), setNodeBoxInterface(ilog.views.graphlayout.IlvNodeBoxInterface), setNodeSideFilter(ilog.views.graphlayout.IlvNodeSideFilter)
  - attach
```
public void attach(IlvGraphModel graphModel)
```
    Allows you to specify the graph model you want to lay out. In addition to the functionality in the base class, the Link Layout attaches its sublayouts, the Short Link Layout and the Long Link Layout.
    
    Overrides:
    
    attach in class IlvGraphLayout
    
    Parameters:
    
    graphModel - The graph model to lay out.
    
    See Also:
    
    detach(), getLongLinkLayout(), getShortLinkLayout()
  - detach
```
public void detach()
```
    Detaches the graph model from the layout instance. It also detaches its sublayouts, the Short Link Layout and the Long Link Layout. 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(IlvGraphModel). The detach method performs cleaning operations on the graph model. In addition to the cleaning operations in the base class, the Link Layout removes the link style specifications of individual links.
    Note that you must call this method when you no longer need the layout instance. Otherwise, some objects may not be garbage collected.
    
    Overrides:
    
    detach in class IlvGraphLayout
    
    See Also:
    
    attach(IlvGraphModel), setLinkStyle(java.lang.Object, int), getLongLinkLayout(), getShortLinkLayout()
  - setGraphModel
```
public void setGraphModel(IlvGraphModel graphModel)
```
    Sets the graph model to be laid out. You should not call this method directly. Instead, use the method IlvGraphLayout.attach(IlvGrapher) or attach(IlvGraphModel).
    
    Overrides:
    
    setGraphModel in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvGraphLayout.attach(IlvGrapher), IlvGraphLayout.attach(IlvGraphModel)
  - layout
```
protected void layout(boolean redraw)
               throws IlvGraphLayoutException
```
    Computes the layout using the Link 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:
    
    IlvInappropriateLinkException - if the grapher contains links that cannot be reshaped to a polyline and whose connection points cannot be moved. (For details, see IlvInappropriateLinkException).
    
    IlvGraphLayoutException - If an unusual situation occurs. WARNING: this method can throw one of the subclasses of IlvGraphLayoutException. Specifically, it can throw an IlvInappropriateGraphException. It can also throw an IlvInappropriateLinkException when inappropriate types of links and/or link connectors are used in an IlvGrapher. For details, refer to the documentation of these exception classes.
    
    See Also:
    
    IlvGraphLayout.performLayout()
  - setLayoutMode
```
public final void setLayoutMode(int mode)
```
    Sets the layout mode. Valid value are:
    - SHORT_LINKS - Links are placed freely in the plane by choosing the best shape from a fixed number of link shapes. A link can have a maximum of 4 bends.
      This mode should be used if any of the following conditions apply:
      
      Most of the links are short and it is not fatal if long links overlap obstacles.
      
      The link routes must be placed freely and cannot be restricted to a grid.
      
      It is important to limit the number of bends.
    - LONG_LINKS - Orthogonal links are routed on a grid by avoiding obstacles. Any orthogonal link shape can occur (that is, the number of link shapes is not limited) but a long link route can have many bends. Direct links are routed with the end segments on the grid, but the middle segment may overlap obstacles.
      This mode should be used if any of the following conditions apply:
      
      Many links are long, and it is important that long links do not overlap obstacles.
      
      Routing on a grid is preferred because it guarantees a minimal distance between link segments.
      
      An increasing number of bends is acceptable if this avoids any overlaps. The long link mode can be used to find an orthogonal route without overlaps in a labyrinth of node obstacles.
    The default value is SHORT_LINKS.
    See Also:
    
    getLayoutMode(), setGlobalLinkStyle(int), setLinkStyle(java.lang.Object, int), getLongLinkLayout(), getShortLinkLayout()
  - getLayoutMode
```
public final int getLayoutMode()
```
    Returns the current layout mode.
    
    See Also:
    
    setLayoutMode(int)
  - getShortLinkLayout
```
public IlvShortLinkLayout getShortLinkLayout()
```
    Returns the Short Link Layout instance that is used internally by this Link Layout instance in layout mode SHORT_LINKS. This allows you to access the internal parameter settings of the Short Link Layout.
    
    See Also:
    
    setLayoutMode(int), getLongLinkLayout(), IlvShortLinkLayout
  - getLongLinkLayout
```
public IlvLongLinkLayout getLongLinkLayout()
```
    Returns the Long Link Layout instance that is used internally by this Link Layout instance in layout mode LONG_LINKS. This allows you to access the internal parameter settings of the Long Link Layout.
    
    See Also:
    
    setLayoutMode(int), getShortLinkLayout(), IlvLongLinkLayout
  - setAutoLayout
```
public final void setAutoLayout(boolean enable)
```
    Enables the auto layout mode. If the argument is true, the layout is automatically performed again each time the layout instance is notified that the geometry or the structure of the graph has changed.
    It is disabled by default.
    
    Overrides:
    
    setAutoLayout in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.isAutoLayout(), IlvGraphLayout.contentsChanged(ilog.views.graphlayout.GraphModelEvent), IlvGraphLayout.performAutoLayout()
  - setLayoutRunning
```
public void setLayoutRunning(boolean running,
                             boolean fromParents)
```
    Sets whether layout is running. The method is part of JViews internals. You should not use it.
    
    Overrides:
    
    setLayoutRunning in class IlvGraphLayout
    
    Parameters:
    
    running - Whether layout is running or not.
    
    fromParents - Whether this is a notification from a parent layout or from this layout instance.
    
    Since:
    
    JViews 8.5
  - setIncrementalMode
```
public final void setIncrementalMode(boolean enable)
```
    Enables the incremental layout mode. If the argument is true, only those links that were affected by changes since the last layout are rerouted. A link is rerouted under the following conditions:
    - if the link is new,
    - if the link shape or link style has changed,
    - if the parameters controlling the starting and end segments have changed,
    - if the link now overlaps obstacles that were moved or resized,
    - in long link mode, if the link is no longer on the grid,
    - if the link is marked for incremental rerouting.
    In short link mode, links already laid out in the last layout keep their general shape (that is keep their number of bends and do not change the side where they connect to the end nodes), except if one or both of their end nodes have been moved or resized.
    
    In long link mode, the rerouted links can change shape completely. The rerouted links can change the side where they are connected to the end nodes if this is necessary to obtain a better route.
    
    The incremental mode works only if the intergraph links mode is disabled or if there are no intergraph links. The incremental mode is disabled by default.
    Parameters:
    
    enable - Set to true to enable incremental layout mode, or false to disable it.
    
    See Also:
    
    isIncrementalMode(), markForIncremental(java.lang.Object), setLayoutMode(int), IlvGraphLayout.contentsChanged(ilog.views.graphlayout.GraphModelEvent), setInterGraphLinksMode(boolean)
  - isIncrementalMode
```
public final boolean isIncrementalMode()
```
    Returns true if the incremental mode is enabled.
    
    See Also:
    
    setIncrementalMode(boolean)
  - markForIncremental
```
public final void markForIncremental(Object link)
```
    Marks the input link to be rerouted with the next call of performLayout if incremental mode is enabled. Normally, the incremental layout reroutes only those links that have changed since the last layout. By setting a mark on the link, this link will be rerouted even if it has not changed.
    
    See Also:
    
    setIncrementalMode(boolean), IlvGraphLayout.performLayout()
  - setInterGraphLinksMode
```
public final void setInterGraphLinksMode(boolean enable)
```
    Enables the routing of intergraph links. If the argument is true, the intergraph links are routed; otherwise, only the normal links are routed. An intergraph link is a link stored in a given graph that has an origin or destination not stored in this graph. If additionally the combined intergraph link routing is enabled, this means that normal links and intergraph links are routed together; otherwise, only the intergraph links are routed.
    The default value is true.
    
    If the intergraph link mode is enabled and the graph actually contains some intergraph links, there are some restrictions:
    - Layout animation is not possible.
    - The incremental mode has no effect.
    - If layout is performed on a nested IlvGrapher (or IlvGrapherAdapter), the top-level grapher must have a manager view attached because of the coordinate transformations of the subgraphers. If you create your own subclass of IlvGraphModel instead of IlvGrapherAdapter to route intergraph links, you must ensure that all graph models of all subgraphers use the same coordinate system through appropriate coordinate transformations.
    Since:
    
    JViews 5.0
    
    See Also:
    
    isInterGraphLinksMode(), setCombinedInterGraphLinksMode(boolean), setAnimate(boolean), setIncrementalMode(boolean), IlvGraphModel.isInterGraphLink(java.lang.Object)
  - isInterGraphLinksMode
```
public final boolean isInterGraphLinksMode()
```
    Returns true if the routing of intergraph links is enabled. Returns false otherwise.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setInterGraphLinksMode(boolean)
  - setCombinedInterGraphLinksMode
```
public final void setCombinedInterGraphLinksMode(boolean enable)
```
    Enables the routing of normal links in addition to intergraph links. If intergraph link routing is disabled, the option has no effect. If intergraph link routing is enabled and the argument is true, both normal links and intergraph links are routed in the same pass. Otherwise, only the intergraph links are routed.
    The default value is true.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isCombinedInterGraphLinksMode(), setInterGraphLinksMode(boolean), IlvGraphModel.isInterGraphLink(java.lang.Object)
  - isCombinedInterGraphLinksMode
```
public final boolean isCombinedInterGraphLinksMode()
```
    Returns true if the routing of normal links in addition to intergraph links is enabled. It returns false otherwise.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setInterGraphLinksMode(boolean), setCombinedInterGraphLinksMode(boolean)
  - setLinkOffset
```
public final void setLinkOffset(double offset)
```
    Sets the offset between links connected on the same side of the node. It affects only the layout mode SHORT_LINKS where the links are placed freely. In the layout mode LONG_LINKS, the link offset parameter is ignored, because the offset between links is implicitly determined by the grid width.
    The default value is 2.
    
    See Also:
    
    getLinkOffset(), setLayoutMode(int), setHorizontalGridOffset(double), setVerticalGridOffset(double)
  - getLinkOffset
```
public final double getLinkOffset()
```
    Returns the offset between links connected on the same side of the node. This offset affects only the layout mode SHORT_LINKS.
    
    See Also:
    
    setLinkOffset(double)
  - setHorizontalGridOffset
```
public final void setHorizontalGridOffset(double offset)
```
    Sets the horizontal offset between the grid lines. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode SHORT_LINKS, links are placed freely and the grid parameters are ignored.
    The default value is 5.
    
    See Also:
    
    getHorizontalGridOffset(), setHorizontalMinOffset(double), setHorizontalGridBase(double), setLinkOffset(double), setLayoutMode(int)
  - getHorizontalGridOffset
```
public final double getHorizontalGridOffset()
```
    Returns the horizontal offset between the grid lines. This offset affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setHorizontalGridOffset(double)
  - setVerticalGridOffset
```
public final void setVerticalGridOffset(double offset)
```
    Sets the vertical offset between the grid lines. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode SHORT_LINKS, links are placed freely and the grid parameters are ignored.
    The default value is 5.
    
    See Also:
    
    getVerticalGridOffset(), setVerticalMinOffset(double), setVerticalGridBase(double), setLinkOffset(double), setLayoutMode(int)
  - getVerticalGridOffset
```
public final double getVerticalGridOffset()
```
    Returns the vertical offset between the grid lines. This offset affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setVerticalGridOffset(double)
  - setHorizontalGridBase
```
public final void setHorizontalGridBase(double coordinate)
```
    Sets the horizontal base coordinate of the grid. This is the x coordinate of the first vertical grid line. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode SHORT_LINKS, links are placed freely and the grid parameters are ignored.
    The default value is 0.
    
    See Also:
    
    getHorizontalGridBase(), setHorizontalGridOffset(double), setLayoutMode(int)
  - getHorizontalGridBase
```
public final double getHorizontalGridBase()
```
    Returns the horizontal base coordinate of the grid. This value affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setHorizontalGridBase(double)
  - setVerticalGridBase
```
public final void setVerticalGridBase(double coordinate)
```
    Sets the vertical base coordinate of the grid. This is the y coordinate of the first horizontal grid line. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode SHORT_LINKS, links are placed freely and the grid parameters are ignored.
    The default value is 0.
    
    See Also:
    
    getVerticalGridBase(), setVerticalGridOffset(double), setLayoutMode(int)
  - getVerticalGridBase
```
public final double getVerticalGridBase()
```
    Returns the vertical base coordinate of the grid. This value affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setVerticalGridBase(double)
  - setHorizontalMinOffset
```
public final void setHorizontalMinOffset(double offset)
```
    Sets the minimal horizontal offset between the node border and a link segment that is (vertically) parallel to the node border. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode SHORT_LINKS, links are placed freely and the grid parameters are ignored.
    The default value is 3.
    
    See Also:
    
    getHorizontalMinOffset(), setHorizontalGridOffset(double), setLayoutMode(int)
  - getHorizontalMinOffset
```
public final double getHorizontalMinOffset()
```
    Returns the minimal horizontal offset between the node border and a link segment that is (vertically) parallel to the node border. This value affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setHorizontalMinOffset(double)
  - setVerticalMinOffset
```
public final void setVerticalMinOffset(double offset)
```
    Sets the minimal vertical offset between the node border and a link segment that is (horizontally) parallel to the node border. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode SHORT_LINKS, links are placed freely and the grid parameters are ignored.
    The default value is 3.
    
    See Also:
    
    getVerticalMinOffset(), setVerticalGridOffset(double), setLayoutMode(int)
  - getVerticalMinOffset
```
public final double getVerticalMinOffset()
```
    Returns the minimal vertical offset between the node border and a link segment that is (horizontally) parallel to the node border. This value affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setVerticalMinOffset(double)
  - setMinNodeCornerOffset
```
public final void setMinNodeCornerOffset(double offset)
```
    Sets the minimum offset between a node corner and a link starting at this node. Setting this to 0 enables the layout to start a link exactly at a node corner. It affects only the layout mode LONG_LINKS where the links are routed on an orthogonal grid and always connect to the node border. In the layout mode SHORT_LINKS, links are placed freely in the plane, potentially connecting outside the node border.
    The default value is 3.
    
    See Also:
    
    getMinNodeCornerOffset(), setLayoutMode(int)
  - getMinNodeCornerOffset
```
public final double getMinNodeCornerOffset()
```
    Returns the minimum offset between a node corner and a link starting at this node. This value affects only the layout mode LONG_LINKS.
    
    See Also:
    
    setMinNodeCornerOffset(double)
  - setMinFinalSegmentLength
```
public final void setMinFinalSegmentLength(double length)
```
    Sets the minimum length of the first and last segments of each link.
    The default value is 10.
    
    See Also:
    
    getMinFinalSegmentLength()
  - getMinFinalSegmentLength
```
public final double getMinFinalSegmentLength()
```
    Returns the minimum length of the first and last segments of each link.
    
    See Also:
    
    setMinFinalSegmentLength(double)
  - setGlobalLinkStyle
```
public final void setGlobalLinkStyle(int style)
```
    Sets the global style of the shapes of links. Valid values are:
    - ORTHOGONAL_STYLE - all links have an orthogonal shape, that is, a shape consisting of a sequence of alternating horizontal and vertical line segments.
    - DIRECT_STYLE - all links get a nearly straight-line shape. The shape of the links is a polyline composed of a straight-line segment between the end nodes with two short horizontal or vertical segments at its ends (their length is controlled by the method setMinFinalSegmentLength and may be 0).
    - MIXED_STYLE - each link can have a different link style. The style of each individual link can be set by the method setLinkStyle(Object, int) so that different link shapes can occur in the same graph.
    Unless the global link style is MIXED_STYLE, all links have the same shape style.
    The default value is ORTHOGONAL_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 link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinkTypes(ilog.views.graphlayout.IlvGraphLayout, boolean) and method IlvGraphLayoutUtil.EnsureAppropriateLinkConnectors(ilog.views.graphlayout.IlvGraphLayout, boolean) before layout, or the method IlvGraphLayoutUtil.EnsureAppropriateLinks(ilog.views.graphlayout.IlvGraphModel, ilog.views.graphlayout.IlvLayoutProvider) when the exception is caught, to convert all links and link connectors to an appropriate type.
    See Also:
    
    getGlobalLinkStyle(), setLinkStyle(java.lang.Object, int), setLayoutMode(int)
  - getGlobalLinkStyle
```
public final int getGlobalLinkStyle()
```
    Returns the global style of the shapes of links.
    
    See Also:
    
    setGlobalLinkStyle(int)
  - setLinkStyle
```
public final void setLinkStyle(Object link,
                               int style)
```
    Sets the shape style 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:
    - ORTHOGONAL_STYLE - the link has an orthogonal shape, that is, a shape consisting of a sequence of alternating horizontal and vertical line segments.
    - DIRECT_STYLE - the link gets a nearly straight-line shape. The shape of the link is a polyline composed of a straight-line segment between the end nodes with two short horizontal or vertical segments at its ends (their length is controlled by the method setMinFinalSegmentLength and may be 0).
    - NO_RESHAPE_STYLE - the link is not reshaped.
    The default value is ORTHOGONAL_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 link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil.EnsureAppropriateLinkTypes(ilog.views.graphlayout.IlvGraphLayout, boolean) and method IlvGraphLayoutUtil.EnsureAppropriateLinkConnectors(ilog.views.graphlayout.IlvGraphLayout, boolean) before layout, or the method IlvGraphLayoutUtil.EnsureAppropriateLinks(ilog.views.graphlayout.IlvGraphModel, ilog.views.graphlayout.IlvLayoutProvider) when the exception is caught, to convert all links and connectors to an appropriate type.
    Note also that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a link style on the Link Layout means that the same style is specified for both Short and Long Link Layouts.
    Parameters:
    
    link - The link.
    
    style - The shape style.
    
    See Also:
    
    getLinkStyle(java.lang.Object), setGlobalLinkStyle(int), setLayoutMode(int)
  - getLinkStyle
```
public int getLinkStyle(Object link)
```
    Returns the shape style of an individual link.
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(java.lang.Object, int)
  - setSplineRoutingEnabled
```
public void setSplineRoutingEnabled(boolean flag)
```
    Sets whether the calculation of optimized spline control points is enabled. If spline links such as IlvSplineLinkImage and IlvGeneralLink are used, the bend points calculated by the layout algorithm are often suboptimal. This option enables the optimization of spline control points. It improves the result only if the splines use a smoothness between 0.1 and 0.9. See IlvSplineLinkImage.setSmoothness(double) and IlvGeneralLink.setCurved(double) for more information.
    Setting flag to true does not affect those links that are not reshaped by the layout algorithm or are routed as a straight line.
    This is an expert option. It is disabled by default.
    
    Overrides:
    
    setSplineRoutingEnabled in class IlvGraphLayout
    
    Parameters:
    
    flag - true to enable the optimization of spline control points, or false to disable it.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvGraphLayout.isSplineRoutingEnabled()
  - setMinSplineCurveSize
```
public void setMinSplineCurveSize(double size)
```
    Sets the minimum curve size used when optimized spline control point routing is enabled.
    The parameter works only if generic spline optimization routing is enabled.
    Bends in splines have a size that is described roughly by the triangle that surrounds the curve part of a bend. Spline routing tries to set the side length of this triangle at each bend between the minimum curve size and the maximum curve size.
    The default value is 5.
    
    Overrides:
    
    setMinSplineCurveSize in class IlvGraphLayout
    
    Parameters:
    
    size - The minimum spline curve size.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvGraphLayout.getMinSplineCurveSize(), setMaxSplineCurveSize(double), setSplineRoutingEnabled(boolean)
  - setMaxSplineCurveSize
```
public void setMaxSplineCurveSize(double size)
```
    Sets the maximum curve size used when optimized spline control point routing is enabled.
    The parameter only works if generic spline optimization routing is enabled. Bends in splines have a size that is described roughly by the triangle that surrounds the curve part of a bend. Spline routing tries to set the side length of this triangle at each bend between the minimum curve size and the maximum curve size.
    The default value is 30.
    
    Overrides:
    
    setMaxSplineCurveSize in class IlvGraphLayout
    
    Parameters:
    
    size - The maximum spline curve size.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvGraphLayout.getMaxSplineCurveSize(), setMinSplineCurveSize(double), setSplineRoutingEnabled(boolean)
  - setBalanceSplineCurveThreshold
```
public void setBalanceSplineCurveThreshold(double threshold)
```
    Sets the threshold for spline curves on arcs until the optimized spline control point routing tries to balance the curve.
    Bends in splines have a size that is described roughly by the triangle that surrounds the curve part of a bend. If the side length of the triangle is larger than the threshold, the algorithm tries to create an isosceles triangle. This results in more balanced bend curves. If the side length of the triangle is smaller than the threshold, the algorithm uses non-isosceles triangles. Isoscele triangles make the bend curve look too sharp.
    The default value is 10.
    Note: the parameter works only if the generic spline optimization routing is enabled.
    
    Overrides:
    
    setBalanceSplineCurveThreshold in class IlvGraphLayout
    
    Parameters:
    
    threshold - The balance spline curve threshold.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvGraphLayout.getBalanceSplineCurveThreshold(), setSplineRoutingEnabled(boolean)
  - setSplineLinkFilter
```
public void setSplineLinkFilter(IlvSplineLinkFilter filter)
```
    Sets the filter that detects which links are suitable for optimized spline routing.
    The filter detects which objects are splines, so that the optimized spline routing is only applied to splines, not to normal polyline links.
    The default spline link filter detects all links where the method IlvLinkImage.isSpline() returns true. It detects IlvSplineLinkImage, IlvCompositeLink and IlvGeneralLink objects with appropriate parameter settings as splines.
    Note: the parameter works only if the generic spline optimization routing is enabled.
    
    Overrides:
    
    setSplineLinkFilter in class IlvGraphLayout
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    IlvGraphLayout.getSplineLinkFilter(), setSplineRoutingEnabled(boolean)
  - setFixed
```
public void setFixed(Object nodeOrLink,
                     boolean fixed)
```
    Allows you to specify whether a link is fixed. In addition to the functionality in the base class, the Link Layout also dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a link as fixed on the Link Layout means that the link is fixed for both Short and Long Link Layouts.
    
    Overrides:
    
    setFixed in class IlvGraphLayout
    
    Parameters:
    
    nodeOrLink - Node or link instance which is part of the graph model.
    
    fixed - Indicates whether the object should remain fixed or not.
    
    See Also:
    
    IlvGraphLayout.isFixed(java.lang.Object), setPreserveFixedLinks(boolean), IlvGraphLayout.isPreserveFixedLinks(), IlvGraphLayout.unfixAllLinks()
  - 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(java.lang.Object, boolean)).
    - 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.
    - 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.
    Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.
    Parameters:
    
    mode - The global mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getGlobalOriginPointMode(), 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(java.lang.Object, boolean)).
    - 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.
    - 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.
    Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.
    Parameters:
    
    mode - The global mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getGlobalDestinationPointMode(), 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(java.lang.Object, boolean)).
    - 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.
    The default value is FREE_MODE.
    Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.
    Parameters:
    
    link - The link.
    
    mode - The mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getOriginPointMode(java.lang.Object), setGlobalOriginPointMode(int)
  - getOriginPointMode
```
public int getOriginPointMode(Object link)
```
    Returns the origin point mode of an individual link.
    
    Parameters:
    
    link - The link.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalOriginPointMode(int), setOriginPointMode(java.lang.Object, int)
  - setDestinationPointMode
```
public final void setDestinationPointMode(Object link,
                                          int mode)
```
    Sets the mode for the connection point on 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(java.lang.Object, boolean)).
    - 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.
    The default value is FREE_MODE.
    Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.
    Parameters:
    
    link - The link.
    
    mode - The mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getDestinationPointMode(java.lang.Object), setGlobalDestinationPointMode(int)
  - getDestinationPointMode
```
public int getDestinationPointMode(Object link)
```
    Returns the destination point mode of an individual link.
    
    Parameters:
    
    link - The link.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalDestinationPointMode(int), setDestinationPointMode(java.lang.Object, int)
  - setNodeBoxInterface
```
public final void setNodeBoxInterface(IlvNodeBoxInterface nodeBoxInterface)
```
    Allows you to specify a node box interface for the obstacle area. The node box interface is an object that provides the rectangle that determines the node box for each node. If none is given, the layout algorithm uses by default the bounding box of each node (see IlvGraphic.boundingBox(IlvTransformer) and IlvGraphModel.boundingBox(Object)) by default. This node box specifies the obstacle area of the node, that is, the area that links should avoid so they do not overlap the node. This can be different from the node box used to find the connection points of the links.
    You can call this method with a null argument to restore the default behavior.
    
    See Also:
    
    getNodeBoxInterface(), setLinkConnectionBoxInterface(ilog.views.graphlayout.IlvLinkConnectionBoxInterface), setLayoutMode(int)
  - getNodeBoxInterface
```
public final IlvNodeBoxInterface getNodeBoxInterface()
```
    Returns the node box interface used during the layout, or null if none is specified.
    
    See Also:
    
    setNodeBoxInterface(ilog.views.graphlayout.IlvNodeBoxInterface)
  - setLinkConnectionBoxInterface
```
public void setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface connectionBoxInterface)
```
    Allows you to specify a link connection box interface for the connection 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.
    By default, the layout algorithm places the connection points of the links relative to the bounding box of the nodes (see IlvGraphic.boundingBox(IlvTransformer) and IlvGraphModel.boundingBox(Object)).
    By setting a link connection box interface, the links can be connected relative to a different box (see getBox). In short link mode, the links are connected by default symmetrically to the middle of the box, and it is possible to "shift" the links tangentially by using the method getTangentialOffset from the interface IlvLinkConnectionBoxInterface:
    - On the "top" and "bottom" sides of a node, the connection points are moved to the right if the offset is positive and to the left if the offset is negative.
    - On the "left" and "right" sides of a node, the connection points are moved to the bottom if the offset is positive and to the top if the offset is negative.
    The tangential shift offsets are ignored in the long link mode.
    If you do not call this method, the layout algorithm places the connection points on the node box that has been customized using the method setNodeBoxInterface(ilog.views.graphlayout.IlvNodeBoxInterface). If this method has not been used, the bounding box of the node in the graph model is used (see IlvGraphModel.boundingBox(Object)).
    You can call this method with a null argument to restore the default behavior.
    Overrides:
    
    setLinkConnectionBoxInterface in class IlvGraphLayout
    
    See Also:
    
    supportsLinkConnectionBox(), IlvGraphLayout.getLinkConnectionBoxInterface(), setNodeBoxInterface(ilog.views.graphlayout.IlvNodeBoxInterface), setLayoutMode(int)
  - setNodeSideFilter
```
public final void setNodeSideFilter(IlvNodeSideFilter filter)
```
    Allows you to install a node-side filter, that is, an object that allows or prohibits the connection of the links on a given side of the nodes.
    When a filter is specified, the layout algorithm asks the filter at which side of its end node each link is allowed to attach. Note that a filter should always allow a link to connect to at least one side of a node; otherwise the link cannot be routed. If no node-side filter is installed, the layout algorithm is free to choose any side of the nodes.
    Note that the layout algorithm cannot always respect the specifications of the filter, especially for the DIRECT_STYLE link style.
    You can call this method with a null argument to restore the default behavior.
    
    See Also:
    
    getNodeSideFilter(), setLayoutMode(int), setGlobalLinkStyle(int), setLinkStyle(java.lang.Object, int)
  - getNodeSideFilter
```
public final IlvNodeSideFilter getNodeSideFilter()
```
    Returns the node-side filter used during layout, or null if none is specified.
    
    See Also:
    
    setNodeSideFilter(ilog.views.graphlayout.IlvNodeSideFilter)
  - setCoordinatesMode
```
public void setCoordinatesMode(int mode)
```
    Sets the coordinates mode.
    The default is IlvGraphLayout.INVERSE_VIEW_COORDINATES.
    
    Overrides:
    
    setCoordinatesMode in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvGraphLayout.getCoordinatesMode(), IlvGrapherAdapter.setCoordinatesMode(int), IlvGrapherAdapter.setReferenceTransformer(ilog.views.IlvTransformer), IlvGrapherAdapter.setReferenceView(IlvManagerView)
  - setUseDefaultParameters
```
public void setUseDefaultParameters(boolean option)
```
    If the argument is true, specifies that the layout use the default values of all the parameters; that is, the "get..." and "is..." methods return the default values.
    The default value of this parameter is false.
    
    Overrides:
    
    setUseDefaultParameters in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.isUseDefaultParameters()
  - setMinBusyTime
```
public void setMinBusyTime(long time)
```
    Sets the minimal time that the layout algorithm can be busy between two calls of layoutStepPerformed when the method callLayoutStepPerformedIfNeeded is used.
    The default value is 50 (milliseconds).
    
    Overrides:
    
    setMinBusyTime in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.layoutStepPerformed(), IlvGraphLayout.callLayoutStepPerformedIfNeeded(), IlvGraphLayout.getMinBusyTime()
  - setAllowedTime
```
public void setAllowedTime(long time)
```
    Sets an upper limit for the duration of the layout algorithm.
    The default value is 32000 (milliseconds).
    
    Overrides:
    
    setAllowedTime in class IlvGraphLayout
    
    Parameters:
    
    time - The allowed time in milliseconds.
    
    See Also:
    
    IlvGraphLayout.supportsAllowedTime(), IlvGraphLayout.getAllowedTime(), IlvGraphLayout.isLayoutTimeElapsed(), IlvGraphLayoutReport.getCode()
  - setInputCheckEnabled
```
public void setInputCheckEnabled(boolean enable)
```
    Enables the checks for the nodes and/or links provided as arguments for the different methods of this layout algorithm.
    It is enabled by default.
    
    Overrides:
    
    setInputCheckEnabled in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.isInputCheckEnabled()
  - setPreserveFixedLinks
```
public void setPreserveFixedLinks(boolean option)
```
    If the argument is true, specifies that the layout is not allowed to reshape the links indicated as fixed by the user. If the argument is false, the layout is free to reshape all the links of the grapher. (This does not change the setting for the fixed links, which can still be used at any time in the future.)
    The default value is false.
    
    Overrides:
    
    setPreserveFixedLinks in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.isPreserveFixedLinks(), IlvGraphLayout.setFixed(Object, boolean), IlvGraphLayout.isFixed(Object), IlvGraphLayout.supportsPreserveFixedLinks(), IlvGraphLayout.unfixAllLinks()
  - setAnimate
```
public void setAnimate(boolean option)
```
    Enables the animation mechanism.
    If the argument is true, the layout tries to redraw the graph during layout to show the progress of the layout. Note that to obtain a redraw of an IlvGrapher during animation, the method IlvGraphLayout.performLayout(boolean, boolean) must be called with the value true for the redraw argument.
    It is disabled by default.
    
    Overrides:
    
    setAnimate in class IlvGraphLayout
    
    See Also:
    
    IlvGraphLayout.isAnimate(), IlvGraphLayout.supportsAnimation()
  - stopImmediately
```
public boolean stopImmediately()
```
    Stops the running layout algorithm as soon as possible.
    This method can be used if multiple threads are used for layout and GUI control. The GUI control thread calls this method to notify the layout thread that the layout run must be stopped. The layout algorithm will perform some final cleanup operations before terminating. Therefore, the layout thread will continue until the cleanup operations are finished. The GUI thread, however, returns immediately from this method.
    If the layout algorithm is stopped before completion, the result code of the layout report is IlvGraphLayoutReport.STOPPED_AND_INVALID.
    
    Overrides:
    
    stopImmediately in class IlvGraphLayout
    
    Returns:
    
    true if the algorithm can be stopped at this point in time.
    
    See Also:
    
    IlvGraphLayoutReport.getCode()
  - 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 5.0
    
    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
  - setAutoCheckAppropriateLinksEnabled
```
public boolean setAutoCheckAppropriateLinksEnabled(boolean enable)
```
    Sets whether the layout checks whether links are appropriate. This is internally used. You should not use it.
    
    Overrides:
    
    setAutoCheckAppropriateLinksEnabled in class IlvGraphLayout
    
    Returns:
    
    The previous value.
    
    Since:
    
    JViews 8.5
  - 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()
  - setParametersUpToDate
```
public void setParametersUpToDate(boolean uptodate)
```
    This method is automatically called with a false argument each time the value of a parameter is changed. It is automatically called with a true argument each time the layout is successfully performed.
    
    Overrides:
    
    setParametersUpToDate in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isParametersUpToDate()
  - isParametersUpToDate
```
public boolean isParametersUpToDate()
```
    Returns false if at least one parameter was modified since the last time the layout was successfully performed on the same graph or if the layout has never been performed successfully on the same graph. Returns true if no changes occurred.
    
    Overrides:
    
    isParametersUpToDate in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setParametersUpToDate(boolean)
  - setStructureUpToDate
```
public void setStructureUpToDate(boolean uptodate)
```
    This method is normally called with a false argument if the structure of the graph changed. It is automatically called with a true argument each time the layout is successfully performed.
    
    Overrides:
    
    setStructureUpToDate in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isStructureUpToDate()
  - isStructureUpToDate
```
public boolean isStructureUpToDate()
```
    Returns false if at least one modification occurred in the structure of the graph since the last time the layout was successfully performed on the same graph or if the layout has never been performed successfully on the same graph. Returns true if no changes occurred.
    
    Overrides:
    
    isStructureUpToDate in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setParametersUpToDate(boolean)
  - setGeometryUpToDate
```
public void setGeometryUpToDate(boolean uptodate)
```
    This method is normally called with a false argument if the geometry of the graph changed. It is automatically called with a true argument each time the layout is successfully performed.
    
    Overrides:
    
    setGeometryUpToDate in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    isGeometryUpToDate()
  - isGeometryUpToDate
```
public boolean isGeometryUpToDate()
```
    Returns false if at least one node, link, label or obstacle was moved or reshaped since the last time the layout was successfully performed on the same graph or if the layout has never been performed successfully on the same graph. Returns true if no changes occurred.
    
    Overrides:
    
    isGeometryUpToDate in class IlvGraphLayout
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setGeometryUpToDate(boolean)
  - 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 setPreserveFixedLinks(boolean) is called with a true argument. The effect is very similar to the effect when the link is filtered during the layout.
    
    Overrides:
    
    supportsPreserveFixedLinks in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    IlvGrapherAdapter.setFilter(ilog.views.graphlayout.IlvLayoutGraphicFilter), IlvGraphLayout.setPreserveFixedLinks(boolean), IlvGraphLayout.isPreserveFixedLinks(), setGlobalLinkStyle(int), setLinkStyle(java.lang.Object, int)
  - supportsAnimation
```
public final boolean supportsAnimation()
```
    Indicates that this layout class supports the animation mechanism; that is, it can perform redraws to animate the layout process in some way.
    
    Overrides:
    
    supportsAnimation in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    IlvGraphLayout.setAnimate(boolean), IlvGraphLayout.isAnimate()
  - 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 Link Layout algorithm, some links may not be routed optimally. 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 final boolean supportsStopImmediately()
```
    Indicates that this layout class can interrupt the current run of the layout immediately in a controlled way. If interrupted, some links may not be routed optimally. The result code in the layout report is IlvGraphLayoutReport.STOPPED_AND_INVALID in this case.
    
    Overrides:
    
    supportsStopImmediately in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    IlvGraphLayout.stopImmediately(), IlvGraphLayout.isStoppedImmediately(), IlvGraphLayoutReport.getCode()
  - supportsLinkConnectionBox
```
public final boolean supportsLinkConnectionBox()
```
    Indicates that this layout class can use a link connection box interface to calculate the end points of a link. 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.
    The link connection box is used instead of the bounding box of each node (see IlvGraphic.boundingBox(IlvTransformer) and IlvGraphModel.boundingBox(Object)) during the routing of links. In short link mode, the connection rectangle and the tangential offsets are respected. In long link mode, only the connection rectangle is respected, and the tangential offsets provided by the link connection box interface are ignored.
    
    Overrides:
    
    supportsLinkConnectionBox in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setLinkConnectionBoxInterface(ilog.views.graphlayout.IlvLinkConnectionBoxInterface), setLayoutMode(int)
  - supportsSaveParametersToNamedProperties
```
public final boolean supportsSaveParametersToNamedProperties()
```
    Indicates that this layout class can transfer the layout parameters to named properties. This mechanism can be used if layout parameters must be stored persistently in an .ivl file.
    
    Overrides:
    
    supportsSaveParametersToNamedProperties in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()
  - supportsSplineRouting
```
public boolean supportsSplineRouting()
```
    Indicates that this class supports the generic optimization of spline control points. If spline links are used such as IlvSplineLinkImage and IlvGeneralLink, the bend points calculated by the layout algorithm are often suboptimal. A generic optimization mechanism is available that can be enabled by setSplineRoutingEnabled(boolean).
    This implementation returns true.
    
    Overrides:
    
    supportsSplineRouting in class IlvGraphLayout
    
    Returns:
    
    Always false.
    
    Since:
    
    JViews 8.1
    
    See Also:
    
    setSplineRoutingEnabled(boolean), setMinSplineCurveSize(double), setMaxSplineCurveSize(double), setBalanceSplineCurveThreshold(double), setSplineLinkFilter(ilog.views.graphlayout.IlvSplineLinkFilter)
  - createLayoutGrapherProperty
```
protected IlvGraphLayoutGrapherProperty createLayoutGrapherProperty(String name,
                                                                    boolean withDefaults)
```
    Returns a new instance of IlvLinkLayoutGrapherProperty 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
    
    See Also:
    
    IlvGraphLayoutGrapherProperty, IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()
  - createLayoutLinkProperty
```
protected IlvGraphLayoutLinkProperty createLayoutLinkProperty(String name,
                                                              IlvGraphic link,
                                                              boolean withDefaults)
```
    Returns a new instance of IlvLinkLayoutLinkProperty 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
    
    See Also:
    
    IlvGraphLayoutLinkProperty, IlvGrapherAdapter.saveParametersToNamedProperties(IlvGraphLayout, boolean), IlvGrapherAdapter.loadParametersFromNamedProperties(IlvGraphLayout), IlvGrapherAdapter.removeParametersFromNamedProperties()

Class IlvLinkLayout

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

ORTHOGONAL_STYLE

DIRECT_STYLE

MIXED_STYLE

NO_RESHAPE_STYLE

SHORT_LINKS

LONG_LINKS

FREE_MODE

FIXED_MODE

MIXED_MODE

Constructor Detail

IlvLinkLayout

IlvLinkLayout

Method Detail

init

copy

copyParameters

attach

detach

setGraphModel

layout

setLayoutMode

getLayoutMode

getShortLinkLayout

getLongLinkLayout

setAutoLayout

setLayoutRunning

setIncrementalMode

isIncrementalMode

markForIncremental

setInterGraphLinksMode

isInterGraphLinksMode

setCombinedInterGraphLinksMode

isCombinedInterGraphLinksMode

setLinkOffset

getLinkOffset

setHorizontalGridOffset

getHorizontalGridOffset

setVerticalGridOffset

getVerticalGridOffset

setHorizontalGridBase

getHorizontalGridBase

setVerticalGridBase

getVerticalGridBase

setHorizontalMinOffset

getHorizontalMinOffset

setVerticalMinOffset

getVerticalMinOffset

setMinNodeCornerOffset

getMinNodeCornerOffset

setMinFinalSegmentLength

getMinFinalSegmentLength

setGlobalLinkStyle

getGlobalLinkStyle

setLinkStyle

getLinkStyle

setSplineRoutingEnabled

setMinSplineCurveSize

setMaxSplineCurveSize

setBalanceSplineCurveThreshold

setSplineLinkFilter

setFixed

setGlobalOriginPointMode

getGlobalOriginPointMode

setGlobalDestinationPointMode

getGlobalDestinationPointMode

setOriginPointMode

getOriginPointMode

setDestinationPointMode

getDestinationPointMode

setNodeBoxInterface

getNodeBoxInterface

setLinkConnectionBoxInterface