y.layout.hierarchic.incremental (yFiles-2.18 API)

Overview

Package

Class

Tree

Deprecated

Index

Help

Search this API

PREV PACKAGE NEXT PACKAGE

FRAMES NO FRAMES

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 `PortCandidate`s.
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.