com.yworks.yfiles.layout.tree

Class AbstractRotatableNodePlacer

java.lang.Object

com.yworks.yfiles.layout.tree.AbstractRotatableNodePlacer

All Implemented Interfaces:

IFromSketchNodePlacer, INodePlacer

Direct Known Subclasses:

AssistantNodePlacer, BusNodePlacer, DelegatingNodePlacer, DoubleLineNodePlacer, FreeNodePlacer, GridNodePlacer, LayeredNodePlacer, LeftRightNodePlacer, SimpleNodePlacer

public abstract class AbstractRotatableNodePlacer
extends Object
implements IFromSketchNodePlacer

Abstract base class for INodePlacers that support rotations of the subtrees.

The direction specified in this AbstractRotatableNodePlacer (defined by a transformation matrix) rotates the subtree that is placed. This is the final direction of this subtree. Rotations are not accumulated.

INodePlacers of this type will only implement the default direction (i.e. top-to-bottom). The other directions are calculated using the specified modification AbstractRotatableNodePlacer.Matrix. The direction used by the implementing INodePlacers is called the model direction while the actual direction in the graph is the real direction.

Note that using rotatable INodePlacers has some pitfalls. Calculations must be aware of the rotations. Especially operations on BorderLines should not be called directly (e.g. BorderLine.mergeWithMin(com.yworks.yfiles.algorithms.BorderLine), BorderLine.mergeWithMax(com.yworks.yfiles.algorithms.BorderLine)). The corresponding methods of AbstractRotatableNodePlacer already support the different directions.

Subclasses just need to override the following two abstract methods: placeSubtree(Node, ParentConnectorDirection) and determineChildConnectors(Node, IDataMap).

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AbstractRotatableNodePlacer.Matrix A matrix describes the rotation of the subtree handled by AbstractRotatableNodePlacer.
static class	AbstractRotatableNodePlacer.RootAlignment A RootAlignment describes how a local root node is arranged in relation to its children.

Field Summary

Fields

Modifier and Type	Field and Description
protected List<Object>	createdChildren The list containing the created children.
protected LayoutGraph	graph The graph instance this INodePlacer is working on.
protected IDataProvider	nodeShapeProvider The provider of TreeLayout.SubtreeShapes for single nodes.
protected IDataProvider	subtreeShapeProvider The provider of TreeLayout.SubtreeShapes for whole subtrees.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractRotatableNodePlacer(AbstractRotatableNodePlacer.Matrix modificationMatrix) Creates a new instance of AbstractRotatableNodePlacer whose direction is specified by the given modification matrix.

Method Summary

Modifier and Type	Method and Description
Comparator<Object>	createComparator() Creates a Comparator for outgoing edges that takes the rotation into account.
Comparator<Object>	createFromSketchComparator() Delegates to createComparator().
IProcessor	createProcessor(TreeLayout layouter, LayoutGraph graph, Node currentRoot) Creates an optional IProcessor for pre- and post-processing.
protected abstract ParentConnectorDirection	determineChildConnector(Node child) Determines a connector direction for the given child node.
void	determineChildConnectors(Node localRoot, IDataMap connectorMap) Provides the direction of the connector to the SubtreeShape for each child node.
AbstractRotatableNodePlacer.Matrix	getModificationMatrix() Gets the modification matrix that defines the direction of the subtree.
protected RotatedSubtreeShape	getNodeShape(Node node) Returns the rotated subtree shape for the given node.
protected PortConstraint	getPortConstraint(Node localRoot) Returns the target PortConstraint for the local root's incoming edge.
protected YPoint	getSourcePointAbs(Edge edge) Returns the absolute source point of the given edge depending on the rotation of this INodePlacer.
double	getSpacing() Gets the spacing between subtrees.
protected RotatedSubtreeShape	getSubtreeShape(Node node) Returns the rotated subtree shape for the subtree rooted at the given node.
TreeLayout.SubtreeShape	placeSubtree(IDataProvider nodeShapeProvider, IDataProvider subtreeShapeProvider, LayoutGraph graph, Node localRoot, ParentConnectorDirection parentConnectorDirection) Initializes the local data structures and then delegates the work to the abstract variant of this method (placeSubtree(Node, ParentConnectorDirection)).
protected abstract RotatedSubtreeShape	placeSubtree(Node localRoot, ParentConnectorDirection parentConnectorDirection) Arranges the local root relative to the rotated subtree shapes of its children.
void	setSpacing(double value) Sets the spacing between subtrees.
protected byte	translateDirectionToModel(ParentConnectorDirection realDirection) Translates the given real direction of the resulting layout to the model direction of this AbstractRotatableNodePlacer.
protected byte	translateDirectionToReal(ParentConnectorDirection modelDirection) Translates the given model direction to the real direction in the resulting layout.
static YPoint	translatePoint(AbstractRotatableNodePlacer.Matrix modificationMatrix, YPoint realWorldPoint) Translates a point from the real layout direction to the model direction using the given modification matrix.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

createdChildren

protected List<Object> createdChildren

The list containing the created children.

graph

protected LayoutGraph graph

The graph instance this INodePlacer is working on.

nodeShapeProvider

protected IDataProvider nodeShapeProvider

The provider of TreeLayout.SubtreeShapes for single nodes.

subtreeShapeProvider

protected IDataProvider subtreeShapeProvider

The provider of TreeLayout.SubtreeShapes for whole subtrees.

Constructor Detail

AbstractRotatableNodePlacer

protected AbstractRotatableNodePlacer(AbstractRotatableNodePlacer.Matrix modificationMatrix)

Creates a new instance of AbstractRotatableNodePlacer whose direction is specified by the given modification matrix.

Parameters:

modificationMatrix - the transformation matrix for the INodePlacer

Method Detail

createComparator

public Comparator<Object> createComparator()

Creates a Comparator for outgoing edges that takes the rotation into account.

Returns:

the Comparator that considers the rotation

createFromSketchComparator

public Comparator<Object> createFromSketchComparator()

Delegates to createComparator().

Specified by:

createFromSketchComparator in interface IFromSketchNodePlacer

Returns:

the From Sketch Comparator

See Also:

createComparator()

createProcessor

public IProcessor createProcessor(TreeLayout layouter,
                                  LayoutGraph graph,
                                  Node currentRoot)

Creates an optional IProcessor for pre- and post-processing.

This implementation returns null. Hence, no pre- or post-processing is done.

Specified by:

createProcessor in interface INodePlacer

Parameters:

layouter - the current TreeLayout instance

graph - the input graph

currentRoot - the root node handled by this INodePlacer

Returns:

null

determineChildConnector

protected abstract ParentConnectorDirection determineChildConnector(Node child)

Determines a connector direction for the given child node.

This method is called by determineChildConnectors(Node, IDataMap) and must be implemented by subclasses. Implementations can assume the default direction (top-to-bottom) for their arrangement.

Parameters:

child - the child node

Returns:

a direction specifier as defined in the INodePlacer interface

determineChildConnectors

public void determineChildConnectors(Node localRoot,
                                     IDataMap connectorMap)

Provides the direction of the connector to the SubtreeShape for each child node.

This implementation uses determineChildConnector(Node) and the modification matrix to retrieve the direction for the connectors.

Specified by:

determineChildConnectors in interface INodePlacer

Parameters:

localRoot - the local root

connectorMap - the map that must be used for storing the direction specifiers of the child nodes

See Also:

determineChildConnector(Node)

getModificationMatrix

public AbstractRotatableNodePlacer.Matrix getModificationMatrix()

Gets the modification matrix that defines the direction of the subtree.

Returns:

the modification matrix

getNodeShape

protected RotatedSubtreeShape getNodeShape(Node node)

Returns the rotated subtree shape for the given node.

This is a convenience method that retrieves a rotated subtree shape for a single node from the corresponding IDataProvider. This shape may be modified and returned by placeSubtree(Node, ParentConnectorDirection).

This method can first be called during the execution of placeSubtree(Node, ParentConnectorDirection). Otherwise, the IDataProvider for querying results will not have been initialized yet.

Parameters:

node - the node

Returns:

the subtree shape for the given node

getPortConstraint

protected PortConstraint getPortConstraint(Node localRoot)

Returns the target PortConstraint for the local root's incoming edge.

This method translates the PortConstraint according to the rotation described by the modification matrix. It should be used instead of PortConstraint.getTPC(LayoutGraph, Edge).

This method may be used in placeSubtree(Node, ParentConnectorDirection) to route the edges to the according port. It may be overridden to provide constant PortConstraints for each node.

Parameters:

localRoot - the local root

Returns:

the PortConstraint for the incoming edge of the local root or PortSide.ANY if no PortConstraint is assigned for that edge

getSourcePointAbs

protected YPoint getSourcePointAbs(Edge edge)

Returns the absolute source point of the given edge depending on the rotation of this INodePlacer.

This method translates the source point according to the rotation described by the modification matrix. It should be used instead of LayoutGraph.getSourcePointAbs(Edge).

It can be used in an implementation of placeSubtree(Node, ParentConnectorDirection).

Parameters:

edge - the edge whose absolute source point should be calculated

Returns:

the translated absolute source point for the given edge and current modification matrix

getSpacing

public double getSpacing()

Gets the spacing between subtrees.

The spacing needs to be non-negative.

Throws:

IllegalArgumentException - if the given spacing is negative

Default Value:

The default value is 20.

Returns:

the distance between subtrees

See Also:

setSpacing(double)

getSubtreeShape

protected RotatedSubtreeShape getSubtreeShape(Node node)

Returns the rotated subtree shape for the subtree rooted at the given node.

This is a convenience method that retrieves a subtree shape of a complete subtree from the corresponding IDataProvider.

This method can first be called during the execution of placeSubtree(Node, ParentConnectorDirection). Before, the IDataProvider for querying results will not have been initialized yet.

Parameters:

node - the local root node

Returns:

the rotated subtree shape of the subtree rooted at the given local root node

placeSubtree

public TreeLayout.SubtreeShape placeSubtree(IDataProvider nodeShapeProvider,
                                            IDataProvider subtreeShapeProvider,
                                            LayoutGraph graph,
                                            Node localRoot,
                                            ParentConnectorDirection parentConnectorDirection)

Initializes the local data structures and then delegates the work to the abstract variant of this method (placeSubtree(Node, ParentConnectorDirection)).

Specified by:

placeSubtree in interface INodePlacer

Parameters:

nodeShapeProvider - the IDataProvider for obtaining an initial shape of the root node

subtreeShapeProvider - the IDataProvider for accessing the pre-calculated shapes of the subtrees

graph - the input graph

localRoot - the root of the subtree that should be arranged by this method

parentConnectorDirection - the direction specifier for the connector of the local root node to its parent node

Returns:

the merged TreeLayout.SubtreeShape for the subtree rooted at the local root node

See Also:

placeSubtree(Node, ParentConnectorDirection)

placeSubtree

protected abstract RotatedSubtreeShape placeSubtree(Node localRoot,
                                                    ParentConnectorDirection parentConnectorDirection)

Arranges the local root relative to the rotated subtree shapes of its children.

This is the main method that must be implemented by subclasses. For calculations and locations subclasses should use the corresponding methods of AbstractRotatableNodePlacer which already consider the modification matrix.

Parameters:

localRoot - the local root node

parentConnectorDirection - the direction specifier for the connector of the local root node to its parent node

Returns:

the merged subtree shape that contains the local root node and all its children

setSpacing

public void setSpacing(double value)

Sets the spacing between subtrees.

The spacing needs to be non-negative.

Throws:

IllegalArgumentException - if the given spacing is negative

Default Value:

The default value is 20.

Parameters:

value - the distance between subtrees

See Also:

getSpacing()

translateDirectionToModel

protected byte translateDirectionToModel(ParentConnectorDirection realDirection)

Translates the given real direction of the resulting layout to the model direction of this AbstractRotatableNodePlacer.

This method is used in placeSubtree(Node, ParentConnectorDirection) to be able to retrieve the model direction for the connector

Throws:

IllegalArgumentException - if translation for the given real direction is not implemented

Parameters:

realDirection - the real direction

Returns:

the model direction

translateDirectionToReal

protected byte translateDirectionToReal(ParentConnectorDirection modelDirection)

Translates the given model direction to the real direction in the resulting layout.

This method is used in determineChildConnectors(Node, IDataMap) to be able to return the real connector direction.

Throws:

IllegalArgumentException - if translation for the given model direction is not implemented

Parameters:

modelDirection - the model direction

Returns:

the real direction

translatePoint

public static final YPoint translatePoint(AbstractRotatableNodePlacer.Matrix modificationMatrix,
                                          YPoint realWorldPoint)

Translates a point from the real layout direction to the model direction using the given modification matrix.

Parameters:

modificationMatrix - the modification matrix to use for the translation

realWorldPoint - the point with coordinates from the real world

Returns:

the translated point with coordinates from the model