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 decendants 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.
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	Accessor 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.
Sequencer	This interface is used by HierarchicLayouter to calculate the node orders of nodes within the layers in a Layers object.

Class Summary

AsIsSequencer	Sequencer implementation that returns a sequencing that corresponds to the current drawing.
DefaultDrawingDistanceCalculator	A default DrawingDistanceCalculator implementation that is used by HierarchicLayouter to configure the NodePlacer.
DefaultLayeredComponentsMerger	A default implemenation 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.
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.
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.
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 hast 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.