IlvLongLinkLayout (JViews CSS Documentation)

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

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: Sample drawing produced with the Long Link Layout

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

Sample drawing produced with the Long Link Layout

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.

CSS example:

SDM {
     LinkLayout : true;
 }

LinkLayout {
     graphLayout : @#layout;
     // optional settings for the link layout renderer
 }

Subobject#layout {

     class : "ilog.views.graphlayout.link.longlink.IlvLongLinkLayout";

     allowedTime : "3";

     allowedTimePerLink : "3";

     animate : "false";

     combinedInterGraphLinksMode : "false";

     coordinatesMode : "MANAGER_COORDINATES";

     crossingReductionEnabled : "false";

     exhaustiveSearching : "false";

     fallbackRouteEnabled : "false";

     globalDestinationPointMode : "FREE_MODE";

     globalLinkStyle : "ORTHOGONAL_STYLE";

     globalOriginPointMode : "FREE_MODE";

     horizontalGridBase : "3.0";

     horizontalGridOffset : "3.0";

     horizontalMinOffset : "3.0";

     incrementalConnectionPreserving : "false";

     incrementalMode : "false";

     interGraphLinksMode : "false";

     linkObstacleEnabled : "false";

     maxBacktrack : "2";

     minBusyTime : "3";

     minEndSegmentLength : "3.0";

     minNodeCornerOffset : "3.0";

     minStartSegmentLength : "3.0";

     nodeObstacleEnabled : "false";

     numberCrossingReductionIterations : "2";

     straightRouteEnabled : "false";

     verticalGridBase : "3.0";

     verticalGridOffset : "3.0";

     verticalMinOffset : "3.0";

 }

link.tag {

     DestinationPointMode : "FREE_MODE";

     LinkStyle : "ORTHOGONAL_STYLE";

     OriginPointMode : "FREE_MODE";

 }

CSS specification of per-node and per-link layout parameters:

The following table lists the per-object rendering properties of the GraphLayout renderer:

Property	Type	Default	Description
GraphLayout	IlvGraphLayout	`null`	Lets you define a different graph layout algorithm for each subgraph. If one is not specified, the same algorithm is applied recursively to all subgraphs.
LayoutFixed	String	`false`	Deprecated, replaced by Fixed.
Fixed	String	`false`	Lets you specify that the node or link must not be moved or reshaped by the layout algorithm.
LayoutGroup	String	`null`	Lets you apply the algorithm to different groups of objects, one group after the other.
LayoutIgnored	boolean	`false`	If `true`, the object is ignored by the layout.

The per-node and per-link layout parameters are specified in the style sheet through the CSS rules for nodes and links, not through the CSS rule for graph layout. For instance:

link.tag { LinkStyle : "ORTHOGONAL_STYLE"; }

Note that the names of the node and link layout parameters use an initial capital, unlike the regular properties.

Additional per-object properties are defined by the LinkLayoutRenderer (which also inherits the properties defined by the GraphLayoutRenderer):

Property	Type	Default	Description
NodeSideForDestination	int	0 (`Any`)	If this property is specified, it tells the link layout algorithm to try to connect links to the specified side of their destination node. The possible values are `Bottom`, `Top`, `Left`, `Right`, `Horizontal`, `Vertical`, and `Any`.
NodeSideForOrigin	int	0 (`Any`)	If this property is specified, it tells the link layout algorithm to try to connect links to the specified side of their origin node. The possible values are `Bottom`, `Top`, `Left`, `Right`, `Horizontal`, `Vertical`, and `Any`.

See also the documentation of the class IlvLinkLayoutRenderer.

Property Summary

Properties
Modifier and Type	Property and Description
`long`	`allowedTime` Sets the upper limit for the duration of the layout algorithm.
`long`	`allowedTimePerLink` Sets the upper limit for the time allowed to find a route for a long link.
`boolean`	`animate` If the argument is `true`, specifies that layout algorithms that support the animation mechanism will require the graph model to redraw the graph after each iteration or step.
`java.lang.String`	`class` Default constructor.
`boolean`	`combinedInterGraphLinksMode` Sets the routing of normal links in addition to intergraph links.
`int`	`coordinatesMode` Sets the coordinates mode to be used during layout.
`boolean`	`crossingReductionEnabled` Sets the crossing reduction.
`int`	`DestinationPointMode` Sets the mode for the connection point of an individual link on the destination node.
`boolean`	`exhaustiveSearching` Sets the exhaustive searching of routes for links.
`boolean`	`fallbackRouteEnabled` Sets whether the fallback routing algorithm is enabled.
`int`	`globalDestinationPointMode` Sets the global mode for the connection point of the links on the destination nodes.
`int`	`globalLinkStyle` Sets the global style of the shapes of links.
`int`	`globalOriginPointMode` Sets the global mode for the connection point of the links on the origin nodes.
`double`	`horizontalGridBase` Sets the horizontal base coordinate of the grid.
`double`	`horizontalGridOffset` Sets the horizontal offset between the grid lines.
`double`	`horizontalMinOffset` Sets the minimum horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
`boolean`	`incrementalConnectionPreserving` Sets whether the incremental layout mode preserves the side and relative order of the link connection points.
`boolean`	`incrementalMode` Sets the incremental layout mode.
`boolean`	`interGraphLinksMode` Sets the routing of intergraph links.
`boolean`	`linkObstacleEnabled` Sets whether links should be line obstacles for the link routes.
`int`	`LinkStyle` Sets the style for the shape of an individual link.
`int`	`maxBacktrack` Sets the maximum number of backtrack steps to find a route for a long link.
`long`	`minBusyTime` Sets the minimal time that the layout algorithm can be busy.
`double`	`minEndSegmentLength` Sets the minimum length of the last segment of each link, that is, the segment incident to the "to" node.
`double`	`minNodeCornerOffset` Sets the minimum offset between a node corner and a link starting at this node.
`double`	`minStartSegmentLength` Sets the minimum length of the first segment of each link, that is, the segment incident to the "from" node.
`boolean`	`nodeObstacleEnabled` Sets whether nodes should be obstacles for the link routes.
`int`	`numberCrossingReductionIterations` Sets the maximum number of iterations performed during crossing reduction.
`int`	`OriginPointMode` Sets the mode for the connection point on an individual link on the origin node.
`boolean`	`straightRouteEnabled` Sets the straight routing.
`double`	`verticalGridBase` Sets the vertical base coordinate of the grid.
`double`	`verticalGridOffset` Sets the vertical offset between the grid lines.
`double`	`verticalMinOffset` Sets the minimum vertical offset between the node border and a link segment that is (horizontally) parallel to the node border.

Method Summary
- Methods inherited from class java.lang.Object
  equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Property Detail
  - class
```
public java.lang.String class
```
    Default constructor.
    
    CSS example: class : "ilog.views.graphlayout.link.longlink.IlvLongLinkLayout";
  - allowedTime
```
public long allowedTime
```
    Sets the upper limit for the duration of the layout algorithm.
    When an iterative layout algorithm is used, the iterations can be stopped when this time is exceeded. Noniterative algorithms can also use this parameter as an upper limit for the computation time. The default value is normally 32000 (32 seconds). Subclasses that support this feature can use a different default value depending on their particular behavior. Layout algorithms that are stopped in this way set the result code of the layout report either to IlvGraphLayoutReport#STOPPED_AND_VALID or to IlvGraphLayoutReport#STOPPED_AND_INVALID.
    
    When the connected components of disconnected graphs are laid out separately (see #supportsLayoutOfConnectedComponents()), the specified allowed time is considered as the total time for the layout of all the connected components plus the time for the connected components layout.
    
    Note that the layout algorithm may not obey exactly the allowed time specification.
    
    Note for implementers of layout algorithms: the method #performLayout(boolean, boolean, boolean) does NOT automatically stop the layout when the allowed time is exceeded. It is the sole responsibility of the implementation of the method #layout(boolean) to do this.
    
    A RuntimeException is thrown if the layout does not support this mechanism.
    
    CSS example: allowedTime : "3";
  - allowedTimePerLink
```
public long allowedTimePerLink
```
    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.
    
    CSS example: allowedTimePerLink : "3";
  - animate
```
public boolean animate
```
    If the argument is true, specifies that layout algorithms that support the animation mechanism will require the graph model to redraw the graph after each iteration or step.
    The default value is false.
    
    A RuntimeException is thrown if the layout does not support this option.
    
    Note that to obtain a redraw of an IlvGrapher after each iteration or step, the method #performLayout(boolean, boolean, boolean) must be called with the value true for the redraw argument.
    
    CSS example: animate : "false";
  - combinedInterGraphLinksMode
```
public boolean combinedInterGraphLinksMode
```
    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.
    
    CSS example: combinedInterGraphLinksMode : "false";
    
    See Also:
    
    interGraphLinksMode
  - coordinatesMode
```
public int coordinatesMode
```
    Sets the coordinates mode to be used during layout.
    Valid values are:
    - ilog.views.graphlayout.IlvGraphLayout#MANAGER_COORDINATES - The geometry of the graph is computed using the coordinate space of the manager (that is, the attached IlvGrapher) without applying any transformation.
      This mode should be used if you visualize the graph at zoom level 1, or you do not visualize it at all, or the graph contains only fully zoomable objects. In all these cases there is no need to take the transformer into account during the layout.
      Note that in this mode the dimensional parameters of the layout algorithms are considered as being specified in manager coordinates.
    - ilog.views.graphlayout.IlvGraphLayout#VIEW_COORDINATES - The geometry of the graph is computed in the coordinate space of the manager view. More exactly, all the coordinates are transformed using the current reference transformer.
      This mode should be used if you want the dimensional parameters of the layout algorithms to be considered as being specified in manager view coordinates.
    - ilog.views.graphlayout.IlvGraphLayout#INVERSE_VIEW_COORDINATES - The geometry of the graph is computed using the coordinate space of the manager view and then applying the inverse transformation. This mode is equivalent to the "manager coordinates" mode if the geometry of the graphic objects strictly obeys the transformer. (A small difference may exist because of the limited precision of the computations.)
      On the contrary, if some graphic objects are either nonzoomable (see IlvGraphic#zoomable) or semizoomable (for example, links with a maximum line width), this mode gives different results than the manager coordinates mode. These results are optimal if the graph is visualized using the same transformer as the one taken into account during the layout.
      Note that in this mode the dimensional parameters of the layout algorithms are considered as being specified in manager coordinates.
    The default value is IlvGraphLayout#INVERSE_VIEW_COORDINATES.
    
    This option is useful only if the attached graph model is an IlvGrapherAdapter (or a subclass). Otherwise, it has no effect. Note: the coordinates mode of the layout is used only while this layout is running. If layout is not running, operations on the grapher adapter use the coordinates mode that was set on the grapher adapter directly (see IlvGrapherAdapter#setCoordinatesMode).
    
    CSS example: coordinatesMode : "MANAGER_COORDINATES";
    
    Allowed values:
    
    MANAGER_COORDINATES
    
    VIEW_COORDINATES
    
    INVERSE_VIEW_COORDINATES
  - crossingReductionEnabled
```
public boolean crossingReductionEnabled
```
    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.
    
    CSS example: crossingReductionEnabled : "false";
  - DestinationPointMode
```
public int DestinationPointMode
```
    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.
    
    CSS example:     DestinationPointMode : "FREE_MODE";
    
    Allowed values:
    
    FREE_MODE    Free
    
    FIXED_MODE    Fixed
    
    Important: This layout parameter applies to subsets of links. Therefore, the CSS declaration must be added to the corresponding CSS rule for links. Note also that the name of such layout parameters uses an initial capital, unlike the regular properties which hold for the entire content of the graph.
    See Also:
    
    globalDestinationPointMode
  - exhaustiveSearching
```
public boolean exhaustiveSearching
```
    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.
    
    CSS example: exhaustiveSearching : "false";
  - fallbackRouteEnabled
```
public boolean fallbackRouteEnabled
```
    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.
    
    CSS example: fallbackRouteEnabled : "false";
  - globalDestinationPointMode
```
public int globalDestinationPointMode
```
    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.
    
    CSS example:     globalDestinationPointMode : "FREE_MODE";
    
    Allowed values:
    
    FREE_MODE    Free
    
    FIXED_MODE    Fixed
    
    MIXED_MODE    Mixed
  - globalLinkStyle
```
public int globalLinkStyle
```
    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 and method IlvGraphLayoutUtil#EnsureAppropriateLinkConnectors before layout, or the method IlvGraphLayoutUtil#EnsureAppropriateLinks when the exception is caught, to convert all links and link connectors to an appropriate type.
    
    CSS example:     globalLinkStyle : "ORTHOGONAL_STYLE";
    
    Allowed values:
    
    ORTHOGONAL_STYLE    Orthogonal links
    
    DIRECT_STYLE    Direct links
    
    MIXED_STYLE    Mixed links
  - globalOriginPointMode
```
public int globalOriginPointMode
```
    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.
    
    CSS example:     globalOriginPointMode : "FREE_MODE";
    
    Allowed values:
    
    FREE_MODE    Free
    
    FIXED_MODE    Fixed
    
    MIXED_MODE    Mixed
  - horizontalGridBase
```
public double horizontalGridBase
```
    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.
    
    CSS example: horizontalGridBase : "3.0";
  - horizontalGridOffset
```
public double horizontalGridOffset
```
    Sets the horizontal offset between the grid lines. Links are routed on an orthogonal grid.
    The default value is 5.
    
    CSS example: horizontalGridOffset : "3.0";
  - horizontalMinOffset
```
public double horizontalMinOffset
```
    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.
    
    CSS example: horizontalMinOffset : "3.0";
  - incrementalConnectionPreserving
```
public boolean incrementalConnectionPreserving
```
    Sets whether the incremental layout mode preserves the side and relative order of the link connection points. The default is false.
    
    CSS example: incrementalConnectionPreserving : "false";
  - incrementalMode
```
public boolean incrementalMode
```
    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.
    
    CSS example: incrementalMode : "false";
  - interGraphLinksMode
```
public boolean interGraphLinksMode
```
    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.
    CSS example: interGraphLinksMode : "false";
  - linkObstacleEnabled
```
public boolean linkObstacleEnabled
```
    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.
    
    CSS example: linkObstacleEnabled : "false";
  - LinkStyle
```
public int LinkStyle
```
    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 and IlvGraphLayoutUtil#EnsureAppropriateLinkConnectors before layout, or the method IlvGraphLayoutUtil#EnsureAppropriateLinks when the exception is caught, to convert all links and connectors to an appropriate type.
    
    CSS example:     LinkStyle : "ORTHOGONAL_STYLE";
    
    Allowed values:
    
    ORTHOGONAL_STYLE    Orthogonal links
    
    DIRECT_STYLE    Direct links
    
    Important: This layout parameter applies to subsets of links. Therefore, the CSS declaration must be added to the corresponding CSS rule for links. Note also that the name of such layout parameters uses an initial capital, unlike the regular properties which hold for the entire content of the graph.
    See Also:
    
    globalLinkStyle
  - maxBacktrack
```
public int maxBacktrack
```
    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.
    
    CSS example: maxBacktrack : "2";
  - minBusyTime
```
public long minBusyTime
```
    Sets the minimal time that the layout algorithm can be busy. This is the time between two calls of #layoutStepPerformed() when the method #callLayoutStepPerformedIfNeeded() is used.
    The objective is to avoid the overhead of #layoutStepPerformed() becoming too high if the method is called too often. Internal routines of layout algorithms usually call #callLayoutStepPerformedIfNeeded(), which calls #layoutStepPerformed() if the time since the last call was at least the minimal busy time.
    
    The default value is 50 (milliseconds).
    
    CSS example: minBusyTime : "3";
  - minEndSegmentLength
```
public double minEndSegmentLength
```
    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.
    
    CSS example: minEndSegmentLength : "3.0";
  - minNodeCornerOffset
```
public double minNodeCornerOffset
```
    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.
    
    CSS example: minNodeCornerOffset : "3.0";
  - minStartSegmentLength
```
public double minStartSegmentLength
```
    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.
    
    CSS example: minStartSegmentLength : "3.0";
  - nodeObstacleEnabled
```
public boolean nodeObstacleEnabled
```
    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.
    
    CSS example: nodeObstacleEnabled : "false";
  - numberCrossingReductionIterations
```
public int numberCrossingReductionIterations
```
    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.
    
    CSS example: numberCrossingReductionIterations : "2";
  - OriginPointMode
```
public int OriginPointMode
```
    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.
    
    CSS example:     OriginPointMode : "FREE_MODE";
    
    Allowed values:
    
    FREE_MODE    Free
    
    FIXED_MODE    Fixed
    
    Important: This layout parameter applies to subsets of links. Therefore, the CSS declaration must be added to the corresponding CSS rule for links. Note also that the name of such layout parameters uses an initial capital, unlike the regular properties which hold for the entire content of the graph.
    See Also:
    
    globalOriginPointMode
  - straightRouteEnabled
```
public boolean straightRouteEnabled
```
    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.
    
    CSS example: straightRouteEnabled : "false";
  - verticalGridBase
```
public double verticalGridBase
```
    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.
    
    CSS example: verticalGridBase : "3.0";
  - verticalGridOffset
```
public double verticalGridOffset
```
    Sets the vertical offset between the grid lines. Links are routed on an orthogonal grid.
    The default value is 5.
    
    CSS example: verticalGridOffset : "3.0";
  - verticalMinOffset
```
public double verticalMinOffset
```
    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.
    
    CSS example: verticalMinOffset : "3.0";

Allowed values:
`FREE_MODE`		Free
`FIXED_MODE`		Fixed
`MIXED_MODE`		Mixed

Allowed values:
`ORTHOGONAL_STYLE`		Orthogonal links
`DIRECT_STYLE`		Direct links
`MIXED_STYLE`		Mixed links

Class IlvLongLinkLayout

Property Summary

Method Summary

Methods inherited from class java.lang.Object

Property Detail

class

allowedTime

allowedTimePerLink

animate

combinedInterGraphLinksMode

coordinatesMode

crossingReductionEnabled

DestinationPointMode

exhaustiveSearching

fallbackRouteEnabled

globalDestinationPointMode

globalLinkStyle

globalOriginPointMode

horizontalGridBase

horizontalGridOffset

horizontalMinOffset

incrementalConnectionPreserving

incrementalMode

interGraphLinksMode

linkObstacleEnabled

LinkStyle

maxBacktrack

minBusyTime

minEndSegmentLength

minNodeCornerOffset

minStartSegmentLength

nodeObstacleEnabled

numberCrossingReductionIterations

OriginPointMode

straightRouteEnabled

verticalGridBase

verticalGridOffset

verticalMinOffset