com.github.gwtd3.api.layout

Class TreeLayout

java.lang.Object

com.google.gwt.core.client.JavaScriptObject

com.github.gwtd3.api.layout.Layout<TreeLayout>

com.github.gwtd3.api.layout.TreeLayout

public class TreeLayout
extends Layout<TreeLayout>

Per the d3 API reference, the tree layout produces tidy node-link diagrams of trees using the Reingold–Tilford “tidy” algorithm. Like most other layouts, the object returned by d3.layout.tree is both an object and a function. That is: you can call the layout like any other function, and the layout has additional methods that change its behavior. Like other classes in D3, layouts follow the method chaining pattern where setter methods return the layout itself, allowing multiple setters to be invoked in a concise statement.

Author:

Evan Shi

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	TreeLayout()

Method Summary

Methods

Modifier and Type	Method and Description
TreeLayout	children(DatumFunction<Array<Node>> df) Sets the specified children accessor function.
Array<Link>	links(Array<Node> n) Given the specified array of nodes, such as those returned by nodes, returns an array of objects representing the from parent to child for each node.
Array<Node>	nodes(Node r) Runs the tree layout, returning the array of nodes associated with the specified root node.
Array<Double>	nodeSize() Returns the current node size, which defaults to null, meaning that the layout has an overall fixed size, which can be retrieved using size().
TreeLayout	nodeSize(double width, double height) Sets a fixed size for each node as a two-element array of numbers representing x and y.
TreeLayout	separation(Sort sort) Uses the specified function to compute separation between neighboring nodes.
Array<Double>	size() Returns the current tree size, which defaults to 1×1.
TreeLayout	size(double width, double height) Sets the available layout size to the specified two-element array of numbers representing x and y.
TreeLayout	sort(Sort sort) Sets the sort order of sibling nodes for the layout using the specified comparator function.
DatumFunction<?>	value() Returns the current value accessor which defaults to null, meaning that the value attribute is not computed.
TreeLayout	value(DatumFunction<?> df) Sets the value accessor to the specified function.

Methods inherited from class com.github.gwtd3.api.layout.Layout

chord, tree

Methods inherited from class com.google.gwt.core.client.JavaScriptObject

cast, createArray, createFunction, createObject, equals, hashCode, toSource, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

TreeLayout

protected TreeLayout()

Method Detail

nodes

public final Array<Node> nodes(Node r)

Runs the tree layout, returning the array of nodes associated with the specified root node. The tree layout is part of D3's family of hierarchical layouts. These layouts follow the same basic structure: the input argument to layout is the root node of the hierarchy, and the output return value is an array representing the computed positions of all nodes. Several attributes are populated on each node:

• parent - the parent Node, or null for the root.
• children - the array of child nodes, or null for leaf nodes.
• depth - the depth of the node, starting at 0 for the root.
• x - the computed x-coordinate of the node position.
• y - the computed y-coordinate of the node position.

Although the layout has a size in x and y, this represents an arbitrary coordinate system; for example, you can treat x as a radius and y as an angle to produce a radial rather than Cartesian layout.

Parameters:

root - of the the tree

Returns:

array of Node in the tree stemming from root

links

public final Array<Link> links(Array<Node> n)

Given the specified array of nodes, such as those returned by nodes, returns an array of objects representing the from parent to child for each node. Leaf nodes will not have any links. Each link is an object with two attributes:

• source - the parent node (as described above).
• target - the child node.

This method is useful for retrieving a set of link descriptions suitable for display, often in conjunction with the Diagonal shape generator.

Parameters:

array - of nodes in tree

Returns:

array of Link connecting nodes

size

public final TreeLayout size(double width,
              double height)

Sets the available layout size to the specified two-element array of numbers representing x and y.

Parameters:

a - two-element array of width and height of tree

Returns:

this tree object

size

public final Array<Double> size()

Returns the current tree size, which defaults to 1×1. Although the layout has a size in x and y, this represents an arbitrary coordinate system. For example, to produce a radial layout where the tree breadth (*x*) is measured in degrees, and the tree depth (*y*) is a radius r in pixels, say [360, r].

Returns:

a two-element array representing the current size of the tree

nodeSize

public final TreeLayout nodeSize(double width,
                  double height)

Sets a fixed size for each node as a two-element array of numbers representing x and y.

Parameters:

width -

height -

Returns:

this tree layout

nodeSize

public final Array<Double> nodeSize()

Returns the current node size, which defaults to null, meaning that the layout has an overall fixed size, which can be retrieved using size().

Returns:

a two element array representing the current size of nodes in the tree

sort

public final TreeLayout sort(Sort sort)

Sets the sort order of sibling nodes for the layout using the specified comparator function. The comparator function is invoked for pairs of nodes, being passed the input data for each node. The default comparator is null, which disables sorting and uses tree traversal order. Sorting by the node's name or key is common and can be done easily using D3#ascending() or D3#descending().

Parameters:

{@link - Sort} a predefined sorting convention

Returns:

this tree object

separation

public final TreeLayout separation(Sort sort)

Uses the specified function to compute separation between neighboring nodes. The separation function is passed two neighboring nodes a and b, and must return the desired separation between nodes. The nodes are typically siblings, though the nodes may also be cousins (or even more distant relations) if the layout decides to place such nodes adjacent. See wiki for examples.

Parameters:

df - a datum function describing how to calculate separation of nodes

Returns:

this tree object

children

public final TreeLayout children(DatumFunction<Array<Node>> df)

Sets the specified children accessor function. The default children accessor function assumes the input data is an object with a children array. The children accessor is first invoked for root node in the hierarchy. If the accessor returns null, then the node is assumed to be a leaf node at the layout traversal terminates. Otherwise, the accessor should return an array of data elements representing the child nodes.

Parameters:

df - a datum function describing how to compute children

Returns:

this tree object

value

public final TreeLayout value(DatumFunction<?> df)

Sets the value accessor to the specified function. The value accessor is invoked for each input data element, and must return a number representing the numeric value of the node. This value has no effect on the tree layout, but is generic functionality provided by hierarchy layouts.

Parameters:

df - a datum function describing how to access node values

Returns:

this tree object

value

public final DatumFunction<?> value()

Returns the current value accessor which defaults to null, meaning that the value attribute is not computed.

Returns:

the current datum function registered for calculating node values