The TikZ and PGF Packages
Manual for version 3.1.10

This operation should directly follow a completed node operation or another child operation, although it is permissible that the first child operation is preceded by options (we will come to that).

When a node operation like node {X} is followed by child, TikZ starts counting the number of child nodes that follow the original node {X}. For this, it scans the input and stores away each child and its arguments until it reaches a path operation that is not a child. Note that this will fix the character codes of all text inside the child arguments, which means, in essence, that you cannot use verbatim text inside the nodes inside a child. Sorry.

Once the children have been collected and counted, TikZ starts generating the child nodes. For each child of a parent node TikZ computes an appropriate position where the child is placed. For each child, the coordinate system is transformed so that the origin is at this position. Then the ⟨child path⟩ is drawn. Typically, the child path just consists of a node specification, which results in a node being drawn at the child’s position. Finally, an edge is drawn from the first node in the ⟨child path⟩ to the parent node.

The optional foreach part (note that there is no backslash before foreach) allows you to specify multiple children in a single child command. The idea is the following: A \foreach statement is (internally) used to iterate over the list of ⟨values⟩. For each value in this list, a new child is added to the node. The syntax for ⟨variables⟩ and for ⟨values⟩ is the same as for the \foreach statement, see Section 88. For example, when you say

the effect will be the same as if you had said

When you write

the effect will be the same as for

You can nest things as in the following example:

The details and options for this operation are described in the rest of this present section.

This style is used at the beginning of each child, as if you had given the style’s contents as options to the child operation.

This style is used at the beginning of each child node in addition to the every node style.

This style is executed at the beginning of each set of children, where ⟨number⟩ is the current level in the current tree. For example, when you say \node {x} child child;, then level=1 is used before the first child. The style or code of this key will be passed ⟨number⟩ as its first parameter. If this first child has children itself, then level=2 would be used for them.

This style is used in addition to the level style. So, when you say \node {x} child child;, then the following key list is executed: level=1,level 1.

This key determines the distance between different levels of the tree, more precisely, between the parent and the line on which its children are arranged. When given to a single child, this will set the distance for this child only.

This key specifies the distance between the anchors of the children of a parent node.

This key is used to define the ⟨direction⟩ in which the tree will grow. The ⟨direction⟩ can either be an angle in degrees or one of the following special text strings: down, up, left, right, north, south, east, west, north east, north west, south east, and south west. All of these have “their obvious meaning”, so, say, south west is the same as the angle \(-135^\circ \).

As a side effect, this option installs the default growth function.

In addition to setting the direction, this option also has a seemingly strange effect: It sets the sibling distance for the current level to 0pt, but leaves the sibling distance for later levels unchanged.

This somewhat strange behavior has a highly desirable effect: If you give this option before the list of children of a node starts, the “current level” is still the parent level. Each child will be on a later level and, hence, the sibling distance will be as specified originally. This will cause the children to be neatly aligned in a line orthogonal to the given ⟨direction⟩. However, if you give this option locally to a single child, then “current level” will be the same as the child’s level. The zero sibling distance will then cause the child to be placed exactly at a point at distance level distance in the direction ⟨direction⟩. However, the children of the child will be placed “normally” on a line orthogonal to the ⟨direction⟩.

These placement effects are best demonstrated by some examples:

This key has the same effect as grow, only the children are arranged in the opposite order.

If this option is given to a child, the current child counter is increased, but the child is otherwise ignored. In particular, the normal contents of the child is completely ignored.

This key allows you to specify which anchor of the parent node is to be used for computing the children’s position. For example, when there is only one child and the level distance is 2cm, then the child node will be placed two centimeters below the ⟨anchor⟩ of the parent node. “Being placed” means that the child node’s anchor (which is the anchor specified using the anchor= option in the node command of the child) is two centimeters below the parent node’s ⟨anchor⟩.

In the following example, the two red lines both have length 1cm.

In the next example, the top and bottom nodes are aligned at the top and the bottom, respectively.

This rather low-level option allows you to set a new growth function. The ⟨macro name⟩ must be the name of a macro without parameters. This macro will be called for each child of a node. The initial function is an internal function that corresponds to downward growth.

The effect of executing the macro should be the following: It should transform the coordinate system in such a way that the origin becomes the place where the current child should be anchored. When the macro is called, the current coordinate system will be set up such that the anchor of the parent node is in the origin. Thus, in each call, the ⟨macro name⟩ must essentially do a shift to the child’s origin. When the macro is called, the TeX counter \tikznumberofchildren will be set to the total number of children of the parent node and the counter \tikznumberofcurrentchild will be set to the number of the current child.

The macro may, in addition to shifting the coordinate system, also transform the coordinate system further. For example, it could be rotated or scaled.

Additional growth functions are defined in the library, see Section 76.

This path operation can only be used inside ⟨child paths⟩ and should be given at the end, possibly followed by ⟨node specifications⟩ like node {a}. If a ⟨child path⟩ does not contain this operation, it will be added at the end of the ⟨child path⟩ automatically.

By default, this operation does the following:

• 1. The following style is executed:

  /tikz/edge from parent(style, initially draw) ¶

  This style is inserted right before the edge from parent path and before the ⟨options⟩ are inserted.

  

  copy
\begin{tikzpicture}
[edge from parent/.style={draw,red,thick}]
\node {root}
child {node {left} edge from parent[dashed]}
child {node {right}
child {node {child}}
child {node {child} edge from parent[draw=none]}
};
\end{tikzpicture}


• 2. Next, the ⟨options⟩ are executed.

• 3. Next, the text stored in the following key is inserted:

  /tikz/edge from parent path=⟨path⟩ (no default, initially code shown below) ¶

  This option allows you to set the edge from parent path to a new path. Initially, this path is the following:

  copy
(\tikzparentnode\tikzparentanchor) -- (\tikzchildnode\tikzchildanchor)


  The \tikzparentnode is a macro that will expand to the name of the parent node. This works even when you have not assigned a name to the parent node, in this case an internal name is automatically generated. The \tikzchildnode is a macro that expands to the name of the child node. The two ...anchor macros are empty by default. So, what is essentially inserted is just the path segment (\tikzparentnode) -- (\tikzchildnode); which is exactly an edge from the parent to the child.

  You can modify this edge from parent path to achieve all sorts of effects. For example, we could replace the straight line by a curve as follows:

  

  copy
\begin{tikzpicture}[level distance=15mm, sibling distance=15mm,
edge from parent path=
{(\tikzparentnode.south) .. controls +(0,-1) and +(0,1)
.. (\tikzchildnode.north)}]
\node {root}
child {node {left}}
child {node {right}
child {node {child}}
child {node {child}}
};
\end{tikzpicture}


  Further useful edge from parent paths are defined in the tree library, see Section 76.

  The nodes in a ⟨node specification⟩ following the edge from parent path command get executed as if the pos option had been added to all these nodes, see also Section 17.8.

  As an example, consider the following code:

  copy
\node (root) {} child {node (child) {} edge to parent node {label}};


  The edge to parent operation and the following node operation will, together, have the same effect as if we had said:

  copy
(root) -- (child) node [pos=0.5] {label}


  Here is a more complicated example:

  

  copy
\begin{tikzpicture}
\node {root}
child {
node {left}
edge from parent
node[left] {a}
node[right] {b}
}
child {
node {right}
child {
node {child}
edge from parent
node[left] {c}
}
child {node {child}}
edge from parent
node[near end] {x}
};
\end{tikzpicture}


  As said before, the anchors in the default edge from parent path are empty. However, you can set them using the following keys:

  /tikz/child anchor=⟨anchor⟩ (no default, initially border) ¶

  Specifies the anchor where the edge from parent meets the child node by setting the macro \tikzchildanchor to .⟨anchor⟩.

  If you specify border as the ⟨anchor⟩, then the macro \tikzchildanchor is set to the empty string. The effect of this is that the edge from the parent will meet the child on the border at an automatically calculated position.

  

  copy
\begin{tikzpicture}
\node {root}
[child anchor=north]
child {node {left} edge from parent[dashed]}
child {node {right}
child {node {child}}
child {node {child} edge from parent[draw=none]}
};
\end{tikzpicture}


  /tikz/parent anchor=⟨anchor⟩ (no default, initially border) ¶

  This option works the same way as the child anchor, only for the parent.

All of the above describes the standard functioning of the edge from parent command. You may, however, sometimes need even more fine-grained control (the graph drawing engine needs it, for instance). In such cases the following key gives you complete control: