Constructs a LayeredDigraphLayout with no Layout.network and with no owning Layout.diagram.
Optionalinit: Partial<LayeredDigraphLayout>Optional initialization properties.
Gets or sets which aggressive option is being used to look for link crossings. The default value is LayeredDigraphAggressive.Less. The fastest option is LayeredDigraphAggressive.None.
Gets or sets the options used by the straighten and pack function, as a faster alternative to packOption.
When using this option, nodes are assigned coordinates within their layers to produce straighter paths of nodes and small edge lengths.
When used as an alternative to packOption, this tends to be faster, particularly for larger graphs. Larger graphs, however, will usually be less compact than when using packOption. If this option is set, packOption is ignored.
This option does not use columns, but rather uses columnSpacing to space nodes within a layer.
The value must be a combination of the LayeredDigraphAlign bit flags.
Using LayeredDigraphAlign.All will tend to provide the most balanced results and is what we recommend starting with.
The default value is LayeredDigraphAlign.All. When the value is LayeredDigraphAlign.None, the packOption is used instead.
see
since2.3
Gets or sets the top-left point for where the graph should be positioned when laid out. The default value for this property is the Point(0, 0). Setting this property to a new value invalidates this layout. This property is likely to be set by many Layouts that belong to a Group when the layout is performed.
Gets or sets a function that determines the initial size and position in document coordinates of a LayoutVertex corresponding to a Node. This function is called by getLayoutBounds. The default value for this property is null, in which case the GraphObject.actualBounds of the Node is used. Setting this property to a new value invalidates this layout.
The non-null value must be a function that takes 3 arguments. The first argument will be the Part whose bounds the Layout should use. The second argument will be this Layout. The third argument will be a Rect that must be modified and returned The return value must be in document coordinates. You may find it convenient to call GraphObject.getDocumentBounds to get the bounds in document coordinates of an object within the node.
since2.0
Gets or sets how the nodes in each layer are positioned within each layer. Each node is aligned in the center of its layer according to its LayoutVertex.focus (the default positioning) or at the top or the left side of the layer if LayeredDigraphVertex.centered is false.
The default value is true. This property provides the default value for LayeredDigraphVertex.centered.
since3.1
Gets or sets the size of each column. This value must be positive and it defaults to 25.
When using alignOption, this will act as node spacing for nodes within a layer.
Gets or set which cycle removal option is used. The value must be a LayeredDigraphCycleRemove value. The default value is LayeredDigraphCycleRemove.DepthFirst.
ReadonlydiagramGets the Diagram that owns this layout, if it is the value of Diagram.layout.
If this property and group are non-null, the Group should be in this Diagram.
see
Gets or sets the direction the graph grows towards. 0 is towards the right, 90 is downwards, 180 is towards the left, and 270 is upwards. The default value is 0.
ReadonlygroupGets the Group that uses this layout, if it is the value of a group's Group.layout.
If this property is set to a Group, the diagram is automatically set to be the Group's Diagram.
see
Gets or sets which indices initialization option is being used. The value must be a LayeredDigraphInit value. The default value is LayeredDigraphInit.DepthFirstOut.
Gets or sets whether this layout is performed on an initial layout. The default value is true. Setting this property to false causes isValidLayout to be set to true so that the diagram does not perform this layout.
If you set both isInitial and isOngoing to false, there will be no automatic layout invalidation, because invalidateLayout will not set isValidLayout to false. To get your nodes to appear, you will need to explicitly set or data-bind their Part.location or GraphObject.position to real Point values, because automatic layout will not assign any positions.
Another way of controlling when layouts are invalidated is by setting Part.isLayoutPositioned or Part.layoutConditions.
Gets or sets whether this layout can be invalidated by invalidateLayout. Set this to false to prevent actions such as adding or removing Parts from invalidating this layout. The default value is true. Setting this property does not invalidate this layout.
If you set both isInitial and isOngoing to false, there will be no automatic layout invalidation, because invalidateLayout will not set isValidLayout to false. To get your nodes to appear, you will need to explicitly set or data-bind their Part.location or GraphObject.position to real Point values, because automatic layout will not assign any positions.
Another way of controlling when layouts are invalidated is by setting Part.isLayoutPositioned or Part.layoutConditions.
Gets or sets whether this layout be performed in real-time, before the end of a transaction. All layouts that are invalidated will be performed at the end of a transaction. The default value is null. A null value is treated as true for a Diagram.layout but false for a Group.layout. Setting this property does not invalidate this layout.
Gets or sets whether this layout routes Links. The default value is true. When false, this layout will not explicitly set the Link.points, and the default routing of each individual Link will take place after the Nodes are moved by commitLayout. Setting this property does not invalidate this layout.
Some layouts ignore links, in which case this property is ignored.
Gets or sets whether this layout needs to be performed again (if false). Instead of setting this property directly, it is normal to set it to false by calling invalidateLayout, since that also requests performing a layout in the near future.
Gets or sets whether this layout depends on the Diagram.viewportBounds's size. If set to true, the layout will invalidate when the Diagram's viewport changes size. This only applies to diagram layouts, not to group layouts, and only when Diagram.autoScale is set to AutoScale.None.
The default value is false. Setting this property to true will invalidate this layout.
It is possible that a viewport-sized layout will trigger the Diagram to require scrollbars, which modifies the Diagram.viewportBounds, which will in turn trigger another layout. This is uncommon, but possible with GridLayout if the results require a vertical scrollbar, and that vertical scrollbar shrinks the viewport width enough that a grid column can no longer fit. When designing custom layouts, one should be careful that this behavior does not result in an infinite loop.
Gets or sets the number of iterations to be done. The value must be non-negative. The default value is 4.
Gets or sets which layering option is being used. The value must be a LayeredDigraphLayering value. The default value is LayeredDigraphLayering.OptimalLinkLength, which is also the slowest option.
Gets or sets the space between each layer. This value must be non-negative and it defaults to 25.
ReadonlymaxThis read-only property returns the largest column value.
ReadonlymaxThis read-only property returns the largest index value.
ReadonlymaxThis read-only property returns the larges index layer.
ReadonlymaxThis read-only property returns the largest layer value.
ReadonlyminThis read-only property returns the smallest index layer.
Gets or sets the LayoutNetwork used by this Layout, if any. The default value is null. Setting this property does not invalidate this layout. Not all kinds of layout make use of a LayoutNetwork. Call createNetwork or makeNetwork to create a network.
Gets or sets the options used by the straighten and pack function; this option is deprecated -- alignOption usually produces a better alignment, faster.
The value must be a combination of bit flags. The default value is LayeredDigraphLayout.PackAll, which is a combination of all three flags.
Each of the flags has a cost; Expand is particularly slow. However if you do not set this property, this layout will automatically turn off the Expand option for you if the graph is large enough. You can set this property value to LayeredDigraphLayout.PackNone to avoid most of the work.
This option is ignored if alignOption is set to a value other than LayeredDigraphAlign.None. This tends to be slower than alignOption, particularly for larger graphs. Larger graphs, however, will usually be more compact than when using alignOption.
deprecatedsee
Gets or sets whether the FromSpot and ToSpot of each link should be set to values appropriate for the given value of LayeredDigraphLayout.direction. The default value is true.
If you set this to false, the spot values of the links and port objects will be used. If you do not set the spot values to sensible values matching the direction, the routing results may be poor and they may cross over nodes.
Protected VirtualassignAssigns every vertex in the input network to a layer. The layer is a non-negative integer describing which row of vertexes each vertex belongs in. (Do not confuse this concept of "layer" with Layers that control the Z-ordering of Parts.)
The layering satisfies the following relationship: if L is a link from node U to node V, then U.layer > V.layer.
This method can be overridden to customize how nodes are assigned layers. Please read the Learn page on Extensions for how to override methods and how to call this base method. By default, this does the appropriate assignments given the value of layeringOption.
ProtectedcollectA convenient way of converting the Diagram|Group|Iterable argument to doLayout to an actual collection of eligible Parts. The resulting Set will not include any Nodes or Links for which Part.canLayout is false. If the argument includes a Group for which Group.layout is null, the resulting Set will include the member parts of that group rather than that group itself. You will not need to call collectParts if you call makeNetwork, because that method does effectively the same thing when building the LayoutNetwork.
Typical usage:
public doLayout(coll) {
// COLL might be a Diagram or a Group or some Iterable<Part>
const it = this.collectParts(coll).iterator;
while (it.next()) {
const node = it.value;
if (node instanceof go.Node) {
. . . position the node . . .
}
}
}
Protected VirtualcommitThis overridable method is called by commitLayout to support custom arrangement of bands or labels across each layout layer. By default this method does nothing.
The coordinates used in the resulting Rects may need to be offset by the Layout.arrangementOrigin.
OverridecommitSet the fromSpot and toSpot on each Link, position each Node according to the vertex position, and then position/route the Links.
This calls the commitNodes and commitLinks methods, the latter only if isRouting is true. You should not call this method -- it is a "protected virtual" method. Please read the Learn page on Extensions for how to override methods and how to call this base method.
Protected VirtualcommitRoutes the links.
This is called by commitLayout. This is only called if Layout.isRouting is true. See also commitNodes. Please read the Learn page on Extensions for how to override methods and how to call this base method.
Protected VirtualcommitCommit the position of all nodes.
This is called by commitLayout. See also commitLinks. Please read the Learn page on Extensions for how to override methods and how to call this base method.
VirtualcopyCreates a copy of this Layout and returns it. When a Group is copied that has a Group.layout, the Layout must also be copied. This calls cloneProtected on a newly constructed Layout.
Virtual OverridecreateCreate a new LayoutNetwork of LayeredDigraphVertexes and LayeredDigraphEdges.
a new LayoutNetwork.
OverridedoPerform the layered digraph layout.
If there is no Layout.network, this calls makeNetwork to create a LayoutNetwork from the given collection of Parts. This removes any reflexive edges in the network, since they should be ignored.
In order to influence a vertex's layer, you can override assignLayers.
Finally this calls Layout.updateParts to commit the Node positions from the vertex positions. Layout.updateParts calls commitLayout within a transaction.
VirtualgetThis method is called by layouts to determine the size and initial position of the nodes that it is laying out. Normally this just returns the part's GraphObject.actualBounds. However, if boundsComputation has been set to a function, that function will be called in order to return the bounds of the given Part in document coordinates that the layout should pretend it has.
a Rect in document coordinates
since2.0
Protected VirtualinitialCompute the desired value of arrangementOrigin if this Layout is being performed for a Group.
This is typically called near the beginning of the implementation of doLayout:
this.arrangementOrigin = this.initialOrigin(this.arrangementOrigin);
if the layout wants to respect the pre-layout location of the Group when deciding where to position its member nodes.
If isOngoing is true and if an initial layout has not yet been performed, set the isValidLayout property to false, and ask to perform another layout in the near future. If isInitial is true, this layout is invalidated only when the Diagram.model is replaced, not under the normal circumstances such as when parts are added or removed or due to other calls to Layout._invalidateLayout.
If you set both isInitial and isOngoing to false, there will be no automatic layout invalidation, because this method will not set isValidLayout to false. However you can still set isValidLayout explicitly.
This is typically called when a layout property value has changed, or when a Part is added or removed or changes visibility, if Part.layoutConditions includes the pertinent flags.
VirtualmakeCreate and initialize a LayoutNetwork with the given nodes and links. This should be called by doLayout when this layout uses a network. This method calls createNetwork to allocate the network. This may be overridden in Layout subclasses to customize the initialization. Please read the Learn page on Extensions for how to override methods and how to call this base method.
normally the value of a call to createNetwork initialized by vertexes and edges corresponding to the coll argument.
VirtualupdateWhen using a LayoutNetwork, update the "physical" node positionings and link routings. This should be called by doLayout when this layout uses a network. This calls commitLayout to actually set Node positions and route Links. This performs the changes within a transaction. Please read the Learn page on Extensions for how to override methods and how to call this base method.
Static ReadonlyAggressivedeprecated
Static ReadonlyAggressivedeprecated
Static ReadonlyAggressivedeprecated
Static ReadonlyAligndeprecated
Static ReadonlyAligndeprecated
Static ReadonlyAligndeprecated
Static ReadonlyAligndeprecated
Static ReadonlyAligndeprecated
Static ReadonlyAligndeprecated
Static ReadonlyCycledeprecated
Static ReadonlyCycledeprecated
Static ReadonlyCycledeprecated
Static ReadonlyInitdeprecated
Static ReadonlyInitdeprecated
Static ReadonlyInitdeprecated
Static ReadonlyLayerdeprecated
Static ReadonlyLayerdeprecated
Static ReadonlyLayerdeprecated
Static ReadonlyPackdeprecatedStatic ReadonlyPackdeprecatedStatic ReadonlyPackdeprecatedStatic ReadonlyPackdeprecatedStatic ReadonlyPackdeprecated
This arranges nodes of directed graphs into layers (rows or columns). There are many samples that use LayeredDigraphLayout.
If you want to experiment interactively with most of the properties, try the Layered Digraph Layout sample. See samples that make use of LayeredDigraphLayout in the samples index.
The layerSpacing property controls the distance between layers. The columnSpacing property controls the breadth of each "column" -- this affects the distance between nodes within a layer, although the exact distance also depends on the breadth of each node. The layeringOption property determines whether nodes without links coming in or without links going out are lined up at the edge of the graph, or whether they are positioned close to their connected nodes.
By default the layout will route the links in a manner that is consistent with the direction. So, for example, if the direction is 90 degrees (i.e. downward), the links are expected to go from the top towards the bottom. That means the links should come out from the bottom of the ports and should go into the top of the ports. Basically the layout will set Link.fromSpot to
Spot.Bottomand Link.toSpot toSpot.Top.If you want to the links to use the spots that are given by the ports or by the links themselves, you will need to set setsPortSpots to false to prevent this layout from setting the spots on the links. For example, if each node only has one port that is the whole node, and if you want the links to be spread out along the sides of the nodes, then you should set setsPortSpots to false and set the node's GraphObject.fromSpot to
Spot.BottomSideand GraphObject.toSpot toSpot.TopSide.This layout handles links that form cycles better than TreeLayout does. The normal routing behavior for "backwards" links is to route them "around" the source node and "around" the destination node, so that all links come in one side and go out the other side. However if you want "backwards" links to go more directly between nodes, set setsPortSpots to false and the node's GraphObject.fromSpot and GraphObject.toSpot both to
Spot.TopBottomSides. (Of course if the direction is zero or 180, you'll want to useSpot.LeftRightSides.)If the diagram is structured in a tree-like fashion, it may be better to use TreeLayout, which has more options specific to trees. TreeLayout is much faster than LayeredDigraphLayout, and can handle a limited number of links that would prevent the graph structure from being a true tree (i.e. some nodes having multiple parents).
This layout makes use of a LayoutNetwork of LayeredDigraphVertexes and LayeredDigraphEdges that normally correspond to the Nodes and Links of the Diagram.
The layout algorithm consists of four-major steps: Cycle Removal, Layer Assignment, Crossing Reduction, and Straightening and Packing. The layout cannot guarantee that it provides optimal positioning of nodes or routing of links.
The Layer Assignment step can be slow if layeringOption is LayeredDigraphLayering.OptimalLinkLength, which is the default value.
The CrossingReduction step is usually slow, but it can be avoided if you want to maintain a certain order within each layer by setting LayeredDigraphLayout.aggressiveOption to LayeredDigraphAggressive.None.
The Straightening and Packing step is usually much slower if you set alignOption to LayeredDigraphAlign.None, which causes the older packOption to be used.
If performance remains a problem, contact us.