Provides tree layout style algorithms.

Classes

  ClassDescription
Public classAbstractNodePlacer
Utility class that serves as a basis for implementations of the INodePlacer interface.
Public classAbstractRotatableNodePlacer
This is an abstract base class for NodePlacers that supports rotations.
"Supporting rotation" means that the NodePlacers only implement the default direction (e.g.
Public classAbstractRotatableNodePlacer..::..Matrix
Instances of this class may be used to configure the AbstractRotatableNodePlacer .
Public classAbstractRotatableNodePlacer..::..RootAlignment
This class represents the horizontal alignment of the root node.
Public classARNodePlacer
This class is used by GenericTreeLayouter and implements a sophisticated INodePlacer .
Public classARTreeLayouter
This tree layouter tries to generate compact tree layouts with a certain aspect ratio.
Public classAssistantPlacer
The assistant placer is a NodePlacer that delegates the node placement to two different node placers depending on the type of the children.
The type of a child is recognized using a DataProvider providing boolean values.
Public classBalloonLayouter
A tree layouter that lays out the subtrees of the tree in a balloon-like fashion.
Public classBalloonLayouter..::..NodeInfo
Encapsulates information bound to a node during the algorithm calculates a layout.
Public classBusPlacer
The BusPlacer is a special NodePlacer that creates a bus where all child nodes and the root node are connected to.
The BusPlacer is rotatable using the constructor BusPlacer(AbstractRotatableNodePlacer..::..Matrix) .
Public classDefaultNodePlacer
Versatile default implementation of INodePlacer used by GenericTreeLayouter .
Public classDefaultPortAssignment
This class provides simple default port assignment strategies.
Public classDelegatingNodePlacer
The DelegatingNodePlacer may be used to layout the children of the actual node with two different NodePlacers.
Public classDendrogramPlacer
This is an implementation of the INodePlacer interface that can be used to create dendrogram-like tree layouts.
Public classDoubleLinePlacer
The DoubleLinePlacer is a special node placer that places its children in two lines.
This node placer is especially useful for leaves with great width.
Public classFreePlacer
Placer that can be used as simple "pseudo"-placer.
Public classGenericTreeLayouter
This class implements the basis of a generic tree layout algorithm.
Public classGenericTreeLayouter..::..SubtreeShape
Instances of this class are used to represent the shape of subtrees during the layout.
Public classGridNodePlacer
This NodePlacer arranges nodes into a grid.
Public classHVTreeLayouter
This tree layouter allows to layout a tree such that each subgraph rooted at a node can either have a horizontal or vertical layout.
Public classLayeredNodePlacer
This NodePlacer calculates and respects layers.
Public classLeafPlacer
This implementation can be used to "place" leafs.
Public classLeftRightPlacer
The LeftRightPlacer is a NodePlacer that arranges the Nodes on the left and right side of a vertical bus.
Public classLeftRightPlacer..::..LeftRightDataProvider
Utility class providing a method to determine if a given node is aligned left (true) or right (false) to the parent node.
Public classNodeOrderComparator
This comparator compares edges by examining the IComparable that is obtained by passing the target nodes to the get method of the IDataProvider bound to the graph via the NodeOrderDpKey key.
Public classSimpleNodePlacer
This is a "default" NodePlacer.
Public classSubtreeShapeRotated
Decorates a SubtreeShape and provides rotated access on it.
Public classTreeComponentLayouter
This stage can be used to do mix layouts for tree-like subgraph structures and the non-tree like rest of a graph.
Public classTreeLayouter
Implementation of a layout algorithm for trees.
Public classTreeReductionStage
This stage can be used to layout non-tree structures with a tree layout algorithm.
Public classXCoordComparator
This comparator compares edges by examining the x-coordinates of the centers of their target nodes.

Interfaces

  InterfaceDescription
Public interfaceIFromSketchNodePlacer
A FromSketchNodePlacer is responsible for arranging its nodes using a comparator, which sorts the outgoing edges of a node according to the position of their target nodes in the graph before the actual placement happens.
Public interfaceINodePlacer
This interface is used by GenericTreeLayouter .
Public interfaceIPortAssignment
This interface is used by GenericTreeLayouter .
Public interfaceIProcessor
A processor is the possibility for each NodePlacer to prepare (and clean up) the graph for its children.
It is created within CreateProcessor(GenericTreeLayouter, LayoutGraph, Node) and called by the GenericTreeLayouter at specific positions of the life-cycle.
The processor may change the values within the DataMaps for its children.

Enumerations

  EnumerationDescription
Public enumerationBorderlineSide
Side constant used by GetBorderLine(Int32) .
Public enumerationChildAlignmentPolicy
Child alignment policy specifier constant.
Public enumerationChildOrderingPolicy
Child ordering policy specifier constant.
Public enumerationChildPlacement
Placement byte constant used for the childPlacement property.
Public enumerationChildPlacementPolicy
Symbolic child placement policy specifier.
Public enumerationConnectorDirection
Direction constant used by ConnectorDirection .
Public enumerationEdgeLayoutStyle
Layout style constant.
Public enumerationFillStyle
Byte constant that can be used for the fillStyle property.
Public enumerationInterleavedMode
Interleaved mode specifier constant.
Public enumerationLayeredRoutingStyle
Layout style constant.
Public enumerationNodeLabelingPolicy
Node labeling policy specifier constant.
Public enumerationOrientation
Orientation specifier.
Public enumerationParentConnectorDirection
Public enumerationPortAssignmentMode
Public enumerationPortStyle
Port style constant.
Public enumerationRootAlignment
Alignment byte constant used for the rootAlignment property.
Public enumerationRootNodePolicy
Root node policy specifier constant.
Public enumerationRoutingStyle
Routing style byte constant used for the routingStyle property.

Remarks

Provides tree layout style algorithms.

Implementations support radial layout of (sub)trees, compact layout obeying a given aspect ratio, and also horizontal/vertical layout of directed (and undirected) trees.

Class GenericTreeLayouter enables the use of INodePlacer implementations which are invoked to calculate the subtrees. Predefined node placers that inherit from abstract class AbstractRotatableNodePlacer allow for rotation of subtrees.
Note that GenericTreeLayouter can be used to emulate the results generated by both TreeLayouter and HVTreeLayouter .

Related Documentation

See the yFiles Developer's Guide section on Tree Layout for descriptions of the yFiles tree layout style algorithms.
The section Generic Tree Layout extensively discusses the advanced capabilities of class GenericTreeLayouter and also its numerous NodePlacer implementations.