ilog.views.graphlayout.link

Class IlvLinkLayout

java.lang.Object

ilog.views.graphlayout.IlvGraphLayout

ilog.views.graphlayout.link.IlvLinkLayout

public class IlvLinkLayout
extends IlvGraphLayout

The main class for the Link Layout algorithm.

The Link Layout algorithm reshapes the links of a graph without moving the nodes. By default, the algorithm computes orthogonal links (that is, links composed of alternating horizontal and vertical segments). Optionally, direct links can be computed. See the method #setGlobalLinkStyle(int).

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

The long link mode is slower and uses more memory on very large graphs than the short link mode. The short link mode should be used if any of the following conditions apply:

• Most of the links are short and it is not fatal if long links overlap obstacles.
• The link routes must be placed freely and cannot be restricted to a grid.
• It is important to limit the number of bends.
• Maximal speed and minimal memory usage are important on huge graphs.

The long link mode should be used if any of the following conditions apply:

• Many links are long and it is important that long orthogonal links do not overlap obstacles.
• Routing on a grid is preferred because it guarantees a minimal distance between link segments.
• An increasing number of bends is acceptable if this avoids any overlaps. The long link mode can be used to find an orthogonal route without overlaps in a labyrinth of node obstacles.

Here are sample drawings produced by the Link Layout algorithm:

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

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

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

The Link Layout algorithm is a wrapper that allows simplified access to two sublayouts: the Short Link Layout algorithm and the Long Link Layout algorithm. It calls these sublayouts internally to perform the layout. This is useful for applications that need to use both layout modes at the same time. Applications that use the short link mode exclusively can use the Short Link Layout algorithm (IlvShortLinkLayout) directly. Applications that use the long link mode exclusively can use the Long Link Layout algorithm (IlvLongLinkLayout) directly.

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

Note the following points:

• The algorithm never moves any nodes. It only reshapes links.
• The algorithm normally routes normal links. It has a special mode to route the intergraph links of the graph model.
• The algorithm has an incremental mode and a nonincremental mode. In nonincremental mode, the initial shape of the links (at the moment you start the layout) does not affect the resulting layout. However, links specified as fixed while #setPreserveFixedLinks is enabled, or links that have the link style #NO_RESHAPE_STYLE, are not reshaped. The incremental mode cannot be used for intergraph links.
• In incremental mode, the initial shape of the link does affect the resulting layout. The algorithm tries to preserve the shape of links that already fit the layout situation.
• The algorithm supports self-links and multiple links between the same pair of nodes.

CSS example:

SDM {
LinkLayout : true;
}

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

Subobject#layout {
class : "ilog.views.graphlayout.link.IlvLinkLayout";
allowedTime : "3";
animate : "false";
combinedInterGraphLinksMode : "false";
coordinatesMode : "MANAGER_COORDINATES";
globalDestinationPointMode : "FREE_MODE";
globalLinkStyle : "ORTHOGONAL_STYLE";
globalOriginPointMode : "FREE_MODE";
horizontalGridBase : "3.0";
horizontalGridOffset : "3.0";
horizontalMinOffset : "3.0";
incrementalMode : "false";
interGraphLinksMode : "false";
layoutMode : "LONG_LINKS";
linkOffset : "3.0";
minBusyTime : "3";
minFinalSegmentLength : "3.0";
minNodeCornerOffset : "3.0";
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.
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 Enables the routing of normal links in addition to intergraph links.
int	coordinatesMode Sets the coordinates mode to be used during layout.
int	DestinationPointMode Sets the mode for the connection point on an individual link on the destination node.
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 minimal horizontal offset between the node border and a link segment that is (vertically) parallel to the node border.
boolean	incrementalMode Enables the incremental layout mode.
boolean	interGraphLinksMode Enables the routing of intergraph links.
int	layoutMode Sets the layout mode.
double	linkOffset Sets the offset between links connected on the same side of the node.
int	LinkStyle Sets the shape style of an individual link.
long	minBusyTime Sets the minimal time that the layout algorithm can be busy.
double	minFinalSegmentLength Sets the minimum length of the first and last segments of each link.
double	minNodeCornerOffset Sets the minimum offset between a node corner and a link starting at this node.
int	OriginPointMode Sets the mode for the connection point on an individual link on the origin node.
double	verticalGridBase Sets the vertical base coordinate of the grid.
double	verticalGridOffset Sets the vertical offset between the grid lines.
double	verticalMinOffset Sets the minimal 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.IlvLinkLayout";

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";

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

Enables the routing of normal links in addition to intergraph links. If intergraph link routing is disabled, the option has no effect. If intergraph link routing is enabled and the argument is true, both normal links and intergraph links are routed in the same pass. Otherwise, only the intergraph links are routed.

The default value is true.

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

DestinationPointMode

public int DestinationPointMode

Sets the mode for the connection point on an individual link on the destination node. This mode is used only if the global from point mode is set to #MIXED_MODE. Otherwise, the connection points on the destination nodes have, for all the links, the mode that is specified as the global destination point mode.

Valid values are:

• #FREE_MODE - The layout is free to choose, for this link, the appropriate position of the connection point on the destination node, except for "pinned" connection points (see IlvGraphModel#hasPinnedConnectionPoint).
• #FIXED_MODE - The layout must keep, for this link, the current position of the connection point on the destination node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.

  The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.

The default value is #FREE_MODE.

Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.

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

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).
• #FIXED_MODE - For all links, the layout must keep the current position of the connection point on the destination node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.

  The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.

• #MIXED_MODE - Each link can have a different mode for the connection point on the destination node. The mode of each individual link can be set by the method #setDestinationPointMode(Object, int).

Unless the global mode is #MIXED_MODE, the connection points on the destination node have the same mode for all the links.

The default value is #FREE_MODE.

Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.

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 have an orthogonal shape, that is, a shape consisting of a sequence of alternating horizontal and vertical line segments.
• #DIRECT_STYLE - all links get a nearly straight-line shape. The shape of the links is a polyline composed of a straight-line segment between the end nodes with two short horizontal or vertical segments at its ends (their length is controlled by the method setMinFinalSegmentLength and may be 0).
• #MIXED_STYLE - each link can have a different link style. The style of each individual link can be set by the method #setLinkStyle(Object, int) so that different link shapes can occur in the same graph.

Unless the global link style is #MIXED_STYLE, all links have the same shape style.

The default value is #ORTHOGONAL_STYLE.

Note that when the graph attached to the layout is of type IlvGrapher, the effect of the link reshaping depends on the type of the links and the connectors installed at the node. For all link styles, we recommend using links of type IlvPolylineLinkImage and link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil#EnsureAppropriateLinkTypes 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).
• #FIXED_MODE - For all links, the layout must keep the current position of the connection point on the origin node. This can be useful,in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.

  The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.

• #MIXED_MODE - Each link can have a different mode for the connection point on the origin node. The mode of each individual link can be set by the method #setOriginPointMode(Object, int).

Unless the global mode is #MIXED_MODE, the connection points on the origin node have the same mode for all the links.

The default value is #FREE_MODE.

Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.

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. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode #SHORT_LINKS, links are placed freely and the grid parameters are ignored.

The default value is 0.

CSS example: horizontalGridBase : "3.0";

horizontalGridOffset

public double horizontalGridOffset

Sets the horizontal offset between the grid lines. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode #SHORT_LINKS, links are placed freely and the grid parameters are ignored.

The default value is 5.

CSS example: horizontalGridOffset : "3.0";

horizontalMinOffset

public double horizontalMinOffset

Sets the minimal horizontal offset between the node border and a link segment that is (vertically) parallel to the node border. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode #SHORT_LINKS, links are placed freely and the grid parameters are ignored.

The default value is 3.

CSS example: horizontalMinOffset : "3.0";

incrementalMode

public boolean incrementalMode

Enables the incremental layout mode. If the argument is true, only those links that were affected by changes since the last layout are rerouted. A link is rerouted under the following conditions:

• if the link is new,
• if the link shape or link style has changed,
• if the parameters controlling the starting and end segments have changed,
• if the link now overlaps obstacles that were moved or resized,
• in long link mode, if the link is no longer on the grid,
• if the link is marked for incremental rerouting.

In short link mode, links already laid out in the last layout keep their general shape (that is keep their number of bends and do not change the side where they connect to the end nodes), except if one or both of their end nodes have been moved or resized.

In long link mode, the rerouted links can change shape completely. The rerouted links can change the side where they are connected to the end nodes if this is necessary to obtain a better route.

The incremental mode works only if the intergraph links mode is disabled or if there are no intergraph links. The incremental mode is disabled by default.

CSS example: incrementalMode : "false";

interGraphLinksMode

public boolean interGraphLinksMode

Enables the routing of intergraph links. If the argument is true, the intergraph links are routed; otherwise, only the normal links are routed. An intergraph link is a link stored in a given graph that has an origin or destination not stored in this graph. If additionally the combined intergraph link routing is enabled, this means that normal links and intergraph links are routed together; otherwise, only the intergraph links are routed.

The default value is true.

If the intergraph link mode is enabled and the graph actually contains some intergraph links, there are some restrictions:

• Layout animation is not possible.
• The incremental mode has no effect.
• If layout is performed on a nested IlvGrapher (or IlvGrapherAdapter), the top-level grapher must have a manager view attached because of the coordinate transformations of the subgraphers. If you create your own subclass of IlvGraphModel instead of IlvGrapherAdapter to route intergraph links, you must ensure that all graph models of all subgraphers use the same coordinate system through appropriate coordinate transformations.

CSS example: interGraphLinksMode : "false";

layoutMode

public int layoutMode

Sets the layout mode. Valid value are:

• #SHORT_LINKS - Links are placed freely in the plane by choosing the best shape from a fixed number of link shapes. A link can have a maximum of 4 bends.
  This mode should be used if any of the following conditions apply:
  • Most of the links are short and it is not fatal if long links overlap obstacles.
  • The link routes must be placed freely and cannot be restricted to a grid.
  • It is important to limit the number of bends.
• #LONG_LINKS - Orthogonal links are routed on a grid by avoiding obstacles. Any orthogonal link shape can occur (that is, the number of link shapes is not limited) but a long link route can have many bends. Direct links are routed with the end segments on the grid, but the middle segment may overlap obstacles.
  This mode should be used if any of the following conditions apply:
  • Many links are long, and it is important that long links do not overlap obstacles.
  • Routing on a grid is preferred because it guarantees a minimal distance between link segments.
  • An increasing number of bends is acceptable if this avoids any overlaps. The long link mode can be used to find an orthogonal route without overlaps in a labyrinth of node obstacles.

The default value is #SHORT_LINKS.

CSS example: layoutMode : "LONG_LINKS";

Allowed values:

LONG_LINKS

SHORT_LINKS

linkOffset

public double linkOffset

Sets the offset between links connected on the same side of the node. It affects only the layout mode #SHORT_LINKS where the links are placed freely. In the layout mode #LONG_LINKS, the link offset parameter is ignored, because the offset between links is implicitly determined by the grid width.

The default value is 2.

CSS example: linkOffset : "3.0";

LinkStyle

public int LinkStyle

Sets the shape style of an individual link. This link style is used only if the global link style is set to #MIXED_STYLE. Otherwise, all links have the style that is specified as the global link style.

Valid values are:

• #ORTHOGONAL_STYLE - the link has an orthogonal shape, that is, a shape consisting of a sequence of alternating horizontal and vertical line segments.
• #DIRECT_STYLE - the link gets a nearly straight-line shape. The shape of the link is a polyline composed of a straight-line segment between the end nodes with two short horizontal or vertical segments at its ends (their length is controlled by the method setMinFinalSegmentLength and may be 0).
• #NO_RESHAPE_STYLE - the link is not reshaped.

The default value is #ORTHOGONAL_STYLE.

Note that when the graph attached to the layout is of type IlvGrapher, the effect of the link reshaping depends on the type of the links and the connectors installed at the node. For all link styles, we recommend using links of type IlvPolylineLinkImage and link connectors of type IlvFreeLinkConnector. Other link or connector types may cause an IlvInappropriateLinkException during layout. You can use the method IlvGraphLayoutUtil#EnsureAppropriateLinkTypes and method IlvGraphLayoutUtil#EnsureAppropriateLinkConnectors before layout, or the method IlvGraphLayoutUtil#EnsureAppropriateLinks when the exception is caught, to convert all links and connectors to an appropriate type.

Note also that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a link style on the Link Layout means that the same style is specified for both Short and Long Link Layouts.

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

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";

minFinalSegmentLength

public double minFinalSegmentLength

Sets the minimum length of the first and last segments of each link.

The default value is 10.

CSS example: minFinalSegmentLength : "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. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid and always connect to the node border. In the layout mode #SHORT_LINKS, links are placed freely in the plane, potentially connecting outside the node border.

The default value is 3.

CSS example: minNodeCornerOffset : "3.0";

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).
• #FIXED_MODE - The layout must keep, for this link, the current position of the connection point on the origin node. This can be useful, in particular, if the node has fixed pins where the link is attached (as, for instance, with IlvPinLinkConnector) and the pins should not be moved by the layout algorithm.

  The fixed mode works only if the link connector delivers consistently the same connection point when called multiple times. If a link is not connected to a link connector, or if the IlvClippingLinkConnector is used, the real connection point is calculated on the fly and may change when called multiple times with changing link bends. In this case, the fixed mode cannot ensure a correct routing of the links.

The default value is #FREE_MODE.

Note that the Link Layout dispatches the call to its sublayouts, the Short Link Layout and the Long Link Layout. Specifying a mode on the Link Layout means that the same mode is specified for both Short and Long Link Layouts.

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

verticalGridBase

public double verticalGridBase

Sets the vertical base coordinate of the grid. This is the y coordinate of the first horizontal grid line. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode #SHORT_LINKS, links are placed freely and the grid parameters are ignored.

The default value is 0.

CSS example: verticalGridBase : "3.0";

verticalGridOffset

public double verticalGridOffset

Sets the vertical offset between the grid lines. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode #SHORT_LINKS, links are placed freely and the grid parameters are ignored.

The default value is 5.

CSS example: verticalGridOffset : "3.0";

verticalMinOffset

public double verticalMinOffset

Sets the minimal vertical offset between the node border and a link segment that is (horizontally) parallel to the node border. It affects only the layout mode #LONG_LINKS where the links are routed on an orthogonal grid. In the layout mode #SHORT_LINKS, links are placed freely and the grid parameters are ignored.

The default value is 3.

CSS example: verticalMinOffset : "3.0";