Search this API

Package y.layout.hierarchic.incremental

Provides hierarchic layout style algorithms.

See:
          Description

Interface Summary
DrawingDistanceCalculator This interface determines the minimum distances between elements that belong to the same layer.
EdgeData This interface provides layout information about the edges of the graph during the layout.
EdgeReverser This interface handles edges that should be reversed during the hierarchic layout process.
GroupingSupport.Visitor Visitor interface that can be used to traverse the descendants of a group node
IncrementalHintsFactory This interface provides factory methods for creating incremental hints for the hierarchic layout.
IntValueHolder This interface provides methods for storing and retrieving layering information for the hierarchic layout.
ItemFactory This interface is a factory for creating and destroying helper structures used in the graph during layout.
Layer This interface describes a single layer in a hierarchic layout.
LayerConstraint This interface describes a layering constraint.
LayerConstraintFactory This interface provides methods for creating layering constraints.
LayeredComponentsMerger This interface merges two Layers instances whose nodes reside in the same graph.
Layerer This interface is used by classes capable of generating a layer assignment.
Layers This interface manages multiple Layer instances.
LayoutDataProvider This interface retrieves NodeData and EdgeData instances for elements in the current layout graph.
NodeData This interface provides layout information about the nodes of the graph during the layout.
NodePlacer This interface is responsible for the assignment of the x-(sequence) and preliminary y-coordinates of the nodes in a hierarchic layout.
PortAllocator This interface is responsible for assigning port coordinates to the adjacent edges of each node of the graph.
PortConstraintOptimizer This interface serves as a callback for HierarchicLayouter after the layering and sequencing phases.
SequenceConstraintFactory This interface specifies the general contract for factory classes that can be used to associate sequence constraints with a graph.
Sequencer This interface is used by HierarchicLayouter to calculate the order of the nodes within each layer.
 

Class Summary
AbstractPortConstraintOptimizer This class is an abstract implementation of the PortConstraintOptimizer interface that minimizes the effort required to modify the port assignment after the sequencing phase of hierarchic layout algorithm.
AbstractPortConstraintOptimizer.SameLayerData This static class provides information about the same-layer structures created by class AbstractPortConstraintOptimizer.
AsIsSequencer This class calculates the sequence of the nodes within each layer using the nodes' coordinates.
AspectRatioComponentLayerer This class is a wrapper Layerer implementation that delegates the actual layering to a delegate Layerer object.
BusDescriptor A BusDescriptor defines settings for edges routed on a common bus and forming a bus substructure for IncrementalHierarchicLayouter.
ConstraintIncrementalLayerer This class is a Layerer implementation that observes relative and absolute layering constraints defined by the layer constraint factory.
DefaultDrawingDistanceCalculator This class is a default DrawingDistanceCalculator implementation that is used by HierarchicLayouter to configure the NodePlacer.
DefaultLayeredComponentsMerger A default implementation of a LayeredComponentsMerger that provides simple default behaviors.
DefaultLayerSequencer This class is a Sequencer implementation that performs the second phase of the Sugiyama algorithm.
DefaultPortAllocator This class is a default PortAllocator implementation.
EdgeLayoutDescriptor This class is used by HierarchicLayouter during the various phases to provide routing details for the edges of the graph.
GivenSequenceSequencer This class is a Sequencer implementation that determines the sequence of nodes of the same layer based on a given comparator constraint.
GroupingSupport This class is responsible for managing hierarchically grouped graphs.
HierarchicLayouter This class arranges graphs in a hierarchic/layered fashion and supports complete re-layout as well as incremental graph layout.
HierarchicLayouter.IncrementalHint This class describes hint objects used internally by HierarchicLayouter.
IntValueHolderAdapter This class is an adapter that uses a DataMap, NodeMap or EdgeMap implementation and wraps it as a DataProvider that provides IntValueHolder instances for each element.
MultiComponentLayerer This class is a wrapper Layerer implementation that delegates the actual layering to a delegate Layerer.
NodeLayoutDescriptor This class is used by HierarchicLayouter during the various phases to provide the drawing details of the nodes of the graph.
OldLayererWrapper This class wraps a Layerer implementation from y.layout.hierarchic package to behave like a Layerer implementation from y.layout.hierarchic.incremental package.
PartitionGridLayoutStage This class implements a layout stage that handles a given partition grid structure.
PCListOptimizer This class is an implementation of the PortConstraintOptimizer interface that tries to assign the edges of the graph to ports considering the specified PortCandidates.
RoutingStyle This class is used by EdgeLayoutDescriptor to specify the routing style for different types of edges.
SelfloopCalculator This class calculates bend points for self-loops routed in orthogonal or octilinear fashion.
SimplexNodePlacer This class is a NodePlacer implementation based on rank assignment.
SwimLaneDescriptor This class is used by HierarchicLayouter during the various phases and models a swimlane structure.
TopLevelGroupToSwimlaneStage This layout stage can be used for automatically assigning SwimLaneDescriptor instances to nodes by treating top-level group nodes as swimlanes.
TopologicalIncrementalLayerer This class is a Layerer implementation that inserts nodes incrementally into an existing layer structure, without destroying the existing layout.
TypeBasedDrawingDistanceCalculator This class is a DrawingDistanceCalculator implementation that returns the minimum distances for each kind of node pair based on their type as returned by NodeData.getType().
 

Package y.layout.hierarchic.incremental Description

Provides hierarchic layout style algorithms.

In the hierarchic layout style, nodes are distributed into layers such that most of the edges point to the main layout direction, i.e., the layer of the edge's source is smaller than that of the target. The order of the nodes within the layers ensures that the number of edge crossings is as small as possible. Also, different edge routing styles i.e., polyline, octilinear, orthogonal are supported.

The main class is HierarchicLayouter. However, users should use class IncrementalHierarchicLayouter that offers a facade to this layouter.

The main steps of the IncrementalHierarchicLayouter are performed by implementations of the following interfaces:

Furthermore, IncrementalHintsFactory provides the interface to determine which elements will be inserted incrementally into a given drawing of the input graph.

Example graphs


Default hierarchic layout

Hierarchic layout with swimlanes and polyline routing

Hierarchic layout with groups and octilinear routing

Related Documentation

See the yFiles Developer's Guide section on Hierarchical Layout Style for descriptions of the yFiles hierarchical layout style algorithms.

 

© Copyright 2000-2021,
yWorks GmbH.
All rights reserved.