yWorks.yFiles.Layout.Hierarchic.Incremental Namespace

	Class	Description
	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 ILayerConstraintFactory .
	DefaultDrawingDistanceCalculator	A default IDrawingDistanceCalculator implementation that is used by HierarchicLayouter to configure the INodePlacer .
	DefaultLayeredComponentsMerger	A default implementation of a ILayeredComponentsMerger 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 IDataMap , INodeMap , or IEdgeMap implementation and wraps it as a IDataProvider that provides IIntValueHolder instances for each element.
	LayerConstraintFactoryCompanion
	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 ILayerer implementation from the y.layout.hierarchic package to behave like a ILayerer 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 PartitionGridDpKey .
	PCListOptimizer	This class is an implementation of the IPortConstraintOptimizer interface which can be registered with the HierarchicLayouter instance using it's PortConstraintOptimizer method.
	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 SwimlaneDescriptorDpKey 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 Type

	Interface	Description
	GroupingSupport..::..IVisitor	Visitor interface that can be used to traverse the descendants of a group node
	IDrawingDistanceCalculator	Interface for a helper class used by HierarchicLayouter during the node placement phase.
	IEdgeData	Multi-purpose edge descriptor for each edge in the graph during the layout.
	IEdgeReverser	Interface for implementations that perform their work after the first phase.
	IIncrementalHintsFactory	Factory interface for IncrementalHierarchicLayouter .
	IIntValueHolder	Used by HierarchicLayouter to write back layering information.
	IItemFactory	Factory that consistently creates and destroys helper structures in the graph during layout.
	ILayer	Describes a single layer in a hierarchical drawing with all its nodes and associated same layer edges.
	ILayerConstraint	This class represents a layering constraint.
	ILayerConstraintFactory	Interface specification for classes that can create layering constraints.
	ILayeredComponentsMerger	Merges two ILayers instances, whose nodes reside in the same graph.
	ILayerer	This interface is used by classes that are capable of generating a layer assignment.
	ILayers	Container class that manages multiple ILayer instances.
	ILayoutDataProvider	Interface for retrieving INodeData and IEdgeData instances for elements in the current layout graph.
	INodeData	Multi-purpose node descriptor for each node in the graph during the hierarchic layout used internally by the algorithm implementations.
	INodePlacer	Responsible for the x (sequence) and preliminary y coordinate assignments of a drawing.
	IPortAllocator	Interface used by HierarchicLayouter during the layout.
	IPortConstraintOptimizer	This interface serves as a callback for HierarchicLayouter after the layering and sequencing phases.
	ISequenceConstraintFactory	Specifies the general contract for factory classes that can be used to associate sequence constraints to a graph.
	ISequencer	This interface is used by HierarchicLayouter to calculate the node orders of nodes within the layers in a ILayers object.

	Enumeration	Description
	EdgeDataType
	GroupCompactionPolicy	Compaction strategy specifier for use with GroupCompactionStrategy .
	IncrementalHintType
	LayerType
	MergingPolicy	Constant for merging policy.
	NodeDataType	Node type constant as returned by Type .
	NodeLabelMode	Byte constant used by NodeLabelMode and NodeLabelMode .

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:

AsIsLayerer (which has to be wrapped by OldLayererWrapper )
AsIsSequencer

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.

Classes

Interfaces

Enumerations

Remarks