Package y.layout.hierarchic.incremental

This package encapsulates all classes that make up the new Hierarchic Layouter facilities.

See:
Description

Interface Summary

DrawingDistanceCalculator	Interface for a helper class used by HierarchicLayouter during the node placement phase.
EdgeData	Multi-purpose edge descriptor for each edge in the graph during the layout.
EdgeReverser	Interface for implementations that perform their work after the first phase.
GroupingSupport.Visitor	Visitor interface that can be used to traverse the descendants of a group node
IncrementalHintsFactory	Factory interface for IncrementalHierarchicLayouter.
IntValueHolder	Used by HierarchicLayouter to write back layering information.
ItemFactory	Factory that consistently creates and destroys helper structures in the graph during layout.
Layer	Describes a single layer in a hierarchical drawing with all its nodes and associated same layer edges.
LayerConstraint	This class represents a layering constraint.
LayerConstraintFactory	Interface specification for classes that can create layering constraints.
LayeredComponentsMerger	Merges two Layers instances, whose nodes reside in the same graph.
Layerer	This interface is used by classes that are capable of generating a layer assignment.
Layers	Container class that manages multiple Layer instances.
LayoutDataProvider	Interface for retrieving NodeData and EdgeData instances for elements in the current layout graph.
NodeData	Multi-purpose node descriptor for each node in the graph during the hierarchic layout used internally by the algorithm implementations.
NodePlacer	Responsible for the x (sequence) and preliminary y coordinate assignments of a drawing.
PortAllocator	Interface used by HierarchicLayouter during the layout.
PortConstraintOptimizer	This interface serves as a callback for HierarchicLayouter after the layering and sequencing phases.
SequenceConstraintFactory	Specifies the general contract for factory classes that can be used to associate sequence constraints to a graph.
Sequencer	This interface is used by HierarchicLayouter to calculate the node orders of nodes within the layers in a Layers object.

Class Summary

AbstractPortConstraintOptimizer	A partial implementation of the PortConstraintOptimizer interface to minimize the effort required to modify the port assignment after the sequencing phase.
AbstractPortConstraintOptimizer.SameLayerData	Provides information about the same layer structures created by class AbstractPortConstraintOptimizer.
AsIsSequencer	Sequencer implementation that returns a sequencing that corresponds to the current drawing.
AspectRatioComponentLayerer	Wrapper Layerer implementation that delegates the actual layering to a delegate Layerer.
ColumnDescriptor	This class represents a column of a PartitionGrid.
ConstraintIncrementalLayerer	Layerer implementation that observes relative and absolute layering constraints defined by the layering constraint factory LayerConstraintFactory.
DefaultDrawingDistanceCalculator	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 implements the second phase of the Sugiyama algorithm.
DefaultPortAllocator	Default implementation of the PortAllocator interface.
EdgeLayoutDescriptor	This class is used by HierarchicLayouter during the various phases to determine the routing details of the graph's edges.
GivenSequenceSequencer	This LayerSequencer implementation returns a sequencing that satisfies a comparator constraint.
GroupingSupport	Helper class that is used to manage hierarchically grouped graphs.
HierarchicLayouter	This class can be used to create hierarchical layouts of graphs.
HierarchicLayouter.IncrementalHint	Hint objects used internally by this layout algorithm implementation.
IntValueHolderAdapter	Adapter class that uses a DataMap, NodeMap, or EdgeMap implementation and wraps it as a DataProvider that provides IntValueHolder instances for each element.
MultiComponentLayerer	Wrapper Layerer implementation that delegates the actual layering to a delegate Layerer.
NodeLayoutDescriptor	This class is used by HierarchicLayouter during the various phases to determine the drawing details of the graph's nodes.
OldLayererWrapper	Wraps a Layerer implementation from the y.layout.hierarchic package to behave like a Layerer implementation from the y.layout.hierarchic.incremental package.
PartitionCellId	Represents an identifier for partition cells of the partition grid.
PartitionCellId.Pair	Represents a single partition cell, i.e., a row-column pair.
PartitionGrid	Class for creating a partition grid, i.e., a grid that partitions the drawing area into rectangular partition cells.
PartitionGridLayoutStage	Layout stage that is used for handling a given partition grid structure (PartitionGrid) that is attached to a graph with DataProvider PartitionGrid.PARTITION_GRID_DPKEY.
PCListOptimizer	This class is an implementation of the PortConstraintOptimizer interface which can be registered with the HierarchicLayouter instance using it's HierarchicLayouter.setPortConstraintOptimizer(PortConstraintOptimizer) method.
RoutingStyle	This class is used by EdgeLayoutDescriptor to specify the routing style for different edge types.
RowDescriptor	This class represents a row of a PartitionGrid.
SelfloopCalculator	This class can be used to calculate bend points for orthogonally routed self loops.
SimplexNodePlacer	NodePlacer implementation based on rank-assignment.
SwimLaneDescriptor	This class is used by HierarchicLayouter during the various phases to associate swim lanes with each node.
TopLevelGroupToSwimlaneStage	This layout stage can be used to automatically assign SwimLaneDescriptor instances to nodes using the IncrementalHierarchicLayouter.SWIMLANE_DESCRIPTOR_DPKEY by treating top-level group nodes as swimlanes.
TopologicalIncrementalLayerer	Inserts nodes incrementally into an existing layer structure, without destroying the latter.
TypeBasedDrawingDistanceCalculator	This implementation 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

This package encapsulates all classes that make up the new Hierarchic Layouter facilities. The main class is HierarchicLayouter. A facade of the main class can be found in the "traditional" hierarchic layouter package: IncrementalHierarchicLayouter. The facade should be used by developers unless they want dig deep into the mechanisms and tweak their behavior.
Important interfaces of this package are:

• Layerer
• Sequencer
• PortAllocator
• DrawingDistanceCalculator
• NodePlacer

Their default implementations are:

• MultiComponentLayerer and OldLayererWrapper
• DefaultLayerSequencer
• DefaultPortAllocator
• DefaultDrawingDistanceCalculator
• SimplexNodePlacer

And the corresponding implementations that use the current sketch are:

• AsIsLayerer (which has to be wrapped by OldLayererWrapper)
• AsIsSequencer

IncrementalHintsFactory provides the interface to determine which elements will be inserted incrementally into a given sketch. An implementation of this interface can be obtained through HierarchicLayouter.createIncrementalHintsFactory().
All other classes in this package are used by the implementations internally and normally need not be used by developers unless they want to customize and tweak the default behaviors.