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

Classes

  ClassDescription
Public classAbstractPortConstraintOptimizer
A partial implementation of the IPortConstraintOptimizer interface to minimize the effort required to modify the port assignment after the sequencing phase.
Public classAbstractPortConstraintOptimizer..::..SameLayerData
Provides information about the same layer structures created by class AbstractPortConstraintOptimizer .
Public classAsIsSequencer
Sequencer implementation that returns a sequencing that corresponds to the current drawing.
Public classAspectRatioComponentLayerer
Wrapper Layerer implementation that delegates the actual layering to a delegate Layerer.
Public classConstraintIncrementalLayerer
Layerer implementation that observes relative and absolute layering constraints defined by the layering constraint factory ILayerConstraintFactory .
Public classDefaultDrawingDistanceCalculator
A default IDrawingDistanceCalculator implementation that is used by HierarchicLayouter to configure the INodePlacer .
Public classDefaultLayeredComponentsMerger
A default implementation of a ILayeredComponentsMerger that provides simple default behaviors.
Public classDefaultLayerSequencer
This class implements the second phase of the Sugiyama algorithm.
Public classDefaultPortAllocator
Default implementation of the PortAllocator interface.
Public classEdgeLayoutDescriptor
This class is used by HierarchicLayouter during the various phases to determine the routing details of the graph's edges.
Public classGivenSequenceSequencer
This LayerSequencer implementation returns a sequencing that satisfies a comparator constraint.
Public classGroupingSupport
Helper class that is used to manage hierarchically grouped graphs.
Public classHierarchicLayouter
This class can be used to create hierarchical layouts of graphs.
Public classHierarchicLayouter..::..IncrementalHint
Hint objects used internally by this layout algorithm implementation.
Public classIntValueHolderAdapter
Adapter class that uses a IDataMap , INodeMap , or IEdgeMap implementation and wraps it as a IDataProvider that provides IIntValueHolder instances for each element.
Public classLayerConstraintFactoryCompanion
Public classMultiComponentLayerer
Wrapper Layerer implementation that delegates the actual layering to a delegate Layerer.
Public classNodeLayoutDescriptor
This class is used by HierarchicLayouter during the various phases to determine the drawing details of the graph's nodes.
Public classOldLayererWrapper
Wraps a ILayerer implementation from the y.layout.hierarchic package to behave like a ILayerer implementation from the y.layout.hierarchic.incremental package.
Public classPartitionGridLayoutStage
Layout stage that is used for handling a given partition grid structure ( PartitionGrid ) that is attached to a graph with DataProvider PartitionGridDpKey .
Public classPCListOptimizer
This class is an implementation of the IPortConstraintOptimizer interface which can be registered with the HierarchicLayouter instance using it's PortConstraintOptimizer method.
Public classRoutingStyle
This class is used by EdgeLayoutDescriptor to specify the routing style for different edge types.
Public classSelfloopCalculator
This class can be used to calculate bend points for orthogonally routed self loops.
Public classSimplexNodePlacer
NodePlacer implementation based on rank-assignment .
Public classSwimLaneDescriptor
This class is used by HierarchicLayouter during the various phases to associate swim lanes with each node.
Public classTopLevelGroupToSwimlaneStage
This layout stage can be used to automatically assign SwimLaneDescriptor instances to nodes using the SwimlaneDescriptorDpKey by treating top-level group nodes as swimlanes.
Public classTopologicalIncrementalLayerer
Inserts nodes incrementally into an existing layer structure, without destroying the latter.
Public classTypeBasedDrawingDistanceCalculator
This implementation returns the minimum distances for each kind of node pair based on their type as returned by Type

Interfaces

  InterfaceDescription
Public interfaceGroupingSupport..::..IVisitor
Visitor interface that can be used to traverse the descendants of a group node
Public interfaceIDrawingDistanceCalculator
Interface for a helper class used by HierarchicLayouter during the node placement phase.
Public interfaceIEdgeData
Multi-purpose edge descriptor for each edge in the graph during the layout.
Public interfaceIEdgeReverser
Interface for implementations that perform their work after the first phase.
Public interfaceIIncrementalHintsFactory
Factory interface for IncrementalHierarchicLayouter .
Public interfaceIIntValueHolder
Used by HierarchicLayouter to write back layering information.
Public interfaceIItemFactory
Factory that consistently creates and destroys helper structures in the graph during layout.
Public interfaceILayer
Describes a single layer in a hierarchical drawing with all its nodes and associated same layer edges.
Public interfaceILayerConstraint
This class represents a layering constraint.
Public interfaceILayerConstraintFactory
Interface specification for classes that can create layering constraints.
Public interfaceILayeredComponentsMerger
Merges two ILayers instances, whose nodes reside in the same graph.
Public interfaceILayerer
This interface is used by classes that are capable of generating a layer assignment.
Public interfaceILayers
Container class that manages multiple ILayer instances.
Public interfaceILayoutDataProvider
Interface for retrieving INodeData and IEdgeData instances for elements in the current layout graph.
Public interfaceINodeData
Multi-purpose node descriptor for each node in the graph during the hierarchic layout used internally by the algorithm implementations.
Public interfaceINodePlacer
Responsible for the x (sequence) and preliminary y coordinate assignments of a drawing.
Public interfaceIPortAllocator
Interface used by HierarchicLayouter during the layout.
Public interfaceIPortConstraintOptimizer
This interface serves as a callback for HierarchicLayouter after the layering and sequencing phases.
Public interfaceISequenceConstraintFactory
Specifies the general contract for factory classes that can be used to associate sequence constraints to a graph.
Public interfaceISequencer
This interface is used by HierarchicLayouter to calculate the node orders of nodes within the layers in a ILayers object.

Enumerations

  EnumerationDescription
Public enumerationEdgeDataType
Public enumerationEdgeRoutingStyle
Routing style constant.
Public enumerationGroupCompactionPolicy
Compaction strategy specifier for use with GroupCompactionStrategy .
Public enumerationIncrementalHintType
Public enumerationLayerType
Public enumerationMergingPolicy
Constant for merging policy.
Public enumerationNodeDataType
Node type constant as returned by Type .
Public enumerationNodeLabelMode
Byte constant used by NodeLabelMode and NodeLabelMode .

Remarks

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:
Their default implementations are:
And the corresponding implementations that use the current sketch are:
IIncrementalHintsFactory provides the interface to determine which elements will be inserted incrementally into a given sketch. An implementation of this interface can be obtained through 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.