IlvLongLinkLayout (Perforce JViews 10.0 API)

java.lang.Object
- ilog.views.graphlayout.IlvGraphLayout
- - ilog.views.graphlayout.link.longlink.IlvLongLinkLayout

All Implemented Interfaces:

GraphModelListener, Serializable, EventListener
```
public class IlvLongLinkLayout
extends IlvGraphLayout
```
The main class for the Long Link Layout algorithm.
The Long Link Layout algorithm reshapes the links of a graph without moving the nodes. It is specialized to route long orthogonal links on a grid without overlapping nodes. It uses a classical path search mechanism and an additional crossing reduction phase. It can be used to find an orthogonal route without overlaps in a labyrinth of node obstacles.

Optionally, direct links can be computed, which, however, may overlap nodes. See the method setGlobalLinkStyle(int).

This layout algorithm is recommended 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 minimum distance between link segments.
- An increasing number of bends is acceptable if this avoids any overlaps.
Otherwise, the IlvShortLinkLayout may be more suitable.
Here are sample drawings produced by the Long Link Layout:

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

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, all links are routed. In incremental mode, only those links are routed that overlap nodes or whose end nodes have changed. The incremental mode cannot be used for intergraph links.
- 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`	`MIXED_MODE` Mixed connection point mode.
`static int`	`MIXED_STYLE` Mixed link shape option.
`static int`	`NO_RESHAPE_STYLE` No reshape link style option.
`static int`	`ORTHOGONAL_STYLE` Orthogonal link shape option.

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

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addLineObstacle(IlvPoint p1, IlvPoint p2)` Adds a line segment obstacle for link routing.
`void`	`addLineObstacle(IlvRect obstacleBoundingBox)` Adds a line segment obstacle for the routing.
`void`	`addRectObstacle(IlvRect obstacleBoundingBox)` Adds a rectangular obstacle for the routing.
`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 `IlvLongLinkLayoutGrapherProperty` that stores the parameter settings of this layout class.
`protected IlvGraphLayoutLinkProperty`	`createLayoutLinkProperty(String name, IlvGraphic link, boolean withDefaults)` Returns a new instance of `IlvLongLinkLayoutLinkProperty` that stores the parameter settings of this layout class for links.
`IlvGraphLayoutReport`	`createLayoutReport()` Creates the graph layout report instance.
`void`	`detach()` Detaches the graph model from the layout instance.
`long`	`getAllowedTimePerLink()` Returns the upper limit for the time allowed to find a route for a long link in milliseconds.
`Enumeration`	`getCalcFallbackLinks()` Returns the links that could not be routed on the grid without obstacle overlaps by the previous layout call.
`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 minimum horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
`int`	`getLinkStyle(Object link)` Returns the style for the shape of an individual link.
`int`	`getMaxBacktrack()` Returns the maximum number of backtrack steps to find a route for a long link.
`double`	`getMinEndSegmentLength()` Returns the minimum length of the last segment of each link.
`double`	`getMinNodeCornerOffset()` Returns the minimum offset between a node corner and a link starting at this node.
`double`	`getMinStartSegmentLength()` Returns the minimum length of the first segment of each link.
`IlvNodeBoxInterface`	`getNodeBoxInterface()` Returns the node box interface used for the obstacle area during the layout.
`IlvNodeSideFilter`	`getNodeSideFilter()` Returns the node-side filter used during layout.
`int`	`getNumberCrossingReductionIterations()` Returns the maximum number of iterations performed during crossing reduction.
`int`	`getOriginPointMode(Object link)` Returns the origin-point mode of an individual link.
`IlvTerminationPointFilter`	`getTerminationPointFilter()` Returns the termination point filter used during layout.
`double`	`getVerticalGridBase()` Returns the vertical base coordinate of the grid.
`double`	`getVerticalGridOffset()` Returns the vertical offset between the grid lines.
`double`	`getVerticalMinOffset()` Returns the minimum 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`	`isCrossingReductionEnabled()` Returns `true` if crossing reduction is enabled.
`boolean`	`isExhaustiveSearching()` Returns `true` if routing uses exhaustive searching.
`boolean`	`isFallbackRouteEnabled()` Returns `true` if the fallback routing algorithm is enabled.
`boolean`	`isFromPointFixed()` Deprecated. Beginning with JViews 5.5, use the method `getGlobalOriginPointMode()` instead.
`boolean`	`isIncrementalConnectionPreserving()` Returns `true` if the incremental mode preserves the side and relative order of the link connection points.
`boolean`	`isIncrementalMode()` Returns `true` if the incremental mode is enabled.
`boolean`	`isInterGraphLinksMode()` Returns `true` if the routing of intergraph links is enabled.
`boolean`	`isLinkObstacleEnabled()` Returns `true` if links should be line obstacles for the link routes.
`boolean`	`isNodeObstacleEnabled()` Returns `true` if nodes should be obstacles for the link routes.
`boolean`	`isStraightRouteEnabled()` Returns `true` if straight routing is enabled.
`boolean`	`isToPointFixed()` Deprecated. Beginning with JViews 5.5, use the method `getGlobalDestinationPointMode()` instead.
`protected void`	`layout(boolean redraw)` Computes the layout using the Long Link Layout algorithm.
`void`	`layoutStepPerformed()` Can be called by the layout classes when a step of the layout algorithm has been performed.
`void`	`markForIncremental(Object link)` Marks the input link to be rerouted with the next call of `IlvGraphLayout.performLayout()`, if incremental mode is enabled.
`void`	`removeAllLineObstacles()` Removes all additional line obstacles.
`void`	`removeAllRectObstacles()` Removes all additional rectangular obstacles.
`void`	`setAllowedTimePerLink(long time)` Sets the upper limit for the time allowed to find a route for a long link.
`void`	`setCombinedInterGraphLinksMode(boolean enable)` Sets the routing of normal links in addition to intergraph links.
`void`	`setCrossingReductionEnabled(boolean flag)` Sets the crossing reduction.
`void`	`setDestinationPointMode(Object link, int mode)` Sets the mode for the connection point of an individual link on the destination node.
`void`	`setExhaustiveSearching(boolean flag)` Sets the exhaustive searching of routes for links.
`void`	`setFallbackRouteEnabled(boolean flag)` Sets whether the fallback routing algorithm is enabled.
`void`	`setFromPointFixed(boolean flag)` Deprecated. Beginning with JViews 5.5, use the method `setGlobalOriginPointMode(int)` instead.
`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`	`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 minOffset)` Sets the minimum horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
`void`	`setIncrementalConnectionPreserving(boolean flag)` Sets whether the incremental layout mode preserves the side and relative order of the link connection points.
`void`	`setIncrementalMode(boolean enable)` Sets the incremental layout mode.
`void`	`setInterGraphLinksMode(boolean enable)` Sets the routing of intergraph links.
`void`	`setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface connectionBoxInterface)` Sets the link connection box interface for the connection points of links.
`void`	`setLinkObstacleEnabled(boolean flag)` Sets whether links should be line obstacles for the link routes.
`void`	`setLinkStyle(Object link, int style)` Sets the style for the shape of an individual link.
`void`	`setMaxBacktrack(int numberOfSteps)` Sets the maximum number of backtrack steps to find a route for a long link.
`void`	`setMinEndSegmentLength(double length)` Sets the minimum length of the last segment of each link, that is, the segment incident to the "to" node.
`void`	`setMinNodeCornerOffset(double offset)` Sets the minimum offset between a node corner and a link starting at this node.
`void`	`setMinStartSegmentLength(double length)` Sets the minimum length of the first segment of each link, that is, the segment incident to the "from" node.
`void`	`setNodeBoxInterface(IlvNodeBoxInterface nodeBoxInterface)` Sets the node box interface for the obstacle area.
`void`	`setNodeObstacleEnabled(boolean flag)` Sets whether nodes should be obstacles for the link routes.
`void`	`setNodeSideFilter(IlvNodeSideFilter filter)` Sets the node-side filter, that is, an object that allows or prohibits the connection of the links on a given side of the nodes.
`void`	`setNumberCrossingReductionIterations(int iterations)` Sets the maximum number of iterations performed during crossing reduction.
`void`	`setOriginPointMode(Object link, int mode)` Sets the mode for the connection point on an individual link on the origin node.
`void`	`setStraightRouteEnabled(boolean flag)` Sets the straight routing.
`void`	`setTerminationPointFilter(IlvTerminationPointFilter filter)` Sets the termination point filter, that is, an object that allows filtering the termination points that are proposed by the layout algorithm.
`void`	`setToPointFixed(boolean flag)` Deprecated. Beginning with JViews 5.5, use the method `setGlobalDestinationPointMode(int)` instead.
`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 minOffset)` Sets the minimum vertical offset between the node border and a link segment that is (horizontally) parallel to the node border.
`boolean`	`stopImmediately()` Stops the running of the 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 process of layout 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`	`supportsPercentageComplete()` Indicates that this layout class can estimate the percentage of completion during the run of layout.
`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()` Tests if this class supports the generic optimization of spline control points.
`boolean`	`supportsStopImmediately()` Indicates that this layout class can interrupt the current run of the layout immediately in a controlled way.

Methods inherited from class ilog.views.graphlayout.IlvGraphLayout
addGraphLayoutEventListener, addGraphLayoutParameterEventListener, afterLayoutOfSubgraph, attach, attach, beforeLayout, beforeLayoutOfSubgraph, callLayoutStepPerformedIfNeeded, cleanGraphModel, clipAllLinks, clipLink, connectAllLinksToCenter, connectLinkToCenter, contentsChanged, createLayoutNodeProperty, 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, isGeometryUpToDate, isInputCheckEnabled, isLayoutNeeded, isLayoutOfConnectedComponentsEnabled, isLayoutOfConnectedComponentsEnabledByDefault, isLayoutRunning, isLayoutRunning, isLayoutTimeElapsed, isLocalRecursiveLayoutNeeded, isMemorySavings, isParametersUpToDate, isPreserveFixedLinks, isPreserveFixedNodes, isSplineRoutingEnabled, isStoppedImmediately, isStructureUpToDate, isUseDefaultParameters, isUseSeedValueForRandomGenerator, onParameterChanged, onParameterChanged, performAutoLayout, performLayout, performLayout, performLayout, PerformLayout, performSublayout, removeGraphLayoutEventListener, removeGraphLayoutParameterEventListener, setAllowedTime, setAnimate, setAutoCheckAppropriateLinksEnabled, setAutoLayout, setAutoLayoutHandler, setBalanceSplineCurveThreshold, setCoordinatesMode, setFixed, setGeometryUpToDate, setGrapher, setGraphModel, setInputCheckEnabled, setLayoutOfConnectedComponents, setLayoutOfConnectedComponentsEnabled, setLayoutRegion, setLayoutRegion, setLayoutRegion, setLayoutReport, setLayoutRunning, setLinkClipInterface, setMaxSplineCurveSize, setMemorySavings, setMinBusyTime, setMinSplineCurveSize, setParametersUpToDate, setParentLayout, setPreserveFixedLinks, setPreserveFixedNodes, setProperty, setProperty, setSeedValueForRandomGenerator, setSplineLinkFilter, setSplineRoutingEnabled, setStructureUpToDate, setUseDefaultParameters, setUseSeedValueForRandomGenerator, supportsLayoutOfConnectedComponents, supportsLayoutRegion, supportsLinkClipping, supportsMemorySavings, 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 shape option. When used as the argument of the method setGlobalLinkStyle(int), all links get an orthogonal shape (alternating horizontal and vertical segments).
    To specify the shape of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), Constant Field Values
  - DIRECT_STYLE
```
public static final int DIRECT_STYLE
```
    Direct link style option. When used as the argument of the method setGlobalLinkStyle(int), all links get a (semi)direct shape.
    This link shape may cause overlaps between links and nodes. To specify the style of an individual link, use this option as the argument of the method setLinkStyle(Object, int).
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), Constant Field Values
  - MIXED_STYLE
```
public static final int MIXED_STYLE
```
    Mixed link shape option. When used as the argument of the method setGlobalLinkStyle(int), each link can have a different shape. The shape of an individual link can be set by the method setLinkStyle(Object, int).
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int), 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:
    
    setLinkStyle(Object, int), 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(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:
    
    setGlobalOriginPointMode(int), setGlobalDestinationPointMode(int), setOriginPointMode(Object, int), setDestinationPointMode(Object, int), 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(Object, int) or setDestinationPointMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalOriginPointMode(int), setGlobalDestinationPointMode(int), setOriginPointMode(Object, int), setDestinationPointMode(Object, int), 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(Object, int) or setDestinationPointMode(Object, int).
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    setGlobalOriginPointMode(int), setGlobalDestinationPointMode(int), setOriginPointMode(Object, int), setDestinationPointMode(Object, int), Constant Field Values
- Constructor Detail
  - IlvLongLinkLayout
```
public IlvLongLinkLayout()
```
    Creates a new instance of the Long 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 IlvGraphLayout.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)
  - IlvLongLinkLayout
```
public IlvLongLinkLayout(IlvLongLinkLayout 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 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, termination point filter) are also copied.
    
    Specified by:
    
    copy in class IlvGraphLayout
    
    Returns:
    
    A copy of the layout instance.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    copyParameters(IlvGraphLayout), setNodeBoxInterface(IlvNodeBoxInterface), setNodeSideFilter(IlvNodeSideFilter), setTerminationPointFilter(IlvTerminationPointFilter)
  - 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, termination point filter) 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(IlvNodeBoxInterface), setNodeSideFilter(IlvNodeSideFilter), setTerminationPointFilter(IlvTerminationPointFilter)
  - detach
```
public void detach()
```
    Detaches the graph model from the layout instance. When you attach a new graph model to the layout instance, you do not need to detach the old graph model because this is done automatically when you call IlvGraphLayout.attach(ilog.views.graphlayout.IlvGraphModel).
    The method performs cleaning operations on the graph model. In addition to the cleaning operations in the base class, the Long 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:
    
    IlvGraphLayout.attach(ilog.views.graphlayout.IlvGraphModel), setLinkStyle(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.
    The method is automatically called by IlvGraphLayout.contentsChanged(GraphModelEvent) whenever a GraphModelEvent of type GraphModelEvent.NODE_REMOVED is received.
    
    Subclasses can override this method to remove additional information stored in the nodes.
    
    Notice that the method may be called multiple times for the same node. At the time this method is called, the node may already be removed; therefore, overridden versions of this method should be implemented so that they work even if the object is no longer a node of graphModel.
    
    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(), IlvGraphModel.dispose()
  - 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.
    The method is automatically called by IlvGraphLayout.contentsChanged(GraphModelEvent) whenever a GraphModelEvent of type GraphModelEvent.LINK_REMOVED is received.
    
    Subclasses can override this method to remove additional information stored in the links.
    
    Notice that the method may be called multiple times for the same link. At the time this method is called, the link may already be removed; therefore, overridden versions of this method should be implemented so that they work even if the object is no longer a link of graphModel.
    
    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(), IlvGraphModel.dispose()
  - layout
```
protected void layout(boolean redraw)
               throws IlvGraphLayoutException,
                      IlvInappropriateLinkException
```
    Computes the layout using the Long 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()
  - createLayoutReport
```
public IlvGraphLayoutReport createLayoutReport()
```
    Creates the graph layout report instance.
    
    Overrides:
    
    createLayoutReport in class IlvGraphLayout
    
    Returns:
    
    A new instance of layout report. The current implementation creates an instance of IlvLongLinkLayoutReport.
    
    See Also:
    
    IlvGraphLayout.createLayoutReport(), IlvLongLinkLayoutReport
  - 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. The effect is very similar to the effect when the links are filtered during 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(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 process of layout 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 Long Link Layout algorithm, the links are not reshaped 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 final boolean supportsStopImmediately()
```
    Indicates that this layout class can interrupt the current run of the layout immediately in a controlled way. If interrupted, the links are not reshaped 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.
    
    See Also:
    
    IlvGraphLayout.stopImmediately(), IlvGraphLayout.isStoppedImmediately(), IlvGraphLayoutReport.getCode()
  - stopImmediately
```
public boolean stopImmediately()
```
    Stops the running of the layout algorithm as soon as possible.
    The Long Link Layout algorithm has several steps. In the first steps, the layout algorithm can be stopped and the method returns true. In the very last step, the layout algorithm cannot be stopped and the method returns false.
    
    Overrides:
    
    stopImmediately in class IlvGraphLayout
    
    Returns:
    
    true if the layout algorithm can be stopped.
    
    See Also:
    
    IlvGraphLayoutReport.getCode(), IlvGraphLayout.supportsStopImmediately(), IlvGraphLayout.isStoppedImmediately()
  - supportsPercentageComplete
```
public final boolean supportsPercentageComplete()
```
    Indicates that this layout class can estimate the percentage of completion during the run of layout.
    
    Overrides:
    
    supportsPercentageComplete in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    See Also:
    
    IlvGraphLayout.increasePercentageComplete(int), IlvGraphLayoutReport.getPercentageComplete(), IlvJGraphLayoutProgressBar
  - 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.
    The link connection box is used instead of the bounding box of each node (see IlvGraphic.boundingBox(ilog.views.IlvTransformer) and IlvGraphModel.boundingBox(Object) ) during the routing of links. The tangential offsets provided by the link connection box interface are currently ignored.
    
    Overrides:
    
    supportsLinkConnectionBox in class IlvGraphLayout
    
    Returns:
    
    Always true.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface)
  - supportsSaveParametersToNamedProperties
```
public 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()
```
    Tests if this class supports the generic optimization of spline control points. If spline links such as IlvSplineLinkImage and IlvGeneralLink are used, the bend points calculated by the layout algorithm are often suboptimal. A generic optimization mechanism can be 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)
  - setHorizontalGridOffset
```
public final void setHorizontalGridOffset(double offset)
```
    Sets the horizontal offset between the grid lines. Links are routed on an orthogonal grid.
    The default value is 5.
    
    See Also:
    
    getHorizontalGridOffset(), setHorizontalMinOffset(double), setHorizontalGridBase(double)
  - getHorizontalGridOffset
```
public final double getHorizontalGridOffset()
```
    Returns the horizontal offset between the grid lines.
    
    See Also:
    
    setHorizontalGridOffset(double)
  - setVerticalGridOffset
```
public final void setVerticalGridOffset(double offset)
```
    Sets the vertical offset between the grid lines. Links are routed on an orthogonal grid.
    The default value is 5.
    
    See Also:
    
    getVerticalGridOffset(), setVerticalMinOffset(double), setVerticalGridBase(double)
  - getVerticalGridOffset
```
public final double getVerticalGridOffset()
```
    Returns the vertical offset between the grid lines.
    
    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. Links are routed on an orthogonal grid.
    The default value is 0.
    
    See Also:
    
    getHorizontalGridBase(), setHorizontalGridOffset(double)
  - getHorizontalGridBase
```
public final double getHorizontalGridBase()
```
    Returns the horizontal base coordinate of the grid.
    
    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. Links are routed on an orthogonal grid.
    The default value is 0.
    
    See Also:
    
    getVerticalGridBase(), setVerticalGridOffset(double)
  - getVerticalGridBase
```
public final double getVerticalGridBase()
```
    Returns the vertical base coordinate of the grid.
    
    See Also:
    
    setVerticalGridBase(double)
  - setHorizontalMinOffset
```
public final void setHorizontalMinOffset(double minOffset)
```
    Sets the minimum horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
    The default value is 3.
    
    See Also:
    
    getHorizontalMinOffset(), setHorizontalGridOffset(double)
  - getHorizontalMinOffset
```
public final double getHorizontalMinOffset()
```
    Returns the minimum horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
    
    See Also:
    
    setHorizontalMinOffset(double)
  - setVerticalMinOffset
```
public final void setVerticalMinOffset(double minOffset)
```
    Sets the minimum vertical offset between the node border and a link segment that is (horizontally) parallel to the node border.
    The default value is 3.
    
    See Also:
    
    getVerticalMinOffset(), setVerticalGridOffset(double)
  - getVerticalMinOffset
```
public final double getVerticalMinOffset()
```
    Returns the minimum vertical offset between the node border and a link segment that is (horizontally) parallel to the node border.
    
    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.
    The default value is 3.
    
    See Also:
    
    getMinNodeCornerOffset()
  - getMinNodeCornerOffset
```
public final double getMinNodeCornerOffset()
```
    Returns the minimum offset between a node corner and a link starting at this node.
    
    See Also:
    
    setMinNodeCornerOffset(double)
  - setMinStartSegmentLength
```
public final void setMinStartSegmentLength(double length)
```
    Sets the minimum length of the first segment of each link, that is, the segment incident to the "from" node.
    The default value is 10.
    
    See Also:
    
    getMinStartSegmentLength(), setMinEndSegmentLength(double)
  - getMinStartSegmentLength
```
public final double getMinStartSegmentLength()
```
    Returns the minimum length of the first segment of each link.
    
    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 incident to the "to" node.
    The default value is 10.
    
    See Also:
    
    getMinEndSegmentLength(), setMinStartSegmentLength(double)
  - getMinEndSegmentLength
```
public final double getMinEndSegmentLength()
```
    Returns the minimum length of the last segment of each link.
    
    See Also:
    
    setMinEndSegmentLength(double)
  - setAllowedTimePerLink
```
public final void setAllowedTimePerLink(long time)
```
    Sets the upper limit for the time allowed to find a route for a long link. The algorithm tries to find a short route for the link. It uses a backtrack mechanism to find a route that bypasses obstacles. The runtime of the backtrack can be large if the size of the drawing area is large and the grid offset is small. The algorithm stops the backtrack when the specified time is elapsed and gives up without result.
    The default value is 2000 (2 seconds).
    
    Note that the specified time is valid for each single link, that is, the maximum time to find routes for all links is approximately the specified time per link multiplied by the number of links. However, this happens only extremely seldom. The algorithm will most likely find a route for the majority of the links before the time elapses; therefore, the average time to find routes for all links is much smaller.
    
    If the specified time elapsed for a link and the fallback routing is enabled, the link is quickly routed by the fallback mechanism instead.
    
    See Also:
    
    setMaxBacktrack(int), setHorizontalGridOffset(double), setVerticalGridOffset(double), setFallbackRouteEnabled(boolean)
  - getAllowedTimePerLink
```
public final long getAllowedTimePerLink()
```
    Returns the upper limit for the time allowed to find a route for a long link in milliseconds.
    
    See Also:
    
    setAllowedTimePerLink(long)
  - setMaxBacktrack
```
public final void setMaxBacktrack(int numberOfSteps)
```
    Sets the maximum number of backtrack steps to find a route for a long link. The algorithm tries to find a short route for the link. The backtrack number indicates that the algorithm tries to find a route that is so many grid points longer than the shortest possible route before it gives up the search.
    Decreasing the value causes the algorithm to give up earlier without result. If the "from" point and "to" point are fixed, this speeds up the search. Otherwise, the time behavior is more complex, so it may speed up or slow down the search.
    
    The default value is 30000.
    
    If the maximum number of backtrack steps is exceeded and the fallback routing is enabled, the link is quickly routed by the fallback mechanism instead.
    
    See Also:
    
    getMaxBacktrack(), setFromPointFixed(boolean), setToPointFixed(boolean), setFallbackRouteEnabled(boolean)
  - getMaxBacktrack
```
public final int getMaxBacktrack()
```
    Returns the maximum number of backtrack steps to find a route for a long link.
    
    See Also:
    
    setMaxBacktrack(int)
  - setGlobalLinkStyle
```
public final void setGlobalLinkStyle(int style)
```
    Sets the global style of the shapes of links. Valid values are:
    - ORTHOGONAL_STYLE - all links get 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 setMinStartSegmentLength(double) and setMinEndSegmentLength(double) and may be 0). In this link style, links may overlap nodes.
    - 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 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(Object, 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 style for 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:
    - ORTHOGONAL_STYLE - the link gets 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 setMinStartSegmentLength(double) and setMinEndSegmentLength(double) and may be 0). In this link style, links may overlap nodes.
    - NO_RESHAPE_STYLE - the link is not reshaped.
    The default value is ORTHOGONAL_STYLE.
    
    When the graph attached to the layout is of type IlvGrapher, the effect of link reshaping depends on the type of links and the connectors installed at the node. For all link styles, you are recommended to use 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 methods IlvGraphLayoutUtil.EnsureAppropriateLinkTypes(ilog.views.graphlayout.IlvGraphLayout, boolean) and 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.
    Parameters:
    
    link - The link instance.
    
    style - The style for the shape of an individual link.
    
    See Also:
    
    getLinkStyle(Object), setGlobalLinkStyle(int)
  - getLinkStyle
```
public int getLinkStyle(Object link)
```
    Returns the style for the shape of an individual link.
    
    Parameters:
    
    link - The link instance.
    
    Returns:
    
    The style for the shape of an individual link. Possible values are: ORTHOGONAL_STYLE, DIRECT_STYLE, NO_RESHAPE_STYLE.
    
    See Also:
    
    setGlobalLinkStyle(int), setLinkStyle(Object, int)
  - setExhaustiveSearching
```
public final void setExhaustiveSearching(boolean flag)
```
    Sets the exhaustive searching of routes for links. If this option is enabled, the algorithm examines the complete grid exhaustively to find a route for an orthogonal link. This may result in fewer bends, but it takes a huge amount of runtime for large graphs.
    Exhaustive searching is disabled by default.
    
    See Also:
    
    isExhaustiveSearching()
  - isExhaustiveSearching
```
public final boolean isExhaustiveSearching()
```
    Returns true if routing uses exhaustive searching.
    
    See Also:
    
    setExhaustiveSearching(boolean)
  - setStraightRouteEnabled
```
public final void setStraightRouteEnabled(boolean flag)
```
    Sets the straight routing. If this option is enabled, the algorithm makes an additional attempt to find a route with zero or one bend before starting the normal backtrack mechanism. As result, the layout has fewer bends, but the distribution of links at the border may become uneven.
    Straight routing is enabled by default.
    
    See Also:
    
    isStraightRouteEnabled()
  - isStraightRouteEnabled
```
public final boolean isStraightRouteEnabled()
```
    Returns true if straight routing is enabled.
    
    See Also:
    
    setStraightRouteEnabled(boolean)
  - setCrossingReductionEnabled
```
public final void setCrossingReductionEnabled(boolean flag)
```
    Sets the crossing reduction. If this option is enabled, the algorithm tries to reduce the crossings between orthogonal links that are routed.
    Crossing reduction is enabled by default.
    
    See Also:
    
    isCrossingReductionEnabled(), setNumberCrossingReductionIterations(int)
  - isCrossingReductionEnabled
```
public final boolean isCrossingReductionEnabled()
```
    Returns true if crossing reduction is enabled.
    
    See Also:
    
    setCrossingReductionEnabled(boolean)
  - setNumberCrossingReductionIterations
```
public final void setNumberCrossingReductionIterations(int iterations)
```
    Sets the maximum number of iterations performed during crossing reduction. This option has an effect only if crossing reduction is enabled. Reducing the value speeds up the algorithm, but the layout may contain more link crossings.
    The default value is 2.
    
    See Also:
    
    setCrossingReductionEnabled(boolean), getNumberCrossingReductionIterations()
  - getNumberCrossingReductionIterations
```
public final int getNumberCrossingReductionIterations()
```
    Returns the maximum number of iterations performed during crossing reduction.
    
    See Also:
    
    setNumberCrossingReductionIterations(int)
  - 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)).
    - 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.
      Note that, in this mode, the first segment of a link is not placed on the grid. Therefore, the first segment may be closer than the specified minimum offset to neighbor links, or may even overlap them if they start at the same fixed point.
      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.
    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(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.
      Note that, in this mode, the first segment of a link is not placed on the grid. Therefore, the first segment may be closer than the specified minimum offset to neighbor links, or may even overlap them if they start at the same fixed point.
      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.
    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(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.
      Note that, in this mode, the first segment of a link is not placed on the grid. Therefore, the first segment may be closer than the specified minimum offset to neighbor links, or may even overlap them if they start at the same fixed point.
      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.
    Parameters:
    
    link - The link.
    
    mode - The mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getOriginPointMode(Object), setGlobalOriginPointMode(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)).
    - 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.
      In this mode, the first segment of a link is not placed on the grid. Therefore, the first segment may be closer than the specified minimum offset to neighbor links, or may even overlap them if they start at the same fixed point.
      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.
    Parameters:
    
    link - The link.
    
    mode - The mode to set.
    
    Since:
    
    JViews 5.5
    
    See Also:
    
    getDestinationPointMode(Object), setGlobalDestinationPointMode(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)
  - setFromPointFixed
```
public final void setFromPointFixed(boolean flag)
```
    Deprecated. Beginning with JViews 5.5, use the method setGlobalOriginPointMode(int) instead.
    
    Sets the routing that starts from a fixed point at the "from" node. If this option is disabled, the algorithm searches for an appropriate start point at the "from" node of a link. However, 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 algorithm should use this pin as the start point instead of searching for its own start point for the routing. In this case, routing from a fixed point should be enabled.
    It is disabled by default.
    
    Note that when routing from a fixed point is enabled, the first segment of a link is not placed on the grid. Therefore, the first segment may be closer than the specified minimum offset to neighbor links, or may even overlap them if they start at the same fixed point.
    
    See Also:
    
    isFromPointFixed(), IlvPinLinkConnector
  - isFromPointFixed
```
public final boolean isFromPointFixed()
```
    Deprecated. Beginning with JViews 5.5, use the method getGlobalOriginPointMode() instead.
    
    Returns true if routing from a fixed "from" point is enabled.
    
    See Also:
    
    setFromPointFixed(boolean)
  - setToPointFixed
```
public final void setToPointFixed(boolean flag)
```
    Deprecated. Beginning with JViews 5.5, use the method setGlobalDestinationPointMode(int) instead.
    
    Sets the routing that ends at a fixed point at the "to" node. If this option is disabled, the algorithm searches for an appropriate end point at the "to" node of a link. However, 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 algorithm should use this pin as the end point instead of searching for its own end point for the routing. In this case, routing to a fixed point should be enabled.
    It is disabled by default.
    
    Note that when routing to a fixed point is enabled, the last segment of a link is not placed on the grid. Therefore, the last segment may be closer than the specified minimum offset to neighbor links, or may even overlap them if they end at the same fixed point.
    
    See Also:
    
    isToPointFixed(), IlvPinLinkConnector
  - isToPointFixed
```
public final boolean isToPointFixed()
```
    Deprecated. Beginning with JViews 5.5, use the method getGlobalDestinationPointMode() instead.
    
    Returns true if routing to a fixed "to" point is enabled.
    
    See Also:
    
    setToPointFixed(boolean)
  - setIncrementalMode
```
public final void setIncrementalMode(boolean enable)
```
    Sets 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 start and end segments have changed,
    - if the link now overlaps obstacles that were moved or resized,
    - if the link is no longer on the grid,
    - if the link is marked for incremental rerouting.
    The links preserve the side and relative order of their connection points from the previous layout, if this mode is selected by setIncrementalConnectionPreserving(boolean).
    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.
    See Also:
    
    isIncrementalMode(), setGlobalLinkStyle(int), setFromPointFixed(boolean), setToPointFixed(boolean), setMinStartSegmentLength(double), setMinEndSegmentLength(double), markForIncremental(Object), setInterGraphLinksMode(boolean)
  - isIncrementalMode
```
public final boolean isIncrementalMode()
```
    Returns true if the incremental mode is enabled.
    
    See Also:
    
    setIncrementalMode(boolean)
  - setIncrementalConnectionPreserving
```
public final void setIncrementalConnectionPreserving(boolean flag)
```
    Sets whether the incremental layout mode preserves the side and relative order of the link connection points. The default is false.
    
    See Also:
    
    setIncrementalMode(boolean), isIncrementalConnectionPreserving()
  - isIncrementalConnectionPreserving
```
public final boolean isIncrementalConnectionPreserving()
```
    Returns true if the incremental mode preserves the side and relative order of the link connection points.
    
    See Also:
    
    setIncrementalConnectionPreserving(boolean)
  - markForIncremental
```
public final void markForIncremental(Object link)
```
    Marks the input link to be rerouted with the next call of IlvGraphLayout.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.
    
    Parameters:
    
    link - The link instance.
    
    See Also:
    
    setIncrementalMode(boolean), IlvGraphLayout.performLayout()
  - setInterGraphLinksMode
```
public final void setInterGraphLinksMode(boolean enable)
```
    Sets 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 the combined intergraph link routing is enabled in additional, 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), IlvGraphLayout.setAnimate(boolean), setIncrementalMode(boolean), IlvGraphModel.isInterGraphLink(Object)
  - isInterGraphLinksMode
```
public final boolean isInterGraphLinksMode()
```
    Returns true if the routing of intergraph links is enabled. It returns false otherwise.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setInterGraphLinksMode(boolean)
  - setCombinedInterGraphLinksMode
```
public final void setCombinedInterGraphLinksMode(boolean enable)
```
    Sets 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(Object)
  - isCombinedInterGraphLinksMode
```
public final boolean isCombinedInterGraphLinksMode()
```
    Returns true if the routing of normal links in addition to intergraph links is enabled. Returns false otherwise.
    
    Since:
    
    JViews 5.0
    
    See Also:
    
    setInterGraphLinksMode(boolean), setCombinedInterGraphLinksMode(boolean)
  - setNodeObstacleEnabled
```
public final void setNodeObstacleEnabled(boolean flag)
```
    Sets whether nodes should be obstacles for the link routes. The default is true. There are, however, situations where it may be suitable to consider a set of obstacles different from the nodes. In this case you can switch nodes as obstacles off and use the method addRectObstacle(IlvRect) to specify the obstacles that are needed.
    
    See Also:
    
    isNodeObstacleEnabled()
  - isNodeObstacleEnabled
```
public final boolean isNodeObstacleEnabled()
```
    Returns true if nodes should be obstacles for the link routes.
    
    See Also:
    
    setNodeObstacleEnabled(boolean)
  - setLinkObstacleEnabled
```
public final void setLinkObstacleEnabled(boolean flag)
```
    Sets whether links should be line obstacles for the link routes.
    The default is true. There are, however, situations where it may be suitable to consider a set of obstacles different from the links. In this case you can switch links as obstacles off and use the methods addLineObstacle(ilog.views.IlvRect) and addLineObstacle(ilog.views.IlvPoint, ilog.views.IlvPoint) to specify the obstacles that are needed.
    
    See Also:
    
    isLinkObstacleEnabled()
  - isLinkObstacleEnabled
```
public final boolean isLinkObstacleEnabled()
```
    Returns true if links should be line obstacles for the link routes.
    
    See Also:
    
    setLinkObstacleEnabled(boolean)
  - addRectObstacle
```
public final void addRectObstacle(IlvRect obstacleBoundingBox)
```
    Adds a rectangular obstacle for the routing.
    All nodes are considered rectangular obstacles by default for the routing of a link. The algorithm tries to find a link routing that avoids overlaps with rectangular obstacles. If graphic objects that are not nodes should also be considered as obstacles, you can add them by this method.
    
    Parameters:
    
    obstacleBoundingBox - A rectangular obstacle for the routing.
    
    See Also:
    
    removeAllRectObstacles(), addLineObstacle(ilog.views.IlvRect), addLineObstacle(ilog.views.IlvPoint, ilog.views.IlvPoint), setNodeObstacleEnabled(boolean)
  - removeAllRectObstacles
```
public final void removeAllRectObstacles()
```
    Removes all additional rectangular obstacles.
    
    See Also:
    
    addRectObstacle(IlvRect)
  - addLineObstacle
```
public final void addLineObstacle(IlvRect obstacleBoundingBox)
```
    Adds a line segment obstacle for the routing.
    This must be either a horizontal line segment or a vertical line segment; hence, the input bounding box must either have zero width or zero height. Orthogonally routed link segments are considered line segment obstacles by default for the routing of another link. The algorithm tries to find a link routing that allows crossing line obstacles in the orthogonal direction but avoids overlaps with line obstacles in the parallel direction. If graphic objects that are not links should also be considered as obstacles, you can add them by this method.
    
    Parameters:
    
    obstacleBoundingBox - A line segment obstacle for the routing.
    
    See Also:
    
    removeAllLineObstacles(), addRectObstacle(IlvRect), setLinkObstacleEnabled(boolean)
  - addLineObstacle
```
public final void addLineObstacle(IlvPoint p1,
                                  IlvPoint p2)
```
    Adds a line segment obstacle for link routing.
    A line segment obstacle does not need to be strictly horizontal or vertical. Orthogonally routed link segments are considered line segment obstacles by default for the routing of another link. The algorithm tries to find link routing that allows crossing line obstacles in the orthogonal direction but avoids overlaps with line obstacles in the parallel direction. If graphical objects that are not links should also be considered as obstacles, you can add them by this method.
    
    Parameters:
    
    p1 - The start point of the line segment obstacle.
    
    p2 - The end point of the line segment obstacle.
    
    See Also:
    
    removeAllLineObstacles(), addRectObstacle(IlvRect), setLinkObstacleEnabled(boolean)
  - removeAllLineObstacles
```
public final void removeAllLineObstacles()
```
    Removes all additional line obstacles.
    
    See Also:
    
    addLineObstacle(ilog.views.IlvRect), addLineObstacle(ilog.views.IlvPoint, ilog.views.IlvPoint)
  - getCalcFallbackLinks
```
public final Enumeration getCalcFallbackLinks()
```
    Returns the links that could not be routed on the grid without obstacle overlaps by the previous layout call. A link may not be routed without overlaps if the allowed time to find a route for this single link elapsed (see getAllowedTimePerLink()), or if the route would have to bypass too many obstacles (see getMaxBacktrack()), or if there is no path on the grid from the start node to the end node that bypasses all obstacles.
    Such links must be routed by some fallback mechanism. If the fallback routing option was set to true by using setFallbackRouteEnabled(boolean), these links are routed by a simple fallback routing algorithm inside IlvGraphLayout.performLayout(). If the fallback routing option was set to false, such links are not routed. In this case, the user is supposed to implement a fallback mechanism to route such links after IlvGraphLayout.performLayout() terminates successfully.
    
    Note that there will be no calculated fallback links if the previous layout did not terminate successfully, for example, if the global layout time elapsed or if the algorithm was stopped immediately during the previous run of IlvGraphLayout.performLayout().
    
    Returns:
    
    The links that could not be routed on the grid without obstacle overlaps by the previous layout call.
    
    See Also:
    
    setFallbackRouteEnabled(boolean), setAllowedTimePerLink(long), setMaxBacktrack(int), IlvGraphLayout.performLayout(), IlvGraphLayout.setAllowedTime(long), IlvGraphLayout.stopImmediately()
  - setFallbackRouteEnabled
```
public final void setFallbackRouteEnabled(boolean flag)
```
    Sets whether the fallback routing algorithm is enabled.
    This routing algorithm is used for those links that cannot be routed on the grid without overlapping other obstacles (nodes or links). If it is disabled, then these fallback links remain unrouted.
    
    The default is true.
    
    See Also:
    
    setAllowedTimePerLink(long), setMaxBacktrack(int), isFallbackRouteEnabled(), getCalcFallbackLinks()
  - isFallbackRouteEnabled
```
public final boolean isFallbackRouteEnabled()
```
    Returns true if the fallback routing algorithm is enabled.
    
    See Also:
    
    setFallbackRouteEnabled(boolean), getCalcFallbackLinks()
  - setNodeBoxInterface
```
public void setNodeBoxInterface(IlvNodeBoxInterface nodeBoxInterface)
```
    Sets the 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 the bounding box of each node (see IlvGraphic.boundingBox(ilog.views.IlvTransformer) and IlvGraphModel.boundingBox(java.lang.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 go back to the default behavior.
    
    See Also:
    
    getNodeBoxInterface(), IlvGraphLayout.setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface)
  - getNodeBoxInterface
```
public IlvNodeBoxInterface getNodeBoxInterface()
```
    Returns the node box interface used for the obstacle area during the layout. Returns null if none is specified.
    
    See Also:
    
    setNodeBoxInterface(IlvNodeBoxInterface)
  - setLinkConnectionBoxInterface
```
public void setLinkConnectionBoxInterface(IlvLinkConnectionBoxInterface connectionBoxInterface)
```
    Sets the 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.
    By default, the layout algorithm places the connection points of the links relative to the bounding box of the nodes (see IlvGraphic.boundingBox(ilog.views.IlvTransformer) and IlvGraphModel.boundingBox(java.lang.Object) ).
    
    By setting a link connection box interface, the links can be connected relative to a different box (see IlvLinkConnectionBoxInterface.getBox(IlvGraphModel, Object)). The tangential offsets provided by the link connection box interface are currently ignored.
    
    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(IlvNodeBoxInterface). If this method has not been used, the bounding box of the node in the graph model (see IlvGraphModel.boundingBox(Object) ) is used.
    
    You can call this method with a null argument to go back to the default behavior.
    
    Overrides:
    
    setLinkConnectionBoxInterface in class IlvGraphLayout
    
    See Also:
    
    supportsLinkConnectionBox(), IlvGraphLayout.getLinkConnectionBoxInterface(), setNodeBoxInterface(IlvNodeBoxInterface)
  - setNodeSideFilter
```
public final void setNodeSideFilter(IlvNodeSideFilter filter)
```
    Sets the node-side filter, that is, an object that allows or prohibits the connection of the links on a given side of the nodes.
    Note that the node-side filter serves the same purpose as the termination point filter; it is, however, easier to use. If a termination point filter is installed, the node-side filter is ignored. If neither a termination point filter nor a node-side filter is installed, the layout algorithm is free to choose any 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 to. 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.
    
    You can call this method with a null argument to go back to the default behavior.
    
    See Also:
    
    IlvNodeSideFilter, getNodeSideFilter(), setTerminationPointFilter(IlvTerminationPointFilter)
  - getNodeSideFilter
```
public final IlvNodeSideFilter getNodeSideFilter()
```
    Returns the node-side filter used during layout. Returns null if none is specified.
    
    See Also:
    
    setNodeSideFilter(IlvNodeSideFilter)
  - setTerminationPointFilter
```
public final void setTerminationPointFilter(IlvTerminationPointFilter filter)
```
    Sets the termination point filter, that is, an object that allows filtering the termination points that are proposed by the layout algorithm.
    For each side, the layout algorithm proposes some termination points. It also proposes a penalty that indicates how "good" this termination point is. The default penalty indicates how far the termination point is away from the border. By installing a termination point filter, you can change this penalty.
    
    Note that the termination point filter serves the same purpose as the node-side filter but allows a greater flexibility. If a termination point filter and a node-side filter are installed, the node-side filter is ignored. If neither a termination point filter nor a node-side filter is installed, the layout algorithm is free to choose any termination point.
    
    When a filter is specified, the layout algorithm proposes a sequence of termination points on the grid for each link. It proposes termination points at all four sides of the corresponding end node. It asks the filter for the penalty of each termination point and then chooses the termination points with the lowest penalty that are feasible to route the link.
    
    You can call this method with a null argument to go back to the default behavior.
    
    See Also:
    
    IlvTerminationPointFilter, getTerminationPointFilter(), setNodeSideFilter(IlvNodeSideFilter)
  - getTerminationPointFilter
```
public final IlvTerminationPointFilter getTerminationPointFilter()
```
    Returns the termination point filter used during layout. Returns null if none is specified.
    
    See Also:
    
    setTerminationPointFilter(IlvTerminationPointFilter)
  - 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
  - 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()
  - 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)
  - createLayoutGrapherProperty
```
protected IlvGraphLayoutGrapherProperty createLayoutGrapherProperty(String name,
                                                                    boolean withDefaults)
```
    Returns a new instance of IlvLongLinkLayoutGrapherProperty 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 IlvLongLinkLayoutLinkProperty 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 IlvLongLinkLayout

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

FREE_MODE

FIXED_MODE

MIXED_MODE

Constructor Detail

IlvLongLinkLayout

IlvLongLinkLayout

Method Detail

init

copy

copyParameters

detach

cleanNode

cleanLink

layout

createLayoutReport

supportsPreserveFixedLinks

supportsAnimation

supportsAllowedTime

supportsStopImmediately

stopImmediately

supportsPercentageComplete

supportsLinkConnectionBox

supportsSaveParametersToNamedProperties

supportsSplineRouting

setHorizontalGridOffset

getHorizontalGridOffset

setVerticalGridOffset

getVerticalGridOffset

setHorizontalGridBase

getHorizontalGridBase

setVerticalGridBase

getVerticalGridBase

setHorizontalMinOffset

getHorizontalMinOffset

setVerticalMinOffset

getVerticalMinOffset

setMinNodeCornerOffset

getMinNodeCornerOffset

setMinStartSegmentLength

getMinStartSegmentLength

setMinEndSegmentLength

getMinEndSegmentLength

setAllowedTimePerLink

getAllowedTimePerLink

setMaxBacktrack

getMaxBacktrack

setGlobalLinkStyle

getGlobalLinkStyle

setLinkStyle

getLinkStyle

setExhaustiveSearching

isExhaustiveSearching

setStraightRouteEnabled

isStraightRouteEnabled

setCrossingReductionEnabled

isCrossingReductionEnabled

setNumberCrossingReductionIterations

getNumberCrossingReductionIterations

setGlobalOriginPointMode

getGlobalOriginPointMode

setGlobalDestinationPointMode

getGlobalDestinationPointMode

setOriginPointMode

getOriginPointMode

setDestinationPointMode

getDestinationPointMode

setFromPointFixed

isFromPointFixed