HierarchicLayout (yFiles-for-JavaFX-Complete-3.0 API)

java.lang.Object
- com.yworks.yfiles.layout.MultiStageLayout
- - com.yworks.yfiles.layout.hierarchic.HierarchicLayout

All Implemented Interfaces:

ILayoutAlgorithm
```
public class HierarchicLayout
extends MultiStageLayout
```
This layout algorithm arranges graphs in a hierarchic fashion.

Layout Style
The nodes are distributed into layers so that most of the edges point to the main layout direction. The order of the nodes within the layers ensures that the number of edge crossings is as small as possible. There are different edge routing styles available. Edges can be orthogonal, polyline or octilinear.

Hierarchical diagrams are commonly used for the visualization of hierarchical data, since they facilitate the identification of dependencies and relationships among the nodes of the graph. Possible application domains are the following: workflow visualization, call graph visualization, entity-relationship diagrams, biochemical pathways and network management.

Hierarchic Layout obtained with default settings
Concept
The layout algorithm runs in three main phases:
- Layering – The nodes are distributed into layers by means of FromScratchLayerer or FixedElementsLayerer, respectively. If the layout orientation is top-to-bottom, the nodes in each layer are arranged horizontally while the layers are ordered vertically top-to-bottom.
- Sequencing – The order of the nodes in each layer is determined such that the number of edge crossings is as small as possible. To specify the sequencing algorithm, use FromScratchSequencer or FixedElementsSequencer.
- Drawing – The layout algorithm assigns the final coordinates to all nodes and routes the edges.
Features

This layout algorithm is able to create hierarchic layouts from scratch or add new elements to the existing sketch drawing incrementally. In order to add elements incrementally to the current sketch or let the algorithm optimize certain elements in the current sketch, set the layout mode to LayoutMode.INCREMENTAL. Then register a IDataProvider (e.g. use Maps.createHashedDataMap()) with the graph using the INCREMENTAL_HINTS_DPKEY DataProvider key and associate the hints obtained from the IIncrementalHintsFactory with the elements to be added incrementally.

NodeLayoutDescriptor and EdgeLayoutDescriptor instances can be used for specifying individual information (e.g. distances or routing styles) for each node and edge in the graph. The descriptors are bound to the graph using IDataProviders registered with HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY or HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY. If there is no descriptor assigned to some nodes/edges, a default descriptor will be used. To set default descriptors use NodeLayoutDescriptor and EdgeLayoutDescriptor.

HierarchicLayout supports two approaches to connect edges on a specific side or even an exact location to a node. PortConstraints define a single constraint for the ports of an edge. To realize more complex port restrictions, several PortCandidates or PortCandidateSets can be assigned to edges or nodes. If an edge with registered PortCandidates connects to nodes with PortCandidateSets, the layouter will try to match both collections to find an appropriate port. In case there is no matching port candidate, a PortCandidate specified for the edge is preferred. Since their simultaneous existence at the same node may be ambiguous, it is not recommended to use a combination of PortConstraints and PortCandidates in the same layout.

The edge grouping feature of this layout algorithm is restricted to normal, hierarchic edges. Edges with recursive edge style RecursiveEdgeStyle.DIRECTED or RecursiveEdgeStyle.UNDIRECTED will not be grouped. They are also not grouped when enabling automatic edge grouping.

Field Summary

Fields
Modifier and Type	Field and Description
`static EdgeDpKey<YPointPath>`	`ALTERNATIVE_EDGE_PATH_DPKEY` A `DataProvider` key for associating alternative paths for edges connecting to groups, group content or folder nodes.
`static NodeDpKey<YRectangle>`	`ALTERNATIVE_GROUP_BOUNDS_DPKEY` A `DataProvider` key for associating an alternative bounds with the collapsed/expanded group.
`static EdgeDpKey<Integer>`	`CRITICAL_EDGE_PRIORITY_DPKEY` A `DataProvider` key for defining the priority of critical edges.
`static EdgeDpKey<Double>`	`EDGE_DIRECTEDNESS_DPKEY` A `DataProvider` key for specifying the directedness of edges.
`static EdgeDpKey<Double>`	`EDGE_THICKNESS_DPKEY` A `DataProvider` key for specifying the thickness of the edges.
`static NodeDpKey<Boolean>`	`FOLDER_NODES_DPKEY` A `DataProvider` key for marking folder nodes.
`static GraphObjectDpKey<Object>`	`INCREMENTAL_HINTS_DPKEY` A `DataProvider` key for specifying incremental hints.
`static GraphDpKey<Object>`	`LAYER_CONSTRAINTS_MEMENTO_DPKEY` A `DataProvider` key for storing the constraint graph
`static NodeDpKey<Integer>`	`LAYER_INDEX_DPKEY` A `DataAcceptor` key for publishing the layer IDs for all nodes in the graph.
`static GraphDpKey<Object>`	`SEQUENCE_CONSTRAINTS_MEMENTO_DPKEY` A `DataProvider` key for storing the constraint graph A `v1 before v2` constraint is represented as an edge between the representatives of `v1` and `v2` in the constraint graph.
`static NodeDpKey<Integer>`	`SEQUENCE_INDEX_DPKEY` A `DataAcceptor` key for publishing the index inside their layer for all nodes in the graph.
`static NodeDpKey<SwimlaneDescriptor>`	`SWIMLANE_DESCRIPTOR_DPKEY` A `DataProvider` key for defining swimlanes for the nodes.

Constructor Summary

Constructors
Constructor and Description

HierarchicLayout()
Creates a new HierarchicLayout instance with the default settings.

Constructors
Constructor and Description
`HierarchicLayout()` Creates a new `HierarchicLayout` instance with the default settings.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyLayoutCore(LayoutGraph graph)` Delegates the calculation of the hierarchic layout to a configured `HierarchicLayoutCore` instance.
`protected void`	`configureCoreLayout(LayoutGraph graph, HierarchicLayoutCore coreLayouter)` Configures the core layout algorithm with the settings of this `HierarchicLayout` instance.
`protected EdgeLayoutDescriptor`	`createEdgeLayoutDescriptor()` Returns a new `EdgeLayoutDescriptor` instance that will be used during the various phases of the layout algorithm to determine the drawing details of the edges of the graph.
`protected HierarchicLayoutCore`	`createHierarchicLayoutCore()` Returns a new `HierarchicLayoutCore` instance.
`IIncrementalHintsFactory`	`createIncrementalHintsFactory()` Returns a `IIncrementalHintsFactory` instance that must be used to obtain hints to be associated with graph elements that should be laid out incrementally.
`ILayerConstraintFactory`	`createLayerConstraintFactory(Graph graph)` Returns a `ILayerConstraintFactory` instance that can be used for specifying layer constraints for the given graph.
`protected NodeLayoutDescriptor`	`createNodeLayoutDescriptor()` Returns a new `NodeLayoutDescriptor` instance that will be used during the various phases of the layout algorithm to determine the drawing details of the nodes of the graph.
`ISequenceConstraintFactory`	`createSequenceConstraintFactory(LayoutGraph graph)` Returns a `ISequenceConstraintFactory` instance that can be used for specifying sequence constraints for the given graph.
`protected void`	`disposeCoreLayout(LayoutGraph graph, HierarchicLayoutCore coreLayouter)` Disposes of the core layout algorithm.
`ComponentArrangementPolicy`	`getComponentArrangementPolicy()` Gets the policy that specifies how to arrange connected components.
`protected DefaultDrawingDistanceCalculator`	`getDefaultDrawingDistanceCalculator()` Gets the `DefaultDrawingDistanceCalculator` that is registered with the layout algorithm by default.
`EdgeLayoutDescriptor`	`getEdgeLayoutDescriptor()` Gets the `EdgeLayoutDescriptor` instance used for all those edges that do not have a specific layout descriptor assigned.
`double`	`getEdgeToEdgeDistance()` Gets the minimum distance between two adjacent edges in one layer.
`ILayerer`	`getFixedElementsLayerer()` Gets the `ILayerer` instance that obtains the layering for fixed nodes during the incremental layout run.
`ISequencer`	`getFixedElementsSequencer()` Gets the `ISequencer` instance that calculates the sequence of the fixed nodes during the incremental layout run.
`ILayerer`	`getFromScratchLayerer()` Gets the `ILayerer` instance that obtains the layering for the nodes if the layout algorithm runs in `From Scratch mode`.
`LayeringStrategy`	`getFromScratchLayeringStrategy()` Gets a predefined layering strategy for the `from scratch` layerer.
`ISequencer`	`getFromScratchSequencer()` Gets the `ISequencer` instance that calculates the node sequence if the layout algorithm runs in `From Scratch mode`.
`double`	`getGridSpacing()` Gets the equidistant spacing between the horizontal and vertical grid lines.
`GroupAlignmentPolicy`	`getGroupAlignmentPolicy()` Gets the group layer alignment strategy used for recursive group layering.
`HierarchicLayoutCore`	`getHierarchicLayoutCore()` Gets the current layout algorithm instance.
`LayoutMode`	`getLayoutMode()` Gets the layout mode this layouter should use for upcoming layouts.
`long`	`getMaximumDuration()` Gets the time limit (in milliseconds) set for the layout algorithm.
`double`	`getMinimumLayerDistance()` Gets the minimum distance between two adjacent layers.
`protected MirrorModes`	`getMirrorMode()` Returns the mirror mask of the `orientation layouter`.
`NodeLayoutDescriptor`	`getNodeLayoutDescriptor()` Gets the `NodeLayoutDescriptor` instance used for all those nodes that do not have a specific layout descriptor assigned.
`INodePlacer`	`getNodePlacer()` Gets the `INodePlacer` instance that will calculate the final node placement of the layout.
`double`	`getNodeToEdgeDistance()` Gets the minimum distance between an edge and an adjacent node in one layer.
`double`	`getNodeToNodeDistance()` Gets the minimum distance between two adjacent nodes in one layer.
`boolean`	`isAutomaticEdgeGroupingEnabled()` Gets whether or not edges are grouped automatically.
`boolean`	`isBackLoopRoutingEnabled()` Gets whether or not reversed edges should be routed as back-loops.
`boolean`	`isBackLoopRoutingForSelfLoopsEnabled()` Gets whether or not self-loops should be routed in a similar manner as back-loops.
`boolean`	`isGroupCompactionEnabled()` Gets whether or not layer compaction for recursive group layering is active.
`boolean`	`isIntegratedEdgeLabelingEnabled()` Gets whether or not the layout algorithm reserves space for labels and places them.
`boolean`	`isLayerSeparationEnabled()` Gets whether or not to separate layers.
`boolean`	`isNodeLabelConsiderationEnabled()` Gets whether or not the layout algorithm considers node labels when calculating node positions to avoid overlaps.
`boolean`	`isOrthogonalRoutingEnabled()` Gets whether or not edges should be routed orthogonally.
`boolean`	`isRecursiveGroupLayeringEnabled()` Gets whether or not groups are respected during the layering stage.
`boolean`	`isStopAfterLayeringEnabled()` Gets whether or not to stop the layout algorithm after the layering step.
`boolean`	`isStopAfterSequencingEnabled()` Gets whether or not to stop the layout algorithm after the sequencing step.
`void`	`setAutomaticEdgeGroupingEnabled(boolean value)` Sets whether or not edges are grouped automatically.
`void`	`setBackLoopRoutingEnabled(boolean value)` Sets whether or not reversed edges should be routed as back-loops.
`void`	`setBackLoopRoutingForSelfLoopsEnabled(boolean value)` Sets whether or not self-loops should be routed in a similar manner as back-loops.
`void`	`setComponentArrangementPolicy(ComponentArrangementPolicy value)` Sets the policy that specifies how to arrange connected components.
`void`	`setEdgeLayoutDescriptor(EdgeLayoutDescriptor value)` Sets the `EdgeLayoutDescriptor` instance used for all those edges that do not have a specific layout descriptor assigned.
`void`	`setEdgeToEdgeDistance(double value)` Sets the minimum distance between two adjacent edges in one layer.
`void`	`setFixedElementsLayerer(ILayerer value)` Sets the `ILayerer` instance that obtains the layering for fixed nodes during the incremental layout run.
`void`	`setFixedElementsSequencer(ISequencer value)` Sets the `ISequencer` instance that calculates the sequence of the fixed nodes during the incremental layout run.
`void`	`setFromScratchLayerer(ILayerer value)` Sets the `ILayerer` instance that obtains the layering for the nodes if the layout algorithm runs in `From Scratch mode`.
`void`	`setFromScratchLayeringStrategy(LayeringStrategy value)` Sets a predefined layering strategy for the `from scratch` layerer.
`void`	`setFromScratchSequencer(ISequencer value)` Sets the `ISequencer` instance that calculates the node sequence if the layout algorithm runs in `From Scratch mode`.
`void`	`setGridSpacing(double value)` Sets the equidistant spacing between the horizontal and vertical grid lines.
`void`	`setGroupAlignmentPolicy(GroupAlignmentPolicy value)` Sets the group layer alignment strategy used for recursive group layering.
`void`	`setGroupCompactionEnabled(boolean value)` Sets whether or not layer compaction for recursive group layering is active.
`void`	`setIntegratedEdgeLabelingEnabled(boolean value)` Sets whether or not the layout algorithm reserves space for labels and places them.
`void`	`setLayerSeparationEnabled(boolean value)` Sets whether or not to separate layers.
`void`	`setLayoutMode(LayoutMode value)` Sets the layout mode this layouter should use for upcoming layouts.
`void`	`setMaximumDuration(long value)` Sets the time limit (in milliseconds) set for the layout algorithm.
`void`	`setMinimumLayerDistance(double value)` Sets the minimum distance between two adjacent layers.
`void`	`setNodeLabelConsiderationEnabled(boolean value)` Sets whether or not the layout algorithm considers node labels when calculating node positions to avoid overlaps.
`void`	`setNodeLayoutDescriptor(NodeLayoutDescriptor value)` Sets the `NodeLayoutDescriptor` instance used for all those nodes that do not have a specific layout descriptor assigned.
`void`	`setNodePlacer(INodePlacer value)` Sets the `INodePlacer` instance that will calculate the final node placement of the layout.
`void`	`setNodeToEdgeDistance(double value)` Sets the minimum distance between an edge and an adjacent node in one layer.
`void`	`setNodeToNodeDistance(double value)` Sets the minimum distance between two adjacent nodes in one layer.
`void`	`setOrthogonalRoutingEnabled(boolean value)` Sets whether or not edges should be routed orthogonally.
`void`	`setRecursiveGroupLayeringEnabled(boolean value)` Sets whether or not groups are respected during the layering stage.
`void`	`setStopAfterLayeringEnabled(boolean value)` Sets whether or not to stop the layout algorithm after the layering step.
`void`	`setStopAfterSequencingEnabled(boolean value)` Sets whether or not to stop the layout algorithm after the sequencing step.

Methods inherited from class com.yworks.yfiles.layout.MultiStageLayout
appendStage, applyLayout, checkNodeSize, disableAllStages, getComponentLayout, getHideGroupsStage, getLabeling, getLayoutOrientation, getOrientationLayout, getParallelEdgeRouter, getSelfLoopRouter, getSubgraphLayout, isComponentLayoutEnabled, isHideGroupsStageEnabled, isLabelingEnabled, isOrientationLayoutEnabled, isParallelEdgeRouterEnabled, isSelfLoopRouterEnabled, isSubgraphLayoutEnabled, prependStage, removeStage, setComponentLayout, setComponentLayoutEnabled, setHideGroupsStage, setHideGroupsStageEnabled, setLabeling, setLabelingEnabled, setLayoutOrientation, setOrientationLayout, setOrientationLayoutEnabled, setParallelEdgeRouter, setParallelEdgeRouterEnabled, setSelfLoopRouter, setSelfLoopRouterEnabled, setSubgraphLayout, setSubgraphLayoutEnabled

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

- Field Detail
  - ALTERNATIVE_EDGE_PATH_DPKEY
```
public static final EdgeDpKey<YPointPath> ALTERNATIVE_EDGE_PATH_DPKEY
```
    A DataProvider key for associating alternative paths for edges connecting to groups, group content or folder nodes.
    When running in incremental layout mode, the alternative edge paths are considered during the routing of fixed (i.e., non-incremental) edges.
    
    The alternative paths should be used in conjunction with alternative group bounds to achieve more stable layout results when collapsing/expanding a group node as follows:
    1. Collapsing: edges adjacent to the group itself and edges where one of the endpoints (source/target) lies inside the group should get the path before collapsing the group as alternative path. If both endpoints are either inside or outside the group, no alternative path is required.
    2. Expanding: edges adjacent to the expanded folder node (which is now a group) should get the path before expanding as alternative path.
    See Also:
    
    ALTERNATIVE_GROUP_BOUNDS_DPKEY
  - ALTERNATIVE_GROUP_BOUNDS_DPKEY
```
public static final NodeDpKey<YRectangle> ALTERNATIVE_GROUP_BOUNDS_DPKEY
```
    A DataProvider key for associating an alternative bounds with the collapsed/expanded group.
    When running in incremental layout mode, the alternative bounds of the collapsed/expanded group will be used during the layering and sequencing phase of the algorithm.
    
    The alternative bounds helps to achieve more stable layout results when collapsing/expanding groups in incremental layout mode. More precisely, the alternative bounds specifies the original size of the expanded/collapsed group (i.e., before expanding/collapsing).
    
    To further improve the results you should also specify alternative edge paths for edges adjacent to such groups. In addition, recursive group layering should be enabled and recursive edge style should be set to RecursiveEdgeStyle.DIRECTED. Edges that end at a group itself or a folder node should not have port candidates or port constraints at this end (because this may destroy the recursive directed edge style required to obtain stable results).
    
    The algorithm assumes that there is at most one node with associated alternative bounds.
    
    See Also:
    
    ALTERNATIVE_EDGE_PATH_DPKEY
  - CRITICAL_EDGE_PRIORITY_DPKEY
```
public static final EdgeDpKey<Integer> CRITICAL_EDGE_PRIORITY_DPKEY
```
    A DataProvider key for defining the priority of critical edges.
    Critical edges highlight different edge paths that are relevant for a user. The layouter tries to vertically align each node pair that is connected by a critical edge. Conflicts between different critical edges are always resolved in favor of the higher priority.
    
    Critical edges are always connected to the center port. Hence, the edge distribution is no longer uniform.
  - EDGE_DIRECTEDNESS_DPKEY
```
public static final EdgeDpKey<Double> EDGE_DIRECTEDNESS_DPKEY
```
    A DataProvider key for specifying the directedness of edges.
    Generally, the hierarchic layout algorithm assigns nodes to layers such that most of the edges point in the main layout direction. The directedness of an edge specifies whether it should comply with this strategy. More precisely, a value of 1 means that the edge should fully comply, a value of -1 that it should comply inversely (the edge should point against the main layout direction), and a value of 0 means that the direction doesn't matter at all and the endpoints of the edges may be placed at the same layer. If there are conflicting preferences, edges with higher absolute values are more likely to point in the desired direction.
    
    If no IDataProvider is registered with this key, the algorithm assumes that all edges have directedness 1.
    
    Considering the edge directedness requires a special layering algorithm. Hence, HierarchicLayout ignores the specified layerer and automatically switches to the ConstraintIncrementalLayerer in such cases.
  - EDGE_THICKNESS_DPKEY
```
public static final EdgeDpKey<Double> EDGE_THICKNESS_DPKEY
```
    A DataProvider key for specifying the thickness of the edges.
    The specified non-negative thickness is considered when calculating minimum distances so that there are no overlaps between edges and other graph elements. By default, each edge has thickness 0.
    
    The port assignments on grid and on sub-grid ignore the thickness of edges.
  - FOLDER_NODES_DPKEY
```
public static final NodeDpKey<Boolean> FOLDER_NODES_DPKEY
```
    A DataProvider key for marking folder nodes.
    When using recursive edge styles in incremental mode, edges will also start at the bottom and end at the top of marked folder nodes. This will keep the edge routes more stable since the connection sides won't change.
  - INCREMENTAL_HINTS_DPKEY
```
public static final GraphObjectDpKey<Object> INCREMENTAL_HINTS_DPKEY
```
    A DataProvider key for specifying incremental hints.
    Incremental hints are created using an incremental hints factory.
    
    See Also:
    
    HierarchicLayoutCore.INCREMENTAL_HINTS_DPKEY, IIncrementalHintsFactory
  - LAYER_CONSTRAINTS_MEMENTO_DPKEY
```
public static final GraphDpKey<Object> LAYER_CONSTRAINTS_MEMENTO_DPKEY
```
    A DataProvider key for storing the constraint graph
  - LAYER_INDEX_DPKEY
```
public static final NodeDpKey<Integer> LAYER_INDEX_DPKEY
```
    A DataAcceptor key for publishing the layer IDs for all nodes in the graph.
    
    If no IDataProvider is registered with this key, the layer information of the nodes is dropped.
    
    See Also:
    
    HierarchicLayoutCore.LAYER_INDEX_DPKEY
  - SEQUENCE_CONSTRAINTS_MEMENTO_DPKEY
```
public static final GraphDpKey<Object> SEQUENCE_CONSTRAINTS_MEMENTO_DPKEY
```
    A DataProvider key for storing the constraint graph
    A v1 before v2 constraint is represented as an edge between the representatives of v1 and v2 in the constraint graph.
  - SEQUENCE_INDEX_DPKEY
```
public static final NodeDpKey<Integer> SEQUENCE_INDEX_DPKEY
```
    A DataAcceptor key for publishing the index inside their layer for all nodes in the graph.
    
    If no IDataProvider is registered with this key, the sequence information of the nodes is dropped.
    
    See Also:
    
    HierarchicLayoutCore.SEQUENCE_INDEX_DPKEY
  - SWIMLANE_DESCRIPTOR_DPKEY
```
public static final NodeDpKey<SwimlaneDescriptor> SWIMLANE_DESCRIPTOR_DPKEY
```
    A DataProvider key for defining swimlanes for the nodes.
    The layout algorithm will arrange nodes in swimlanes according to the registered descriptors.
    
    Layout information about the swimlanes is finally written back to the descriptor instances. Instances can be shared among multiple nodes in the same lane.
    
    See Also:
    
    HierarchicLayoutCore.SWIMLANE_DESCRIPTOR_DPKEY
- Constructor Detail
  - HierarchicLayout
```
public HierarchicLayout()
```
    Creates a new HierarchicLayout instance with the default settings.
- Method Detail
  - applyLayoutCore
```
public void applyLayoutCore(LayoutGraph graph)
```
    Delegates the calculation of the hierarchic layout to a configured HierarchicLayoutCore instance.
    HierarchicLayout applies its own configuration to HierarchicLayoutCore and also prepares the graph for layout.
    
    Specified by:
    
    applyLayoutCore in class MultiStageLayout
    
    The given graph will not be copied during the layout process and the layout will be immediately applied to the given graph.
    
    Parameters:
    
    graph - the input graph
  - configureCoreLayout
```
protected void configureCoreLayout(LayoutGraph graph,
                                   HierarchicLayoutCore coreLayouter)
```
    Configures the core layout algorithm with the settings of this HierarchicLayout instance.
    This method is called by applyLayoutCore(LayoutGraph) before the actual layout is calculated. It may be overridden in order to manually reconfigure the core layout algorithm.
    
    This implementation will temporarily set a PortCandidateOptimizer if a IDataProvider is registered with PortCandidateSet.NODE_PORT_CANDIDATE_SET_DPKEY and no PortConstraintOptimizer is assigned.
    
    Everything that is added to the graph or the core layout algorithm needs to be removed in disposeCoreLayout(LayoutGraph, HierarchicLayoutCore).
    
    Parameters:
    
    graph - the input graph
    
    coreLayouter - the given core layout algorithm instance
  - createEdgeLayoutDescriptor
```
protected EdgeLayoutDescriptor createEdgeLayoutDescriptor()
```
    Returns a new EdgeLayoutDescriptor instance that will be used during the various phases of the layout algorithm to determine the drawing details of the edges of the graph.
    This method may be overridden to create a new EdgeLayoutDescriptor instance with different configuration settings.
    
    Returns:
    
    a new EdgeLayoutDescriptor instance
  - createHierarchicLayoutCore
```
protected HierarchicLayoutCore createHierarchicLayoutCore()
```
    Returns a new HierarchicLayoutCore instance.
    This method may be overridden to create a new HierarchicLayoutCore object with different configuration settings.
    
    This factory method provides the initial HierarchicLayoutCore instance.
    
    Returns:
    
    a new HierarchicLayoutCore instance
  - createIncrementalHintsFactory
```
public IIncrementalHintsFactory createIncrementalHintsFactory()
```
    Returns a IIncrementalHintsFactory instance that must be used to obtain hints to be associated with graph elements that should be laid out incrementally.
    Use this factory and a IDataProvider that is registered to the graph using the INCREMENTAL_HINTS_DPKEY key to associate appropriate hints with the graph elements that should be laid out incrementally by the algorithm.
    
    Returns:
    
    a new IIncrementalHintsFactory instance
    
    See Also:
    
    HierarchicLayoutCore.createIncrementalHintsFactory(), INCREMENTAL_HINTS_DPKEY, Graph.addDataProvider(Object, IDataProvider), setLayoutMode(LayoutMode), LayoutMode.INCREMENTAL
  - createLayerConstraintFactory
```
public ILayerConstraintFactory createLayerConstraintFactory(Graph graph)
```
    Returns a ILayerConstraintFactory instance that can be used for specifying layer constraints for the given graph.
    The instance is usually bound to Graph instance graph, i.e., if the input graph for the layerer changes, a new instance must be retrieved. This instance can be used for creating constraints for this graph instance.
    
    You can create an instance without binding it to a graph instance initially by passing a null parameter. In that case, you must bind the returned instance to the graph, see LayerConstraintFactoryCompanion.LAYER_CONSTRAINTS_MEMENTO_DPKEY and Memento.
    
    ILayerConstraintFactory instances have to be disposed after use. Disposing the factory will also remove all constraints previously specified for the factory's associated graph. Creating layering constraints with a disposed factory will throw an IllegalStateException.
    
    Parameters:
    
    graph - the input graph
    
    Returns:
    
    a new ILayerConstraintFactory instance
  - createNodeLayoutDescriptor
```
protected NodeLayoutDescriptor createNodeLayoutDescriptor()
```
    Returns a new NodeLayoutDescriptor instance that will be used during the various phases of the layout algorithm to determine the drawing details of the nodes of the graph.
    This method may be overridden to create a new NodeLayoutDescriptor instance with different configuration settings.
    
    Returns:
    
    a new NodeLayoutDescriptor instance
  - createSequenceConstraintFactory
```
public ISequenceConstraintFactory createSequenceConstraintFactory(LayoutGraph graph)
```
    Returns a ISequenceConstraintFactory instance that can be used for specifying sequence constraints for the given graph.
    For these sequence constraints to have any effect, the ISequencer that determines the in-layer node order (sequence) has to support constraints. Both, DefaultLayerSequencer and the incremental sequencer used internally support sequence constraints.
    
    ISequenceConstraintFactory instances have to be disposed of after use. Disposing of the factory will also remove all constraints previously specified for the factory's associated graph. Creating sequence constraints with a disposed of factory will throw an IllegalStateException.
    
    Parameters:
    
    graph - the input graph
    
    Returns:
    
    a ISequenceConstraintFactory instance
    
    See Also:
    
    setFromScratchSequencer(ISequencer), setFixedElementsSequencer(ISequencer)
  - disposeCoreLayout
```
protected void disposeCoreLayout(LayoutGraph graph,
                                 HierarchicLayoutCore coreLayouter)
```
    Disposes of the core layout algorithm.
    This method is called by applyLayoutCore(LayoutGraph) after the actual layout is calculated. It may be overridden in order to revert a custom configuration made in configureCoreLayout(LayoutGraph, HierarchicLayoutCore).
    
    This implementation will remove the PortCandidateOptimizer that was created in case a IDataProvider is registered with PortCandidateSet.NODE_PORT_CANDIDATE_SET_DPKEY and no PortConstraintOptimizer was initially assigned.
    
    Everything that was added to the graph or the core layout algorithm in configureCoreLayout(LayoutGraph, HierarchicLayoutCore) needs to be removed here.
    
    Parameters:
    
    graph - the input graph
    
    coreLayouter - the given core layout algorithm instance
  - getComponentArrangementPolicy
```
public ComponentArrangementPolicy getComponentArrangementPolicy()
```
    Gets the policy that specifies how to arrange connected components.
    
    Throws:
    
    IllegalArgumentException - if the specified policy does not match a default component arrangement policy
    
    Default Value:
    The default value is ComponentArrangementPolicy.TOPMOST. Connected components are aligned with their first layer.
    
    Returns:
    
    one of the default component arrangement policies
    
    See Also:
    
    setComponentArrangementPolicy(ComponentArrangementPolicy)
  - getDefaultDrawingDistanceCalculator
```
protected DefaultDrawingDistanceCalculator getDefaultDrawingDistanceCalculator()
```
    Gets the DefaultDrawingDistanceCalculator that is registered with the layout algorithm by default.
    
    Throws:
    
    IllegalStateException - if the current instance returned by DrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    Returns:
    
    the current DefaultDrawingDistanceCalculator instance
  - getEdgeLayoutDescriptor
```
public EdgeLayoutDescriptor getEdgeLayoutDescriptor()
```
    Gets the EdgeLayoutDescriptor instance used for all those edges that do not have a specific layout descriptor assigned.
    By default, this method will return a EdgeLayoutDescriptor instance created with createEdgeLayoutDescriptor().
    
    Throws:
    
    IllegalArgumentException - if the EdgeLayoutDescriptor is null
    
    Default Value:
    The default value is EdgeLayoutDescriptor
    
    Returns:
    
    the current EdgeLayoutDescriptor instance
    
    See Also:
    
    HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY, setEdgeLayoutDescriptor(EdgeLayoutDescriptor)
  - getEdgeToEdgeDistance
```
public double getEdgeToEdgeDistance()
```
    Gets the minimum distance between two adjacent edges in one layer.
    All values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    IllegalStateException - if the current IDrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    If edges should use different distances, you can map them to different EdgeLayoutDescriptor instances (see HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY) with custom minimum distance values.
    
    Default Value:
    The default value is 20.
    
    Returns:
    
    the non-negative minimum distance
    
    See Also:
    
    setEdgeToEdgeDistance(double)
  - getFixedElementsLayerer
```
public ILayerer getFixedElementsLayerer()
```
    Gets the ILayerer instance that obtains the layering for fixed nodes during the incremental layout run.
    
    Throws:
    
    IllegalArgumentException - if the ILayerer is null
    
    Default Value:
    The default value is AsIsLayerer
    
    Returns:
    
    the ILayerer instance used for fixed nodes
    
    See Also:
    
    setLayoutMode(LayoutMode), setFixedElementsLayerer(ILayerer)
  - getFixedElementsSequencer
```
public ISequencer getFixedElementsSequencer()
```
    Gets the ISequencer instance that calculates the sequence of the fixed nodes during the incremental layout run.
    
    Throws:
    
    IllegalArgumentException - if the given ISequencer is null
    
    Default Value:
    The default value is AsIsSequencer
    
    Returns:
    
    the ISequencer instance used for fixed elements
    
    See Also:
    
    setLayoutMode(LayoutMode), setFixedElementsSequencer(ISequencer)
  - getFromScratchLayerer
```
public ILayerer getFromScratchLayerer()
```
    Gets the ILayerer instance that obtains the layering for the nodes if the layout algorithm runs in From Scratch mode.
    If the graph consists of multiple components, then the ILayerer instance should be wrapped in MultiComponentLayerer.
    
    Throws:
    
    IllegalArgumentException - if the ILayerer is null
    
    Default Value:
    The default value is WeightedLayerer
    
    Returns:
    
    the ILayerer instance
    
    See Also:
    
    setLayoutMode(LayoutMode), setFromScratchLayerer(ILayerer)
  - getFromScratchLayeringStrategy
```
public LayeringStrategy getFromScratchLayeringStrategy()
```
    Gets a predefined layering strategy for the from scratch layerer.
    The layouter assigns the nodes to separate layers. The nodes within each layer will be placed on the same horizontal layer. The layers will be arranged vertically starting with the small-numbered layers.
    
    An important layering strategy for the hierarchic layout style is called Hierarchical Layering. A hierarchical layering tries to assign nodes to layers in a way such that as much edges of the graph as possible will point to the main layout direction, i.e., the start nodes of the edges will be in a layer with a smaller number than the corresponding end nodes. Also, a hierarchical layering will never put two connected nodes in the same layer.
    
    This method wraps the internal implementations into a MultiComponentLayerer instance so that it is possible to specify the behavior of the algorithm if the component layouter is disabled.
    
    Throws:
    
    IllegalArgumentException - if an unknown strategy is given
    
    Default Value:
    The default value is LayeringStrategy.HIERARCHICAL_OPTIMAL
    
    Returns:
    
    one of the predefined layering strategies
    
    See Also:
    
    setFromScratchLayeringStrategy(LayeringStrategy)
  - getFromScratchSequencer
```
public ISequencer getFromScratchSequencer()
```
    Gets the ISequencer instance that calculates the node sequence if the layout algorithm runs in From Scratch mode.
    
    Throws:
    
    IllegalArgumentException - if the ISequencer is null
    
    Default Value:
    The default value is DefaultLayerSequencer
    
    Returns:
    
    the ISequencer instance
    
    See Also:
    
    getFromScratchLayerer(), setLayoutMode(LayoutMode), setFromScratchSequencer(ISequencer)
  - getGridSpacing
```
public double getGridSpacing()
```
    Gets the equidistant spacing between the horizontal and vertical grid lines.
    When the spacing is negative or zero, no grid is defined, otherwise nodes and edges are placed on multiples of the grid spacing.
    
    The grid feature doesn't work together with exact (layer/sequence) coordinate hints.
    
    Default Value:
    The default value is 0. There is no grid specified.
    
    Returns:
    
    the grid spacing
    
    See Also:
    
    IIncrementalHintsFactory, setGridSpacing(double)
  - getGroupAlignmentPolicy
```
public GroupAlignmentPolicy getGroupAlignmentPolicy()
```
    Gets the group layer alignment strategy used for recursive group layering.
    
    Throws:
    
    IllegalArgumentException - if an unknown group alignment policy is given
    
    Default Value:
    The default value is GroupAlignmentPolicy.CENTER. Groups and normal nodes are center aligned.
    
    Returns:
    
    one of the default group alignment policies
    
    See Also:
    
    setRecursiveGroupLayeringEnabled(boolean), setGroupAlignmentPolicy(GroupAlignmentPolicy)
  - getHierarchicLayoutCore
```
public HierarchicLayoutCore getHierarchicLayoutCore()
```
    Gets the current layout algorithm instance.
    By default, this method will return a HierarchicLayoutCore instance created with createHierarchicLayoutCore().
    
    Returns:
    
    the HierarchicLayoutCore instance
    
    See Also:
    
    createHierarchicLayoutCore()
  - getLayoutMode
```
public LayoutMode getLayoutMode()
```
    Gets the layout mode this layouter should use for upcoming layouts.
    Depending on the mode the layout algorithm will use different ILayerer and ISequencer implementations.
    
    Throws:
    
    IllegalArgumentException - if the given layout mode is unknown
    
    Default Value:
    The default value is LayoutMode.FROM_SCRATCH
    
    Returns:
    
    the new layout mode
    
    See Also:
    
    getFromScratchLayerer(), getFromScratchSequencer(), getFixedElementsLayerer(), getFixedElementsSequencer(), setLayoutMode(LayoutMode)
  - getMaximumDuration
```
public long getMaximumDuration()
```
    Gets the time limit (in milliseconds) set for the layout algorithm.
    Values have to be greater or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the maximum duration is negative
    
    Restricting the maximum duration may result in a lower layout quality. Furthermore, the real runtime may exceed the maximum duration since the layout algorithm still has to find a valid solution.
    
    Default Value:
    The default value is Long.MAX_VALUE. The layout algorithm runs unrestricted.
    
    Returns:
    
    a non-negative value that specifies the time limit
    
    See Also:
    
    setMaximumDuration(long)
  - getMinimumLayerDistance
```
public double getMinimumLayerDistance()
```
    Gets the minimum distance between two adjacent layers.
    The specified distance should have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    Default Value:
    The default value is 20.
    
    Returns:
    
    the non-negative minimum distance
    
    See Also:
    
    setMinimumLayerDistance(double)
  - getMirrorMode
```
protected MirrorModes getMirrorMode()
```
    Returns the mirror mask of the orientation layouter.
    It may be overridden in order to configure a different mirror mask.
    
    Returns:
    
    the mirror mask
  - getNodeLayoutDescriptor
```
public NodeLayoutDescriptor getNodeLayoutDescriptor()
```
    Gets the NodeLayoutDescriptor instance used for all those nodes that do not have a specific layout descriptor assigned.
    By default, this method will return a NodeLayoutDescriptor instance created with createNodeLayoutDescriptor().
    
    Throws:
    
    IllegalArgumentException - if the given NodeLayoutDescriptor is null
    
    Default Value:
    The default value is NodeLayoutDescriptor
    
    Returns:
    
    the current NodeLayoutDescriptor instance
    
    See Also:
    
    HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY, createNodeLayoutDescriptor(), setNodeLayoutDescriptor(NodeLayoutDescriptor)
  - getNodePlacer
```
public INodePlacer getNodePlacer()
```
    Gets the INodePlacer instance that will calculate the final node placement of the layout.
    
    Throws:
    
    IllegalArgumentException - if the INodePlacer is null
    
    Default Value:
    The default value is SimplexNodePlacer
    
    Returns:
    
    the INodePlacer instance
    
    See Also:
    
    setNodePlacer(INodePlacer)
  - getNodeToEdgeDistance
```
public double getNodeToEdgeDistance()
```
    Gets the minimum distance between an edge and an adjacent node in one layer.
    All values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    IllegalStateException - if the current IDrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    If nodes/edges should use different distances, you can map them to different NodeLayoutDescriptor /EdgeLayoutDescriptor instances (see HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY and HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY) with custom minimum distance values.
    
    Default Value:
    The default value is 15.
    
    Returns:
    
    the non-negative minimum distance
    
    See Also:
    
    setNodeToEdgeDistance(double)
  - getNodeToNodeDistance
```
public double getNodeToNodeDistance()
```
    Gets the minimum distance between two adjacent nodes in one layer.
    All values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    IllegalStateException - if the current IDrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    If nodes should use different distances, you can map them to different NodeLayoutDescriptor instances (see HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY) with custom minimum distance values.
    
    Default Value:
    The default value is 30.
    
    Returns:
    
    the non-negative minimum distance
    
    See Also:
    
    setNodeToNodeDistance(double)
  - isAutomaticEdgeGroupingEnabled
```
public boolean isAutomaticEdgeGroupingEnabled()
```
    Gets whether or not edges are grouped automatically.
    The automatic edge grouping tries to group a high number of edges without changing the semantic of the graph, i.e., it groups edges either at a common source node or a common target node. Edge groupings often allow more compact layouts since grouped edges are routed in a bus-style manner.
    
    Edges are only grouped at their source (target) node if they do not have port constraints, port candidates or port group ids (see PortConstraintKeys.SOURCE_PORT_GROUP_ID_DPKEY and PortConstraintKeys.TARGET_PORT_GROUP_ID_DPKEY) at this node. Furthermore, edges cannot be grouped at a node with specified port candidate set.
    
    User specified edge groups are not considered.
    
    Default Value:
    The default value is false. Edges are not grouped automatically.
    
    Returns:
    
    true if the edge grouping should be applied, false otherwise
    
    See Also:
    
    setAutomaticEdgeGroupingEnabled(boolean)
  - isBackLoopRoutingEnabled
```
public boolean isBackLoopRoutingEnabled()
```
    Gets whether or not reversed edges should be routed as back-loops.
    When this option is enabled, back-loops attach to the same node sides as the other edges, i.e., for layout orientation top-to-bottom, they leave their source at the bottom and enter their target at the top.
    
    Port constraints and port candidates are still considered.
    
    This setting is ignored for edges with recursive edge styles RecursiveEdgeStyle.DIRECTED and RecursiveEdgeStyle.UNDIRECTED, including edges where source or target are not inside a group node.
    
    Default Value:
    The default value is false. There is no back-loop routing applied to reversed edges.
    
    Returns:
    
    true if back-loop routing is applied, false otherwise
    
    See Also:
    
    setBackLoopRoutingEnabled(boolean)
  - isBackLoopRoutingForSelfLoopsEnabled
```
public boolean isBackLoopRoutingForSelfLoopsEnabled()
```
    Gets whether or not self-loops should be routed in a similar manner as back-loops.
    Self-loops will start at the bottom of their attached nodes and end at the top of them.
    
    Port constraints and port candidates are still considered.
    
    Back-loop routing for self-loops only applies if back-loop routing is enabled.
    
    Default Value:
    The default value is false. There is no back-loop routing applied to self-loops.
    
    Returns:
    
    true if self-loops should be routed like back-loops, false otherwise
    
    See Also:
    
    isBackLoopRoutingEnabled(), setBackLoopRoutingForSelfLoopsEnabled(boolean)
  - isGroupCompactionEnabled
```
public boolean isGroupCompactionEnabled()
```
    Gets whether or not layer compaction for recursive group layering is active.
    The number of node layers is decreased if possible without reversing edge directions. The resulting layering tries to keep the layer span of a group node minimum while minimizing the overall vertical space.
    
    This feature works best when an instance of TopologicalLayerer is used for layer assignment. If this feature is enabled, an alignment policy that is set with GroupAlignmentPolicy is ignored.
    
    Group compaction only applies when recursive group layering is enabled. During non-recursive layering, groups are ignored completely.
    
    Default Value:
    The default value is false. The layer compaction is disabled.
    
    Returns:
    
    true if group compaction is active, false otherwise
    
    See Also:
    
    setRecursiveGroupLayeringEnabled(boolean), setGroupCompactionEnabled(boolean)
  - isIntegratedEdgeLabelingEnabled
```
public boolean isIntegratedEdgeLabelingEnabled()
```
    Gets whether or not the layout algorithm reserves space for labels and places them.
    To define the desired placement for each label add a PreferredPlacementDescriptor on IEdgeLabelLayout.
    
    This method is a convenience method that assures that the labeling algorithm is of type LabelLayoutTranslator and EdgeLabelTranslationEnabled is set to true.
    
    Throws:
    
    IllegalStateException - if integrated labeling should be enabled but the current labeling algorithm is not of type LabelLayoutTranslator
    
    IllegalStateException - if no properly configured LabelLayoutTranslator is registered even though integrated labeling was enabled earlier (can happen when manually specifying the labeling algorithm).
    
    When enabling this property, any previously specified labeling algorithm will be overwritten and when disabling it, any currently specified labeling algorithm will be disabled via property LabelingEnabled. Therefore, it is recommended to only use this convenience property instead of manually changing the mentioned other properties.
    
    Default Value:
    The default value is false. Integrated edge labeling is disabled.
    
    Returns:
    
    true if integrated edge labeling is enabled, false otherwise
    
    See Also:
    
    setIntegratedEdgeLabelingEnabled(boolean)
  - isLayerSeparationEnabled
```
public boolean isLayerSeparationEnabled()
```
    Gets whether or not to separate layers.
    In case layers are not separated, nodes of a layer may extend into adjacent layers. Otherwise, nodes of different layers are strictly separated, i.e., layers are placed below each other.
    
    The alignment of nodes within their layer is not affected by this property.
    
    Default Value:
    The default value is true. Layers are separated.
    
    Returns:
    
    true if layers are separated, false otherwise
    
    See Also:
    
    setLayerSeparationEnabled(boolean)
  - isNodeLabelConsiderationEnabled
```
public boolean isNodeLabelConsiderationEnabled()
```
    Gets whether or not the layout algorithm considers node labels when calculating node positions to avoid overlaps.
    This method is a convenience method that assures that the labeling algorithm is of type LabelLayoutTranslator and NodeLabelTranslationEnabled is set to true.
    
    Throws:
    
    IllegalStateException - if this property should be enabled but the current labeling algorithm is not of type LabelLayoutTranslator
    
    IllegalStateException - if no properly configured LabelLayoutTranslator is registered even though this property was enabled earlier (can happen when manually specifying the labeling algorithm).
    
    Enabling this option may overwrite the current labeling algorithm. Hence, to combine this option with a generic edge labeling algorithm, the generic labeling has to be applied in an additional step after calculating the layout.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Returns:
    
    true if the layout algorithm takes the node labels into account, false otherwise
    
    See Also:
    
    setNodeLabelConsiderationEnabled(boolean)
  - isOrthogonalRoutingEnabled
```
public boolean isOrthogonalRoutingEnabled()
```
    Gets whether or not edges should be routed orthogonally.
    When orthogonal routing is enabled, all resulting edge paths will be composed of vertical and horizontal segments, only.
    
    This is a convenience method that sets the routing style for the default edge layout descriptor to orthogonal.
    
    Default Value:
    The default value is false. Edges are not orthogonally routed.
    
    Returns:
    
    true if edges are routed orthogonally, false otherwise
    
    See Also:
    
    setOrthogonalRoutingEnabled(boolean)
  - isRecursiveGroupLayeringEnabled
```
public boolean isRecursiveGroupLayeringEnabled()
```
    Gets whether or not groups are respected during the layering stage.
    If this option is enabled, groups are layered recursively, i.e.
    - nodes in the same group always occupy adjacent layers
    - layer intervals spanned by different group nodes are either disjoint or are nested
    If it is disabled, group information is ignored for the layering step.
    
    If the graph is flat, this setting is ignored.
    In case group compaction is enabled, groups are layered non-recursively.
    
    Default Value:
    The default value is true. Groups are layered recursively.
    
    Returns:
    
    true if group information is used, false otherwise
    
    See Also:
    
    setGroupCompactionEnabled(boolean), setRecursiveGroupLayeringEnabled(boolean)
  - isStopAfterLayeringEnabled
```
public boolean isStopAfterLayeringEnabled()
```
    Gets whether or not to stop the layout algorithm after the layering step.
    By then, each node will be assigned to a layer. Since the sequencing and drawing phases are skipped, the order of the nodes within a layer matches the initial order of the nodes, edges won't be routed and the nodes won't get coordinates assigned.
    
    The calculated layering information can be retrieved from the IDataProvider registered with the key LAYER_INDEX_DPKEY.
    
    The layout algorithm may be stopped here if only the layer assignment is important and the sequencing or the actual drawing is not needed. For example, an initial layout run may be needed to determine the layering for a second layout run that will work with this information. Then stopping after layering will save runtime.
    
    The bounds of group nodes depend on the locations of their content and the routes of connecting edges. Therefore, they are not yet calculated after the layering phase and will have width and height 1.
    
    Default Value:
    The default value is false. The algorithm calculates the complete layout.
    
    Returns:
    
    true if the layout algorithm should stop after the layering phase, false if the complete layout should be calculated
    
    See Also:
    
    LAYER_INDEX_DPKEY, setStopAfterLayeringEnabled(boolean)
  - isStopAfterSequencingEnabled
```
public boolean isStopAfterSequencingEnabled()
```
    Gets whether or not to stop the layout algorithm after the sequencing step.
    By then, each node will be assigned to a layer and will have a place in the sequence of nodes in this layer. Since the drawing phase is skipped, edges won't be routed and the nodes won't get coordinates assigned.
    
    The calculated layering and sequencing information can be retrieved from the IDataProviders registered with the keys LAYER_INDEX_DPKEY and SEQUENCE_INDEX_DPKEY.
    
    The layout algorithm may be stopped here if only the location within the layers is important and the actual drawing is not needed. For example, an initial layout run may be needed to determine the layering and the sequencing for a second layout run that will work with this information. Then stopping after sequencing will save runtime.
    
    The bounds of group nodes depend on the locations of their content and the routes of connecting edges. Therefore, they are not yet calculated after the sequencing phase and will have width and height 1.
    
    Default Value:
    The default value is false. The algorithm calculates the complete layout.
    
    Returns:
    
    true if the layout algorithm should stop after the sequencing phase, false if the complete layout should be calculated
    
    See Also:
    
    SEQUENCE_INDEX_DPKEY, LAYER_INDEX_DPKEY, setStopAfterSequencingEnabled(boolean)
  - setAutomaticEdgeGroupingEnabled
```
public void setAutomaticEdgeGroupingEnabled(boolean value)
```
    Sets whether or not edges are grouped automatically.
    The automatic edge grouping tries to group a high number of edges without changing the semantic of the graph, i.e., it groups edges either at a common source node or a common target node. Edge groupings often allow more compact layouts since grouped edges are routed in a bus-style manner.
    
    Edges are only grouped at their source (target) node if they do not have port constraints, port candidates or port group ids (see PortConstraintKeys.SOURCE_PORT_GROUP_ID_DPKEY and PortConstraintKeys.TARGET_PORT_GROUP_ID_DPKEY) at this node. Furthermore, edges cannot be grouped at a node with specified port candidate set.
    
    User specified edge groups are not considered.
    
    Default Value:
    The default value is false. Edges are not grouped automatically.
    
    Parameters:
    
    value - true if the edge grouping should be applied, false otherwise
    
    See Also:
    
    isAutomaticEdgeGroupingEnabled()
  - setBackLoopRoutingEnabled
```
public void setBackLoopRoutingEnabled(boolean value)
```
    Sets whether or not reversed edges should be routed as back-loops.
    When this option is enabled, back-loops attach to the same node sides as the other edges, i.e., for layout orientation top-to-bottom, they leave their source at the bottom and enter their target at the top.
    
    Port constraints and port candidates are still considered.
    
    This setting is ignored for edges with recursive edge styles RecursiveEdgeStyle.DIRECTED and RecursiveEdgeStyle.UNDIRECTED, including edges where source or target are not inside a group node.
    
    Default Value:
    The default value is false. There is no back-loop routing applied to reversed edges.
    
    Parameters:
    
    value - true if back-loop routing is applied, false otherwise
    
    See Also:
    
    isBackLoopRoutingEnabled()
  - setBackLoopRoutingForSelfLoopsEnabled
```
public void setBackLoopRoutingForSelfLoopsEnabled(boolean value)
```
    Sets whether or not self-loops should be routed in a similar manner as back-loops.
    Self-loops will start at the bottom of their attached nodes and end at the top of them.
    
    Port constraints and port candidates are still considered.
    
    Back-loop routing for self-loops only applies if back-loop routing is enabled.
    
    Default Value:
    The default value is false. There is no back-loop routing applied to self-loops.
    
    Parameters:
    
    value - true if self-loops should be routed like back-loops, false otherwise
    
    See Also:
    
    isBackLoopRoutingEnabled(), isBackLoopRoutingForSelfLoopsEnabled()
  - setComponentArrangementPolicy
```
public void setComponentArrangementPolicy(ComponentArrangementPolicy value)
```
    Sets the policy that specifies how to arrange connected components.
    
    Throws:
    
    IllegalArgumentException - if the specified policy does not match a default component arrangement policy
    
    Default Value:
    The default value is ComponentArrangementPolicy.TOPMOST. Connected components are aligned with their first layer.
    
    Parameters:
    
    value - one of the default component arrangement policies
    
    See Also:
    
    getComponentArrangementPolicy()
  - setEdgeLayoutDescriptor
```
public void setEdgeLayoutDescriptor(EdgeLayoutDescriptor value)
```
    Sets the EdgeLayoutDescriptor instance used for all those edges that do not have a specific layout descriptor assigned.
    By default, this method will return a EdgeLayoutDescriptor instance created with createEdgeLayoutDescriptor().
    
    Throws:
    
    IllegalArgumentException - if the EdgeLayoutDescriptor is null
    
    Default Value:
    The default value is EdgeLayoutDescriptor
    
    Parameters:
    
    value - the current EdgeLayoutDescriptor instance
    
    See Also:
    
    HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY, getEdgeLayoutDescriptor()
  - setEdgeToEdgeDistance
```
public void setEdgeToEdgeDistance(double value)
```
    Sets the minimum distance between two adjacent edges in one layer.
    All values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    IllegalStateException - if the current IDrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    If edges should use different distances, you can map them to different EdgeLayoutDescriptor instances (see HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY) with custom minimum distance values.
    
    Default Value:
    The default value is 20.
    
    Parameters:
    
    value - the non-negative minimum distance
    
    See Also:
    
    getEdgeToEdgeDistance()
  - setFixedElementsLayerer
```
public void setFixedElementsLayerer(ILayerer value)
```
    Sets the ILayerer instance that obtains the layering for fixed nodes during the incremental layout run.
    
    Throws:
    
    IllegalArgumentException - if the ILayerer is null
    
    Default Value:
    The default value is AsIsLayerer
    
    Parameters:
    
    value - the ILayerer instance used for fixed nodes
    
    See Also:
    
    setLayoutMode(LayoutMode), getFixedElementsLayerer()
  - setFixedElementsSequencer
```
public void setFixedElementsSequencer(ISequencer value)
```
    Sets the ISequencer instance that calculates the sequence of the fixed nodes during the incremental layout run.
    
    Throws:
    
    IllegalArgumentException - if the given ISequencer is null
    
    Default Value:
    The default value is AsIsSequencer
    
    Parameters:
    
    value - the ISequencer instance used for fixed elements
    
    See Also:
    
    setLayoutMode(LayoutMode), getFixedElementsSequencer()
  - setFromScratchLayerer
```
public void setFromScratchLayerer(ILayerer value)
```
    Sets the ILayerer instance that obtains the layering for the nodes if the layout algorithm runs in From Scratch mode.
    If the graph consists of multiple components, then the ILayerer instance should be wrapped in MultiComponentLayerer.
    
    Throws:
    
    IllegalArgumentException - if the ILayerer is null
    
    Default Value:
    The default value is WeightedLayerer
    
    Parameters:
    
    value - the ILayerer instance
    
    See Also:
    
    setLayoutMode(LayoutMode), getFromScratchLayerer()
  - setFromScratchLayeringStrategy
```
public void setFromScratchLayeringStrategy(LayeringStrategy value)
```
    Sets a predefined layering strategy for the from scratch layerer.
    The layouter assigns the nodes to separate layers. The nodes within each layer will be placed on the same horizontal layer. The layers will be arranged vertically starting with the small-numbered layers.
    
    An important layering strategy for the hierarchic layout style is called Hierarchical Layering. A hierarchical layering tries to assign nodes to layers in a way such that as much edges of the graph as possible will point to the main layout direction, i.e., the start nodes of the edges will be in a layer with a smaller number than the corresponding end nodes. Also, a hierarchical layering will never put two connected nodes in the same layer.
    
    This method wraps the internal implementations into a MultiComponentLayerer instance so that it is possible to specify the behavior of the algorithm if the component layouter is disabled.
    
    Throws:
    
    IllegalArgumentException - if an unknown strategy is given
    
    Default Value:
    The default value is LayeringStrategy.HIERARCHICAL_OPTIMAL
    
    Parameters:
    
    value - one of the predefined layering strategies
    
    See Also:
    
    getFromScratchLayeringStrategy()
  - setFromScratchSequencer
```
public void setFromScratchSequencer(ISequencer value)
```
    Sets the ISequencer instance that calculates the node sequence if the layout algorithm runs in From Scratch mode.
    
    Throws:
    
    IllegalArgumentException - if the ISequencer is null
    
    Default Value:
    The default value is DefaultLayerSequencer
    
    Parameters:
    
    value - the ISequencer instance
    
    See Also:
    
    getFromScratchLayerer(), setLayoutMode(LayoutMode), getFromScratchSequencer()
  - setGridSpacing
```
public void setGridSpacing(double value)
```
    Sets the equidistant spacing between the horizontal and vertical grid lines.
    When the spacing is negative or zero, no grid is defined, otherwise nodes and edges are placed on multiples of the grid spacing.
    
    The grid feature doesn't work together with exact (layer/sequence) coordinate hints.
    
    Default Value:
    The default value is 0. There is no grid specified.
    
    Parameters:
    
    value - the grid spacing
    
    See Also:
    
    IIncrementalHintsFactory, getGridSpacing()
  - setGroupAlignmentPolicy
```
public void setGroupAlignmentPolicy(GroupAlignmentPolicy value)
```
    Sets the group layer alignment strategy used for recursive group layering.
    
    Throws:
    
    IllegalArgumentException - if an unknown group alignment policy is given
    
    Default Value:
    The default value is GroupAlignmentPolicy.CENTER. Groups and normal nodes are center aligned.
    
    Parameters:
    
    value - one of the default group alignment policies
    
    See Also:
    
    setRecursiveGroupLayeringEnabled(boolean), getGroupAlignmentPolicy()
  - setGroupCompactionEnabled
```
public void setGroupCompactionEnabled(boolean value)
```
    Sets whether or not layer compaction for recursive group layering is active.
    The number of node layers is decreased if possible without reversing edge directions. The resulting layering tries to keep the layer span of a group node minimum while minimizing the overall vertical space.
    
    This feature works best when an instance of TopologicalLayerer is used for layer assignment. If this feature is enabled, an alignment policy that is set with GroupAlignmentPolicy is ignored.
    
    Group compaction only applies when recursive group layering is enabled. During non-recursive layering, groups are ignored completely.
    
    Default Value:
    The default value is false. The layer compaction is disabled.
    
    Parameters:
    
    value - true if group compaction is active, false otherwise
    
    See Also:
    
    setRecursiveGroupLayeringEnabled(boolean), isGroupCompactionEnabled()
  - setIntegratedEdgeLabelingEnabled
```
public void setIntegratedEdgeLabelingEnabled(boolean value)
```
    Sets whether or not the layout algorithm reserves space for labels and places them.
    To define the desired placement for each label add a PreferredPlacementDescriptor on IEdgeLabelLayout.
    
    This method is a convenience method that assures that the labeling algorithm is of type LabelLayoutTranslator and EdgeLabelTranslationEnabled is set to true.
    
    Throws:
    
    IllegalStateException - if integrated labeling should be enabled but the current labeling algorithm is not of type LabelLayoutTranslator
    
    IllegalStateException - if no properly configured LabelLayoutTranslator is registered even though integrated labeling was enabled earlier (can happen when manually specifying the labeling algorithm).
    
    When enabling this property, any previously specified labeling algorithm will be overwritten and when disabling it, any currently specified labeling algorithm will be disabled via property LabelingEnabled. Therefore, it is recommended to only use this convenience property instead of manually changing the mentioned other properties.
    
    Default Value:
    The default value is false. Integrated edge labeling is disabled.
    
    Parameters:
    
    value - true if integrated edge labeling is enabled, false otherwise
    
    See Also:
    
    isIntegratedEdgeLabelingEnabled()
  - setLayerSeparationEnabled
```
public void setLayerSeparationEnabled(boolean value)
```
    Sets whether or not to separate layers.
    In case layers are not separated, nodes of a layer may extend into adjacent layers. Otherwise, nodes of different layers are strictly separated, i.e., layers are placed below each other.
    
    The alignment of nodes within their layer is not affected by this property.
    
    Default Value:
    The default value is true. Layers are separated.
    
    Parameters:
    
    value - true if layers are separated, false otherwise
    
    See Also:
    
    isLayerSeparationEnabled()
  - setLayoutMode
```
public void setLayoutMode(LayoutMode value)
```
    Sets the layout mode this layouter should use for upcoming layouts.
    Depending on the mode the layout algorithm will use different ILayerer and ISequencer implementations.
    
    Throws:
    
    IllegalArgumentException - if the given layout mode is unknown
    
    Default Value:
    The default value is LayoutMode.FROM_SCRATCH
    
    Parameters:
    
    value - the new layout mode
    
    See Also:
    
    getFromScratchLayerer(), getFromScratchSequencer(), getFixedElementsLayerer(), getFixedElementsSequencer(), getLayoutMode()
  - setMaximumDuration
```
public void setMaximumDuration(long value)
```
    Sets the time limit (in milliseconds) set for the layout algorithm.
    Values have to be greater or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the maximum duration is negative
    
    Restricting the maximum duration may result in a lower layout quality. Furthermore, the real runtime may exceed the maximum duration since the layout algorithm still has to find a valid solution.
    
    Default Value:
    The default value is Long.MAX_VALUE. The layout algorithm runs unrestricted.
    
    Parameters:
    
    value - a non-negative value that specifies the time limit
    
    See Also:
    
    getMaximumDuration()
  - setMinimumLayerDistance
```
public void setMinimumLayerDistance(double value)
```
    Sets the minimum distance between two adjacent layers.
    The specified distance should have a non-negative value.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    Default Value:
    The default value is 20.
    
    Parameters:
    
    value - the non-negative minimum distance
    
    See Also:
    
    getMinimumLayerDistance()
  - setNodeLabelConsiderationEnabled
```
public void setNodeLabelConsiderationEnabled(boolean value)
```
    Sets whether or not the layout algorithm considers node labels when calculating node positions to avoid overlaps.
    This method is a convenience method that assures that the labeling algorithm is of type LabelLayoutTranslator and NodeLabelTranslationEnabled is set to true.
    
    Throws:
    
    IllegalStateException - if this property should be enabled but the current labeling algorithm is not of type LabelLayoutTranslator
    
    IllegalStateException - if no properly configured LabelLayoutTranslator is registered even though this property was enabled earlier (can happen when manually specifying the labeling algorithm).
    
    Enabling this option may overwrite the current labeling algorithm. Hence, to combine this option with a generic edge labeling algorithm, the generic labeling has to be applied in an additional step after calculating the layout.
    
    Default Value:
    The default value is false. Node labels are not considered.
    
    Parameters:
    
    value - true if the layout algorithm takes the node labels into account, false otherwise
    
    See Also:
    
    isNodeLabelConsiderationEnabled()
  - setNodeLayoutDescriptor
```
public void setNodeLayoutDescriptor(NodeLayoutDescriptor value)
```
    Sets the NodeLayoutDescriptor instance used for all those nodes that do not have a specific layout descriptor assigned.
    By default, this method will return a NodeLayoutDescriptor instance created with createNodeLayoutDescriptor().
    
    Throws:
    
    IllegalArgumentException - if the given NodeLayoutDescriptor is null
    
    Default Value:
    The default value is NodeLayoutDescriptor
    
    Parameters:
    
    value - the current NodeLayoutDescriptor instance
    
    See Also:
    
    HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY, createNodeLayoutDescriptor(), getNodeLayoutDescriptor()
  - setNodePlacer
```
public void setNodePlacer(INodePlacer value)
```
    Sets the INodePlacer instance that will calculate the final node placement of the layout.
    
    Throws:
    
    IllegalArgumentException - if the INodePlacer is null
    
    Default Value:
    The default value is SimplexNodePlacer
    
    Parameters:
    
    value - the INodePlacer instance
    
    See Also:
    
    getNodePlacer()
  - setNodeToEdgeDistance
```
public void setNodeToEdgeDistance(double value)
```
    Sets the minimum distance between an edge and an adjacent node in one layer.
    All values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    IllegalStateException - if the current IDrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    If nodes/edges should use different distances, you can map them to different NodeLayoutDescriptor /EdgeLayoutDescriptor instances (see HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY and HierarchicLayoutCore.EDGE_LAYOUT_DESCRIPTOR_DPKEY) with custom minimum distance values.
    
    Default Value:
    The default value is 15.
    
    Parameters:
    
    value - the non-negative minimum distance
    
    See Also:
    
    getNodeToEdgeDistance()
  - setNodeToNodeDistance
```
public void setNodeToNodeDistance(double value)
```
    Sets the minimum distance between two adjacent nodes in one layer.
    All values have to be greater than or equal to 0.
    
    Throws:
    
    IllegalArgumentException - if the distance is negative
    
    IllegalStateException - if the current IDrawingDistanceCalculator is not an instance of DefaultDrawingDistanceCalculator
    
    If nodes should use different distances, you can map them to different NodeLayoutDescriptor instances (see HierarchicLayoutCore.NODE_LAYOUT_DESCRIPTOR_DPKEY) with custom minimum distance values.
    
    Default Value:
    The default value is 30.
    
    Parameters:
    
    value - the non-negative minimum distance
    
    See Also:
    
    getNodeToNodeDistance()
  - setOrthogonalRoutingEnabled
```
public void setOrthogonalRoutingEnabled(boolean value)
```
    Sets whether or not edges should be routed orthogonally.
    When orthogonal routing is enabled, all resulting edge paths will be composed of vertical and horizontal segments, only.
    
    This is a convenience method that sets the routing style for the default edge layout descriptor to orthogonal.
    
    Default Value:
    The default value is false. Edges are not orthogonally routed.
    
    Parameters:
    
    value - true if edges are routed orthogonally, false otherwise
    
    See Also:
    
    isOrthogonalRoutingEnabled()
  - setRecursiveGroupLayeringEnabled
```
public void setRecursiveGroupLayeringEnabled(boolean value)
```
    Sets whether or not groups are respected during the layering stage.
    If this option is enabled, groups are layered recursively, i.e.
    - nodes in the same group always occupy adjacent layers
    - layer intervals spanned by different group nodes are either disjoint or are nested
    If it is disabled, group information is ignored for the layering step.
    
    If the graph is flat, this setting is ignored.
    In case group compaction is enabled, groups are layered non-recursively.
    
    Default Value:
    The default value is true. Groups are layered recursively.
    
    Parameters:
    
    value - true if group information is used, false otherwise
    
    See Also:
    
    setGroupCompactionEnabled(boolean), isRecursiveGroupLayeringEnabled()
  - setStopAfterLayeringEnabled
```
public void setStopAfterLayeringEnabled(boolean value)
```
    Sets whether or not to stop the layout algorithm after the layering step.
    By then, each node will be assigned to a layer. Since the sequencing and drawing phases are skipped, the order of the nodes within a layer matches the initial order of the nodes, edges won't be routed and the nodes won't get coordinates assigned.
    
    The calculated layering information can be retrieved from the IDataProvider registered with the key LAYER_INDEX_DPKEY.
    
    The layout algorithm may be stopped here if only the layer assignment is important and the sequencing or the actual drawing is not needed. For example, an initial layout run may be needed to determine the layering for a second layout run that will work with this information. Then stopping after layering will save runtime.
    
    The bounds of group nodes depend on the locations of their content and the routes of connecting edges. Therefore, they are not yet calculated after the layering phase and will have width and height 1.
    
    Default Value:
    The default value is false. The algorithm calculates the complete layout.
    
    Parameters:
    
    value - true if the layout algorithm should stop after the layering phase, false if the complete layout should be calculated
    
    See Also:
    
    LAYER_INDEX_DPKEY, isStopAfterLayeringEnabled()
  - setStopAfterSequencingEnabled
```
public void setStopAfterSequencingEnabled(boolean value)
```
    Sets whether or not to stop the layout algorithm after the sequencing step.
    By then, each node will be assigned to a layer and will have a place in the sequence of nodes in this layer. Since the drawing phase is skipped, edges won't be routed and the nodes won't get coordinates assigned.
    
    The calculated layering and sequencing information can be retrieved from the IDataProviders registered with the keys LAYER_INDEX_DPKEY and SEQUENCE_INDEX_DPKEY.
    
    The layout algorithm may be stopped here if only the location within the layers is important and the actual drawing is not needed. For example, an initial layout run may be needed to determine the layering and the sequencing for a second layout run that will work with this information. Then stopping after sequencing will save runtime.
    
    The bounds of group nodes depend on the locations of their content and the routes of connecting edges. Therefore, they are not yet calculated after the sequencing phase and will have width and height 1.
    
    Default Value:
    The default value is false. The algorithm calculates the complete layout.
    
    Parameters:
    
    value - true if the layout algorithm should stop after the sequencing phase, false if the complete layout should be calculated
    
    See Also:
    
    SEQUENCE_INDEX_DPKEY, LAYER_INDEX_DPKEY, isStopAfterSequencingEnabled()

Class HierarchicLayout

Layout Style

Concept

Features

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.yworks.yfiles.layout.MultiStageLayout

Methods inherited from class java.lang.Object

Field Detail

ALTERNATIVE_EDGE_PATH_DPKEY

ALTERNATIVE_GROUP_BOUNDS_DPKEY

CRITICAL_EDGE_PRIORITY_DPKEY

EDGE_DIRECTEDNESS_DPKEY

EDGE_THICKNESS_DPKEY

FOLDER_NODES_DPKEY

INCREMENTAL_HINTS_DPKEY

LAYER_CONSTRAINTS_MEMENTO_DPKEY

LAYER_INDEX_DPKEY

SEQUENCE_CONSTRAINTS_MEMENTO_DPKEY

SEQUENCE_INDEX_DPKEY

SWIMLANE_DESCRIPTOR_DPKEY

Constructor Detail

HierarchicLayout

Method Detail

applyLayoutCore

configureCoreLayout

createEdgeLayoutDescriptor

createHierarchicLayoutCore

createIncrementalHintsFactory

createLayerConstraintFactory

createNodeLayoutDescriptor

createSequenceConstraintFactory

disposeCoreLayout

getComponentArrangementPolicy

getDefaultDrawingDistanceCalculator

getEdgeLayoutDescriptor

getEdgeToEdgeDistance

getFixedElementsLayerer

getFixedElementsSequencer

getFromScratchLayerer

getFromScratchLayeringStrategy

getFromScratchSequencer

getGridSpacing

getGroupAlignmentPolicy

getHierarchicLayoutCore

getLayoutMode

getMaximumDuration

getMinimumLayerDistance

getMirrorMode

getNodeLayoutDescriptor

getNodePlacer

getNodeToEdgeDistance

getNodeToNodeDistance

isAutomaticEdgeGroupingEnabled

isBackLoopRoutingEnabled

isBackLoopRoutingForSelfLoopsEnabled

isGroupCompactionEnabled

isIntegratedEdgeLabelingEnabled

isLayerSeparationEnabled

isNodeLabelConsiderationEnabled

isOrthogonalRoutingEnabled

isRecursiveGroupLayeringEnabled

isStopAfterLayeringEnabled

isStopAfterSequencingEnabled

setAutomaticEdgeGroupingEnabled

setBackLoopRoutingEnabled

setBackLoopRoutingForSelfLoopsEnabled

setComponentArrangementPolicy

setEdgeLayoutDescriptor

setEdgeToEdgeDistance

setFixedElementsLayerer

setFixedElementsSequencer

setFromScratchLayerer

setFromScratchLayeringStrategy

setFromScratchSequencer

setGridSpacing

setGroupAlignmentPolicy

setGroupCompactionEnabled

setIntegratedEdgeLabelingEnabled