% \CheckSum{12832} % \iffalse meta-comment % forest.dtx %% `forest' is a `pgf/tikz'-based package for drawing (linguistic) trees. %% %% Copyright (c) 2013 Saso Zivanovic %% (Sa\v{s}o \v{Z}ivanovi\'{c}) %% saso.zivanovic@guest.arnes.si %% %% This work may be distributed and/or modified under the %% conditions of the LaTeX Project Public License, either version 1.3 %% of this license or (at your option) any later version. %% The latest version of this license is in %% %% http://www.latex-project.org/lppl.txt %% %% and version 1.3 or later is part of all distributions of LaTeX %% version 2005/12/01 or later. %% %% This work has the LPPL maintenance status `maintained'. %% %% The Current Maintainer of this work is Saso Zivanovic. %% %% This work consists of the files forest.dtx and forest.ins %% and the derived file forest.sty. %% % %<*driver> \documentclass[a4paper]{ltxdoc} \usepackage{fullpage} \usepackage[external]{forest} %\tikzexternalize \tikzset{ external/prefix={forest.for.dir/}, external/system call={ pdflatex \tikzexternalcheckshellescape -halt-on-error -interaction=nonstopmode -jobname "\image" "\texsource"}, } %\usepackage[trace]{trace-pgfkeys} \usepackage[colorlinks=true,linkcolor=blue,citecolor=blue,hyperindex=false]{hyperref} \usepackage{url} \usepackage[numbers]{natbib} \usepackage[multiple]{footmisc} \usepackage{tipa} \usepackage{paralist} \usepackage{printlen} \makeatletter \DeleteShortVerb\| \newcommand\OR{\ensuremath{\,|\,}}% %%%%%%%% %\usepackage{lstdoc} %%% copy/paste most of the file, but omit and adjust some stuff like %section-modifications \usepackage{listings} \def\lst@sampleInput{% \MakePercentComment\catcode`\^^M=10\relax \small\lst@sample {\setkeys{lst}{SelectCharTable=\lst@ReplaceInput{\^\^I}% {\lst@ProcessTabulator}}% \leavevmode \input{\jobname.tmp}}\MakePercentIgnore} \definecolor{darkgreen}{rgb}{0,0.5,0} \def\rstyle{\color{red}} \def\advise{\par\list\labeladvise {\advance\linewidth\@totalleftmargin \@totalleftmargin\z@ \@listi \let\small\footnotesize \small\sffamily \parsep \z@ \@plus\z@ \@minus\z@ \topsep6\p@ \@plus1\p@\@minus2\p@ \def\makelabel##1{\hss\llap{##1}}}} \let\endadvise\endlist \def\advisespace{\hbox{}\qquad} \def\labeladvise{$\to$} \newenvironment{syntax} {\list{}{\itemindent-\leftmargin \def\makelabel##1{\hss\lst@syntaxlabel##1,,,,\relax}}} {\endlist} \def\lst@syntaxlabel#1,#2,#3,#4\relax{% \llap{\scriptsize\itshape#3}% \def\lst@temp{#2}% \expandafter\lst@syntaxlabel@\meaning\lst@temp\relax \rlap{\hskip-\itemindent\hskip\itemsep\hskip\linewidth \llap{\ttfamily\lst@temp}\hskip\labelwidth \def\lst@temp{#1}% \ifx\lst@temp\lstdoc@currversion#1\fi}} \def\lst@syntaxlabel@#1>#2\relax {\edef\lst@temp{\zap@space#2 \@empty}} \newcommand*\syntaxnewline{\newline\hbox{}\kern\labelwidth} \newcommand*\syntaxor{\qquad or\qquad} \newcommand*\syntaxbreak {\hfill\kern0pt\discretionary{}{\kern\labelwidth}{}} \let\syntaxfill\hfill \def\alternative#1{\lst@true \alternative@#1,\relax,} \def\alternative@#1,{% \ifx\relax#1\@empty \expandafter\@gobble \else \ifx\@empty#1\@empty\else %\if \lst@if \lst@false \else $\vert$\fi \textup{\texttt{#1}}% \fi \fi \alternative@} \lst@RequireAspects{writefile} \lst@InstallKeywords{p}{point}{pointstyle}\relax{keywordstyle}{}ld \def\pstyle{\color{darkgreen}} \lstset{language={[LaTeX]TeX},tabsize=4,gobble=4,% basicstyle=\small\ttfamily,basewidth=0.51em,boxpos=t,pointstyle=\pstyle,moredelim=[is][\pstyle]{~}{~}}% \newbox\sampleoutputbox \newbox\lst@samplebox \newdimen\forestexample@code \newdimen\forestexample@sample \newdimen\forestexample@hsep \forestexample@hsep=1em \lst@Key{hsep}\relax{\forestexample@hsep=#1}% \pgfqkeys{/forestexample}{% samplebox/.code={\let\sampleoutputbox#1}, codebox/.code={\let\lst@samplebox#1}, pos/.initial=l, % example is left of the code before/.code={\gdef\lst@sample{#1}}, labelformat/.initial={\def\@currentlabel{#1}}, no numbering/.code={\addtocounter{lstlisting}{-1}\pgfkeysalso{labelformat={}}}, .unknown/.code={\lstset{\pgfkeyscurrentname={#1}}}, ekeynames/.code={\def\myindex@for@temp##1{\ekeyname[example]{##1}}\forcsvlist\myindex@for@temp{#1}}, ecmdnames/.code={\forcsvlist{\ecmdname[example]}{#1}}, filename/.initial={}, } \lstnewenvironment{forestexample}[1][]{% \global\let\lst@intname\@empty \def\@currentlabel{(\arabic{lstlisting})}% \addtocounter{lstlisting}{1}% \gdef\lst@sample{}% \pgfqkeys{/forestexample}{#1}% \setbox\lst@samplebox=\hbox\bgroup \xdef\samplebox@baselineskip{\the\baselineskip}% \catcode`~=9\relax \lst@BeginAlsoWriteFile{\jobname.tmp}% }{% \lst@EndWriteFile\egroup \immediate\write18{cat \jobname.tmp}% \pgfkeysgetvalue{/forestexample/pos}\fe@pos \if x\fe@pos %%%%%%%% user position: boxes are stored in cs given in samplebox and codebox args \forest@temp@count=\@listdepth \pgfutil@tempdima=0pt \loop \ifnum\forest@temp@count>0 \advance\pgfutil@tempdima\csname leftmargin\romannumeral\the\forest@temp@count\endcsname\relax \advance\forest@temp@count-1 \repeat \global\setbox\lst@samplebox=\hbox{\hskip-\pgfutil@tempdima\box\lst@samplebox\hskip\pgfutil@tempdima}% \global\setbox\sampleoutputbox=\hbox{\lst@sampleInput}% \else \if l\fe@pos %%%% example is left of the code % move the code left for each list's \leftmargin ... have no idea why this must be done \forest@temp@count=\@listdepth \pgfutil@tempdima=0pt \loop \ifnum\forest@temp@count>0 \advance\pgfutil@tempdima\csname leftmargin\romannumeral\the\forest@temp@count\endcsname\relax \advance\forest@temp@count-1 \repeat \setbox\lst@samplebox=\hbox{\hskip-\pgfutil@tempdima\box\lst@samplebox\hskip\pgfutil@tempdima}% \setbox\sampleoutputbox=\hbox{\lst@sampleInput}% \pgfutil@tempdima=\wd\sampleoutputbox \advance\pgfutil@tempdima\wd\lst@samplebox \advance\pgfutil@tempdima\forestexample@hsep \ifdim\pgfutil@tempdima>\linewidth \forestexample@code=\linewidth \advance\forestexample@code-\wd\lst@samplebox \forestexample@sample=\forestexample@code \advance\forestexample@sample-\forestexample@hsep \advance\forestexample@sample-\wd\sampleoutputbox \else \pgfutil@tempdima=\wd\sampleoutputbox \advance\pgfutil@tempdima\forestexample@hsep \ifdim\pgfutil@tempdima>.5\linewidth \forestexample@sample=0pt \forestexample@code=\wd\sampleoutputbox \advance\forestexample@code\forestexample@hsep \else \pgfutil@tempdima=\wd\lst@samplebox \advance\pgfutil@tempdima\forestexample@hsep \ifdim\pgfutil@tempdima>.5\linewidth \forestexample@code=\linewidth \advance\forestexample@code-\wd\lst@samplebox \forestexample@sample=0pt \else \forestexample@sample=0pt \forestexample@code=.5\linewidth \fi \fi \fi \begin{trivlist}\item\relax $% \vcenter{ \hbox{% \hbox to 0pt{\hskip\linewidth\llap{\@currentlabel}}% \hbox to 0pt{% \hskip\forestexample@code \raise\samplebox@baselineskip\box\lst@samplebox }% }% }% \vcenter{% \hbox to 0pt{% \hskip\forestexample@sample \box\sampleoutputbox }% }% $% \end{trivlist}% \else \if t\fe@pos %%%% example is above the code \forest@temp@count=\@listdepth \pgfutil@tempdima=0pt \loop \ifnum\forest@temp@count>0 \advance\pgfutil@tempdima\csname leftmargin\romannumeral\the\forest@temp@count\endcsname\relax \advance\forest@temp@count-1 \repeat \setbox\lst@samplebox=\hbox{\hskip-\pgfutil@tempdima\box\lst@samplebox\hskip\pgfutil@tempdima}% \setbox\sampleoutputbox=\hbox{\lst@sampleInput}% \begin{trivlist}% \item \hfil\box\sampleoutputbox\hfil \item \hbox{% \hbox to 0pt{\hskip\linewidth\llap{\@currentlabel}}% \hbox to 0pt{% \raise\samplebox@baselineskip\box\lst@samplebox }% }% \end{trivlist}% \else \if b\fe@pos %%% example is below the code \forest@temp@count=\@listdepth \pgfutil@tempdima=0pt \loop \ifnum\forest@temp@count>0 \advance\pgfutil@tempdima\csname leftmargin\romannumeral\the\forest@temp@count\endcsname\rel ax \advance\forest@temp@count-1 \repeat \setbox\lst@samplebox=\hbox{\hskip-\pgfutil@tempdima\box\lst@samplebox\hskip\pgfutil@tempdima}% \setbox\sampleoutputbox=\hbox{\lst@sampleInput}% \begin{trivlist}% \item \hbox{% \hbox to 0pt{\hskip\linewidth\llap{\@currentlabel}}% \hbox to 0pt{% \raise\samplebox@baselineskip\box\lst@samplebox }% }% \item \hfil\box\sampleoutputbox\hfil \end{trivlist}% \else %%% insert other pos here.... \fi \fi \fi \fi }% \def\myisaspect#1#2#3{% #1=aspect id, #2=aspect display, #3=entry ids \csdef{myaspect@display@#1}{#2}% \edef\myisaspect@##1{% \csdef{myaspect@of@##1}{#1}% }% \forcsvlist\myisaspect@{#3}% } \def\my@index#1#2#3#4{% #1=entry id,#2=entry display,#3=aspect id,#4=pagestyle \ifstrempty{#3}{% \edef\mytemp{% \noexpand\index{#1=\unexpanded{#2}#4}% }% }{% \edef\mytemp{% \noexpand\index{% #1=\unexpanded{#2}\protect\noexpand\space {\protect\noexpand\scriptsize \expandafter\expandafter\expandafter\unexpanded \expandafter\expandafter\expandafter {\csname myaspect@display@#3\endcsname}% }% #4% }% \noexpand\index{#3=\expandafter\expandafter\expandafter\unexpanded \expandafter\expandafter\expandafter {\csname myaspect@display@#3\endcsname}\levelchar #1=\unexpanded{#2}% #4% }% }% }% \mytemp }% \newcommand\myindex[1]{% \@bsphack \pgfqkeys{/myindex}{#1}% \pgfkeysgetvalue{/myindex/id}\myindex@temp@entryid \pgfkeysgetvalue{/myindex/display}\myindex@temp@entrydisplay \pgfkeysgetvalue{/myindex/aspect}\myindex@temp@aspectid \pgfkeysgetvalue{/myindex/pagestyle}\myindex@temp@pagestyle \edef\myindex@temp{\noexpand\my@index {\expandonce{\myindex@temp@entryid}}{\expandonce{\myindex@temp@entrydisplay}}{\expandonce{\myindex@temp@aspectid}}{\myindex@temp@pagestyle}% }\myindex@temp \@esphack \pgfkeysvalueof{/myindex/text}% } \def\stripfirst#1#2\stripfirst{#2}% \pgfqkeys{/myindex}{% /handlers/.wrap/.code={% \edef\myindex@currentpath{\pgfkeyscurrentpath}% \pgfkeysgetvalue{\myindex@currentpath}\myindex@keyvalue \forest@def@with@pgfeov\myindex@wrap@code{#1}% \expandafter\edef\expandafter\myindex@wrapped@value\expandafter{\expandafter\expandonce\expandafter{\expandafter\myindex@wrap@code\myindex@keyvalue\pgfeov}}% \pgfkeysalso{\myindex@currentpath/.expand once=\myindex@wrapped@value}% }, /handlers/.ewrap/.code={% not used! \edef\myindex@currentpath{\pgfkeyscurrentpath}% \pgfkeysgetvalue{\myindex@currentpath}\myindex@keyvalue \forest@def@with@pgfeov\myindex@wrap@code{#1}% \edef\myindex@wrapped@value{\expandafter\myindex@wrap@code\expandafter{\myindex@keyvalue}\pgfeov}% \pgfkeysalso{\myindex@currentpath/.expand once=\myindex@wrapped@value}% }, id/.code={% \pgfkeyssetvalue{/myindex/id}{#1}% \pgfkeysgetvalue{/myindex/id}\myindex@temp \pgfkeyslet{/myindex/display}\myindex@temp \pgfkeyslet{/myindex/text}\myindex@temp \pgfkeyssetvalue{/myindex/pagestyle}{}% \pgfkeyssetvalue{/myindex/version}{}% \ifcsname myaspect@of@#1\endcsname \pgfkeysalso{aspect/.expand once=\csname myaspect@of@#1\endcsname}% \else \pgfkeyssetvalue{/myindex/aspect}{}% \pgfkeyssetvalue{/myindex/margin}{}% \fi }, id'/.code={\pgfkeyssetvalue{/myindex/id}{#1}}, .unknown/.code={% \edef\myindex@temp{% \noexpand\pgfkeysalso{id={\pgfkeyscurrentname}}% }\myindex@temp }, display/.initial={}, pagestyle/.initial={}, text/.initial={}, aspect/.code={% \edef\myindex@temp{% \noexpand\pgfkeyssetvalue{/myindex/aspect}{#1}% }\myindex@temp \ifcsname myaspect@display@#1\endcsname \edef\myindex@temp{% \noexpand\pgfkeyslet{/myindex/margin}\expandonce{\csname myaspect@display@#1\endcsname}% }\myindex@temp \else \pgfkeyssetvalue{/myindex/margin}{}% \fi }, nfc/.style={% no first char (in id) id'/.expanded={\expandafter\stripfirst\romannumeral-`0\pgfkeysvalueof{/myindex/id}\stripfirst} }, rstyle/.style={text/.wrap={\begingroup\rstyle##1\endgroup}}, example/.style={pagestyle=|indextextexample}, def/.style={pagestyle=|indextextdef}, normal/.style={pagestyle=|indextextnormal}, item/.style={% #1=default text/.wrap={% ##1=current text \item[\pgfkeysvalueof{/myindex/version},#1,\pgfkeysvalueof{/myindex/margin}]{##1}% } }, item/.default={}, version/.initial={}, margin/.initial={}, } \newcommand\indextextexample[1]{\hyperlink{page.#1}{\textcolor{darkgreen}{#1}}} \newcommand\indextextdef[1]{\hyperlink{page.#1}{\textcolor{red}{#1}}} \newcommand\indextextnormal[1]{\hyperlink{page.#1}{\textcolor{blue}{#1}}} \let\keyname\texttt \newcommand\rkeyname[2][]{\myindex{% #2, display/.wrap=\protect\texttt{##1}, text/.wrap=\hypertarget{\pgfkeysvalueof{/myindex/id}}{{\rstyle\keyname{##1}}}, def, #1 }} \newcommand\ikeyname[2][]{\myindex{% #2, display/.wrap=\protect\texttt{##1}, text/.wrap=\hyperlink{\pgfkeysvalueof{/myindex/id}}{\keyname{##1}}, normal, #1 }} \newcommand\ekeyname[2][]{\myindex{% #2, display/.wrap=\protect\texttt{##1}, text={}, normal, #1 }} \newcommand\rmeta[2][]{\myindex{% #2, display/.wrap=\protect\meta{##1}, %text/.wrap=\begingroup\rstyle\meta{##1}\endgroup, text/.wrap=\hypertarget{\pgfkeysvalueof{/myindex/id}}{{\rstyle\meta{##1}}}, def, #1 }} \newcommand\imeta[2][]{\myindex{% #2, display/.wrap=\protect\meta{##1}, text/.wrap=\hyperlink{\pgfkeysvalueof{/myindex/id}}{\meta{##1}}, normal, #1 }} \newcommand\cmdname[1]{\expandafter\texttt\expandafter{\expandafter\string\csname#1\endcsname}} \newcommand\rcmdname[2][]{\myindex{% #2, id'/.expanded=\pgfkeysvalueof{/myindex/id} macro, display/.wrap=\protect\cmdname{##1}, text/.wrap=\hypertarget{\pgfkeysvalueof{/myindex/id}}{{\rstyle\cmdname{##1}}}, def, #1 }} \newcommand\icmdname[2][]{\myindex{% #2, id'/.expanded=\pgfkeysvalueof{/myindex/id} macro, text/.wrap=\hyperlink{\pgfkeysvalueof{/myindex/id}}{\cmdname{##1}}, normal, #1 }} \newcommand\ecmdname[2][]{\myindex{% #2, id'/.expanded=\pgfkeysvalueof{/myindex/id} macro, display/.wrap=\protect\cmdname{##1}, text={}, normal, #1 }} \makeatother \myisaspect{environment}{environment}{forest} \myisaspect{option}{option}{align,content,content format,node format,base,node options,phantom,anchor,calign,calign primary angle,calign secondary angle,calign primary child,calign secondary child,fit,grow,ignore,ignore edge,reversed,l,s,l sep,s sep,tier,x,y,child anchor,edge,edge label,edge path,parent anchor,name,tikz,anchor,level,n,n',n children,id,max x,max y,min x,min y} \myisaspect{propagator}{propagator}{for,if,where,for tree,repeat,delay,delay n,if have delayed,for ancestors,for ancestors',for children,for descendants,for descendants',for all next,for all previous,for previous siblings,before typesetting nodes,before packing,before computing xy,before drawing tree,repeat} \myisaspect{type}{type}{toks,autowrapped toks,keylist,dimen,count,boolean}%relative node name,node walk,step} \myisaspect{handler}{handler}{.pgfmath,.wrap value,.wrap pgfmath arg,.wrap $n$ pgfmath args,.wrap 2 pgfmath args,.wrap 3 pgfmath args,.wrap 4 pgfmath args,.wrap 5 pgfmath args,.wrap 6 pgfmath args,.wrap 7 pgfmath args,.wrap 8 pgfmath args,.wrap 9 pgfmath args} \myisaspect{key prefix}{key prefix}{if in ,where in ,if ,where ,not ,for } \myisaspect{key suffix}{key suffix}{',+,-,*,:,'+,'-,'*,':} \myisaspect{key}{}{afterthought,baseline,label,pin,alias,TeX,TeX',TeX'',no edge,typeset node,repeat,use as bounding box,use as bounding box',draw tree box} \myisaspect{style}{style}{stages,typeset nodes stage,pack stage,compute xy stage,draw tree stage,math content} \myisaspect{stage}{stage}{typeset nodes,typeset nodes',pack,compute xy,draw tree,draw tree'} \myisaspect{package option}{package option}{external,tikzcshack,tikzinstallkeys} \myisaspect{dynamic tree}{dynamic tree}{create,remove,prepend,append,insert after,insert before,set root,replace by,prepend',append',insert after',insert before',replace by',prepend'',append'',insert after'',insert before'',replace by'',copy name template} \myisaspect{forest cs}{forest cs}{} \myisaspect{calign}{\keyname{calign} value}{}%{child,first,last,child edge,midpoint,center,edge midpoint,fixed angles,fixed edge angles} \myisaspect{align}{\keyname{align} value}{}%{left,center,right} \myisaspect{fit}{\keyname{fit} value}{}%{tight,rectangle,band} \myisaspect{base}{\keyname{base} value}{}%{top,bottom} \myisaspect{step}{\meta{step}}{current,next,previous,parent,sibling,previous leaf,next leaf, linear next,linear previous,first leaf,last leaf,to tier,next on tier,previous on tier, root,embed,trip,group,first,last %,n,n',name,id, % these equal option names } \myisaspect{short step}{\meta{short step}}{1,2,3,4,5,6,7,8,9,u,p,% %,n,l,s equal option names P,N,F,L,<,%> is a level char c,r} \myisaspect{generic anchor}{generic anchor}{}% {\catcode`\|=12 \gdef\myindexgt{\texttt{>}}} {\makeatletter % an dirty patch: \lst@nolig can sneak in the name... \gdef\myexampleindex#1{{\def\lst@nolig{}\lstaspectindex{#1}{}}} } \lstset{indexstyle={[1]\myexampleindex}} \makeindex %%% end lst-related stuff \EnableCrossrefs %\DisableCrossrefs % Say \DisableCrossrefs if index is ready %\CodelineIndex %\RecordChanges % Gather update information %\OnlyDescription % comment out for implementation details \setlength\hfuzz{15pt} % dont make so many \hbadness=7000 % over and under full box warnings \def\partname{Part} \def\TikZ;{{\rm Ti\emph{k}Z}}\def\PGF;{\textsc{pgf}}\def\foRest;{\textsc{Forest}}\def\FoRest;{\textsc{Forest}} \usetikzlibrary{intersections} \tikzset{>=latex} \forestset{ background tree/.style={ for tree={text opacity=0.2,draw opacity=0.2,edge={draw opacity=0.2}}} } \def\getforestversion#1/#2/#3 v#4 #5\getforestversion{v#4} \edef\forestversion{\expandafter\expandafter\expandafter\getforestversion\csname ver@forest.sty\endcsname\getforestversion} \def\getforestdate#1/#2/#3 v#4 #5\getforestdate{#1/#2/#3} \edef\forestdate{\expandafter\expandafter\expandafter\getforestdate\csname ver@forest.sty\endcsname\getforestdate} \title{\FoRest;: a \PGF;/\TikZ;-based package for drawing linguistic trees\\\normalsize\forestversion} \author{Sa\v so \v Zivanovi\'c\footnote{e-mail: \href{mailto:saso.zivanovic@guest.arnes.si}{saso.zivanovic@guest.arnes.si}; web: \href{http://spj.ff.uni-lj.si/zivanovic/}{http://spj.ff.uni-lj.si/zivanovic/}}} \def\settodayfromforestdateA#1/#2/#3 v#4 #5\settodayfromforestdateA{\def\year{#1}\def\month{#2}\def\day{#3}} \def\settodayfromforestdate{\expandafter\expandafter\expandafter\settodayfromforestdateA\csname ver@forest.sty\endcsname\settodayfromforestdateA} \begin{document} \DocInput{forest.dtx} \end{document} % % \fi % % ^^A short verbatim: | (changes spaces into _) % \DeleteShortVerb\| % {\catcode`\_=12 \def\marshal{^^A % \lstMakeShortInline[basicstyle=\ttfamily,literate={_}{ }1 {__}{_}1]}^^A % \expandafter}\marshal | % % \newbox\treebox % \newbox\codebox % % % % {\settodayfromforestdate\maketitle} % % \begin{abstract} % \FoRest; is a \PGF;/\TikZ;-based package for drawing linguistic (and % other kinds of) trees. Its main features are % \begin{inparaenum}[(i)] % \item a packing algorithm which can produce very compact trees; % \item a user-friendly interface consisting of the familiar bracket encoding of trees plus the % key--value interface to option-setting; % \item many tree-formatting options, with control over option values of individual nodes and % mechanisms for their manipulation; % \item the possibility to decorate the tree using the full power of \PGF;/\TikZ;; % \item an externalization mechanism sensitive to code-changes. % \end{inparaenum} % \end{abstract} % % {\lstset{basicstyle=\ttfamily\scriptsize}^^A % \begin{forestexample}[samplebox=\treebox,codebox=\codebox,pos=x,ekeynames={content,{id=.pgfmath,nfc},if,repeat,append,before drawing tree,where,y,alias,for ,name,for children,edge,before typesetting nodes,for tree,s sep,l,+,,for ancestors',typeset node}] % \pgfmathsetseed{14285} % \begin{forest} % random tree/.style n args={3}{% #1=max levels, #2=max children, #3=max content % content/.pgfmath={random(0,#3)}, % if={#1>0}{repeat={random(0,#2)}{append={[,random tree={#1-1}{#2}{#3}]}}}{}}, % for deepest/.style={before drawing tree={ % alias=deepest, % where={y()](!)--(!#1);}}}, % p-govern/.style={ % before drawing tree={tikz+={\draw[->](.north) to[out=150,in=30] (!#1.north);}}}, % no p-govern/.style={ % before drawing tree={tikz+={\draw[->,loosely dashed](.north) to[out=150,in=30] (!#1.north);}}}, % encircle/.style={before drawing tree={circle,draw,inner sep=0pt}}, % fen/.style={pin={[font=\footnotesize,inner sep=1pt,pin edge=<-]10:\textsc{Fen}}}, % el/.style={content=\textsc{\textbf{##1}}}, % head/.style={content=\textsc{\textbf{\underline{##1}}}} % } % \end{forestexample} % \input{\jobname.tmp} % % All the examples given above produced top-down trees with centered % children. The other sections of this manual explain how various % properties of a tree can be changed, making it possible to typeset % radically different-looking trees. However, you don't have to learn % everything about this package to profit from its power. Using % styles, you can draw predefined types of trees with ease. For % example, a phonologist can use the \ikeyname{GP1} style from \S\ref{sec:gallery} to easily typeset % (Government Phonology) phonological % representations. The style is applied simply by writing its name % before the first (opening) bracket of the tree. % \begin{forestexample}[label=ex:gp1-frost] % \begin{forest} ~GP1~ [ % [O[x[f]][x[r]]] % [R[N[x[o]]][x[s]]] % [O[x[t]]] % [R[N[x]]] % ]\end{forest} % \end{forestexample} % Of course, someone needs to develop the style --- you, me, your % local \TeX nician \dots\@ Furtunately, designing styles is not very % difficult once you know your \foRest; options. If you write one, % please contribute! % % I have started a \href{https://github.com/sasozivanovic/forest-styles}{style repository} at % GitHub. Hopefully, it will grow \dots\@ Check it out, download the styles \dots\ and contribute % them! % % \subsection{Options} % \label{sec:options} % % A node can be given various options, which control various % properties of the node and the tree. For example, at the end of % section~\ref{sec:basic-usage}, we have seen that the \ikeyname{GP1} style % vertically aligns the parent with the first % child. This is achieved by setting option \ikeyname{calign} (for % \emph{c}hild-\emph{align}ment) to \ikeyname{first,aspect=calign} (child). % % Let's try. Options are given inside the brackets, following the % content, but separated from it by a comma. (If multiple options are % given, they are also separated by commas.) A single option % assignment takes the form \meta{option name}|=|\meta{option value}. (There are % also options which do not require a value or have a default value: % these are given simply as \meta{option name}.) % \begin{forestexample}[label=ex:numerals-simple,ekeynames={calign,{first,aspect=calign}}] % \begin{forest} % [\LaTeX\ numerals, ~calign=first~ % [arabic[1][2][3][4]] % [roman[i][ii][iii][iv]] % [alph[a][b][c][d]] % ] % \end{forest} % \end{forestexample} % % The experiment has succeeded only partially. The root node's % children are aligned as desired (so \ikeyname{calign}|=|\ikeyname{first,aspect=calign} applied to the % root node), but the value of the \ikeyname{calign} option didn't get % automatically assigned to the root's children! \emph{An option given % at some node applies only to that node.} In \foRest;, the options % are passed to the node's relatives via special options, called % \emph{propagators}. (We'll % call the options that actually change some property of the node % \emph{node options}.) What we need above is the \ikeyname{for tree} propagator. Observe: % \begin{forestexample}[label=ex:numerals-manual] % \begin{forest} % [\LaTeX\ numerals, % ~for tree~={calign=first} % [arabic[1][2][3][4]] % [roman[i][ii][iii][iv]] % [alph[a][b][c][d]] % ] % \end{forest} % \end{forestexample} % The value of propagator \ikeyname{for tree} is the option string that we % want to process. This option string is propagated to all the nodes in % the subtree\footnote{It might be more precise to call this option % \texttt{for subtree} \dots\@ but this name at least saves some typing.} % rooted in the current node (i.e.\ the node where \ikeyname{for tree} was % given), including the node itself. (Propagator \ikeyname{for descendants} is % just like \ikeyname{for tree}, only that it excludes the node itself. There % are many other \ikeyname{id={{for }}}|...| propagators; for the complete list, see % sections~\ref{ref:propagators} and \ref{ref:node-walk}.) % % Some other useful options are \ikeyname{parent anchor}, \ikeyname{child anchor} % and \ikeyname{tier}. The \ikeyname{parent anchor} and \ikeyname{child anchor} options tell % where the parent's and child's endpoint of the edge between them % should be, respectively: usually, the value is either empty % (meaning a smartly determined border point \citep[see][\S16.11]{tikzpgf2.10}; this is the default) % or a compass direction \citep[see][\S16.5.1]{tikzpgf2.10}. (Note: the \ikeyname{parent anchor} % determines where the % edge from the child will arrive to this node, not where the node's % edge to its parent will start!) % % Option \ikeyname{tier} is what makes the % skeletal points $\times$ in example \ref{ex:gp1-frost} align horizontally although they % occur at different levels in the logical structure of the tree. % Using option \ikeyname{tier} is very simple: just set |tier=tier_name| at % all the nodes that you want to align horizontally. Any tier name % will do, as long as the tier names of different tiers are % different \dots\@ (Yes, you can have multiple tiers!) % \begin{forestexample}[point={tier},ekeynames={parent anchor,child anchor,tier},label=ex:tier-manual] % \begin{forest} % [VP, for tree={~parent anchor~=south, ~child anchor~=north} % [DP[John,tier=word]] % [V' % [V[sent,tier=word]] % [DP[Mary,tier=word]] % [DP[D[a,tier=word]][NP[letter,tier=word]]] % ] % ] % \end{forest} % \end{forestexample} % Before discussing the variety of \foRest;'s options, it is worth % mentioning that \foRest;'s node accepts all options \citep[see % \S16]{tikzpgf2.10} that \TikZ;'s node does --- mostly, it just passes % them on to \TikZ;. For example, you can easily encircle a node like % this:\footnote{If option \texttt{draw} was not given, the shape of the node % would still be circular, but the edge would not be drawn. For % details, see \cite[\S16]{tikzpgf2.10}.} % \begin{forestexample} % \begin{forest} % [VP,~circle~,~draw~ % [DP][V'[V][DP]] % ] % \end{forest} % \end{forestexample} % % Let's have another look at example \ref{ex:gp1-frost}. You will note that the skeletal % positions were input by typing |x|s, while the result looks like % this: $\times$ (input as |\times| in math mode). Obviously, the % content of the node can be changed. Even more, it can be % manipulated: added to, doubled, boldened, emphasized, etc. We will % demonstrate this by making example \ref{ex:numerals-manual} a bit % fancier: we'll write the input in the arabic numbers and have % \LaTeX\ convert it to the other formats. We'll start with the % easiest case of roman numerals: to get them, we can use the (plain) % \TeX\ command |\romannumeral|. To change the content of the node, % we use option \ikeyname{content}. When specifying its new value, we can use % |#1| to insert the current content.\footnote{This mechanism is called % \emph{wrapping}. \ikeyname{content} is the only option where wrapping works implicitely (simply % because I assume that wrapping will be almost exclusively used with this option). To wrap values % of other options, use handler \ikeyname{id=.wrap value,nfc}; see~\S\ref{ref:handlers}.} % \begin{forestexample}[point={content,delay},ekeynames={for children,content,delay},label=ex:romannumeral] % \begin{forest} % [roman, delay={for children={content=\romannumeral#1}} % [1][2][3][4] % ] % \end{forest} % \end{forestexample} % This example introduces another option: \ikeyname{delay}. Without it, the % example wouldn't work: we would get arabic numerals. This is so % because of the order in which the options are processed. The % processing proceeds through the tree in a depth-first, parent-first fashion (first % the parent is processed, and then its children, recursively). The option string of a node is % processed linearly, in the order they were given. (Option \keyname{content} % is specified implicitely and is always the first.) If a propagator % is encountered, the options given as its value are propagated \emph{immediately}. The net effect % is that if the % above example contained simply |roman,for_children={content=...}|, the % \keyname{content} option given there would be processed \emph{before} the % implicit content options given to the children (i.e.\ numbers |1|, % |2|, |3| and |4|). Thus, there would be nothing for the % |\romannumeral| to change --- it would actually crash; more generally, the content assigned % in such a way would get overridden by the implicit content. Option % \ikeyname{delay} is true to its name. It delays the processing of its option % string argument until the whole tree was processed. In other words, % it introduces cyclical option processing. Whatever is delayed in % one cycle, gets processed in the next one. The number of cycles is % not limited --- you can nest \ikeyname{delay}s as deep as you need. % % Unlike \ikeyname{id={{for }}}|_...| options we have met before, option \ikeyname{delay} is not a % spatial, but a temporal propagator. Several other temporal propagators options exist, see % \S\ref{ref:stages}. % % We are now ready to learn about simple conditionals. Every node option has the corresponding % \ikeyname{id={{if }}}|...| and \ikeyname{id={{where }}}|...| keys. % \ikeyname{id={{if }}}\meta{option}|=|\meta{value}\meta{true options}\meta{false options} checks whether % the value of \meta{option} equals \meta{value}. If so, \meta{true options} are % processed, otherwise \meta{false options}. The \ikeyname{id={{where }}}|_...| keys are % the same, but do this for the every node in the subtree; informally % speaking, |where| = |for_tree| + |if|. To see this in action, % consider the rewrite of the \ikeyname{tier} example \ref{ex:tier-manual} from above. We don't set % the tiers manually, but rather put the terminal nodes (option % \ikeyname{n children} is a read-only option containing the number % of children) on tier \keyname{word}.\footnote{We could omit the braces around \texttt{0} because % it is a single character. If we were hunting for nodes with 42 children, we'd have to write % \texttt{where n children=\{42\}...}.} % \begin{forestexample}[ekeynames={tier,where ,n children}] % \begin{forest} % ~where n children~=0{tier=word}{} % [VP % [DP[John]] % [V' % [V[sent]] % [DP[Mary]] % [DP[D[a]][NP[letter]]] % ] % ] % \end{forest} % \end{forestexample} % % Finally, let's talk about styles. Styles are simply collections of % options. (They are not actually defined in the \foRest; package, but % rather inherited from |pgfkeys|.) If you often want to have non-default % parent/child anchors, say south/north as in example \ref{ex:tier-manual}, you would save some % typing by defining a style. Styles are defined using \PGF;'s handler % |.style|. (In the example below, style |ns_edges| is first defined and then used.) % \begin{forestexample}[ekeynames={tier,parent anchor,child anchor}] % \begin{forest} % ~sn edges~/~.style~={for tree={ % parent anchor=south, child anchor=north}}, % ~sn edges~ % [VP, % [DP[John,tier=word]] % [V' % [V[sent,tier=word]] % [DP[Mary,tier=word]] % [DP[D[a,tier=word]][NP[letter,tier=word]]]]] % \end{forest} % \end{forestexample} % If you want to use a style in more than one tree, you have to define it outside the \ikeyname{forest} % environment. Use macro \icmdname{forestset} to do this. % \begin{lstlisting} % ~\forestset~{ % sn edges/.style={for tree={parent anchor=south, child anchor=north}}, % background tree/.style={for tree={ % text opacity=0.2,draw opacity=0.2,edge={draw opacity=0.2}}} % } % \end{lstlisting} % % You might have noticed that the last two examples contain options (actually, keys) even before the % first opening bracket, contradicting was said at the beginning of this section. This is mainly % just syntactic sugar (it can separate the design and the content): such preamble % keys behave as if they were given in the root node, the only difference (which often does not % matter) being that they get processed before all other root node options, even the implicit % content. % % \subsection{Decorating the tree} % \label{sec:decorating} % % The tree can be decorated (think movement arrows) with arbitrary % \TikZ; code. % \begin{forestexample} % \begin{forest} % [XP % [specifier] % [X$'$ % [X$^0$] % [complement] % ] % ] % ~\node at (current bounding box.south) % [below=1ex,draw,cloud,aspect=6,cloud puffs=30] % {\emph{Figure 1: The X' template}};~ % \end{forest} % \end{forestexample} % % However, decorating the tree would make little sense if one could % not refer to the nodes. The simplest way to do so is to give them a % \TikZ; name using the \ikeyname{name} option, and then use this name in \TikZ; % code as any other (\TikZ;) node name. % \begin{forestexample}[point=name,ekeynames={phantom,name}] % \begin{forest} % [CP % [DP,name=spec CP] % [\dots % [,phantom] % [VP % [DP] % [V' % [V] % [DP,name=object]]]]] % \draw[->,dotted] ~(object)~ to[out=south west,in=south] ~(spec CP)~; % \end{forest} % \end{forestexample} % % It gets better than this, however! In the previous examples, we put % the \TikZ; code after the tree specification, i.e.\ after the closing % bracket of the root node. In fact, you can put \TikZ; code after % \emph{any} closing bracket, and \foRest; will know what the current % node is. (Putting the code after a node's bracket is actually just a % special way to provide a value for option \ikeyname{tikz} of that node.) To % refer to the current node, simply use an empty node name. This works both with and without % anchors \citep[see][\S16.11]{tikzpgf2.10}: below, |(.south east)| and |()|. % \begin{forestexample}[ekeynames={phantom,name}] % \begin{forest} % [CP % [DP,name=spec CP] % [\dots % [,phantom] % [VP % [DP] % [V' % [V] % [DP,draw] ~{~ % \draw[->,dotted] ~()~ to[out=south west,in=south] (spec CP); % \draw[<-,red] ~(.south east)~--++(0em,-4ex)--++(-2em,0pt) % node[anchor=east,align=center]{This guy\\has moved!}; % ~}~ % ]]]] % \end{forest} % \end{forestexample} % % Important: \emph{the \TikZ; code should usually be enclosed in braces} to hide % it from the bracket parser. You don't want all the bracketed code % (e.g.\ |[->,dotted]|) to become tree nodes, right? (Well, they % probably wouldn't anyway, because \TeX\ would spit out a thousand % errors.) % % \bigskip % % Finally, the most powerful tool in the node reference toolbox: % \emph{relative nodes}. It is possible to refer to other nodes which stand % in some (most often geometrical) relation to the current node. To % do this, follow the node's name with a |!| and a \emph{node walk} % specification. % % A node walk is a concise\footnote{Actually, \foRest; distinguishes two kinds of % steps in node walks: long and short steps. This section introduces only short steps. See % \S\ref{ref:node-walk}.} way of expressing node % relations. It is simply a string of steps, which are represented by single % characters, where: \ikeyname{u} stands for the parent node (up); \ikeyname{p} for the % previous sibling; \ikeyname{n,aspect=short step} for the next sibling; \ikeyname{s,aspect=short step} for \emph{the} % sibling (useful only in binary trees);\ekeyname{3} \ikeyname{1}, \ikeyname{2}, % \ekeyname{3}\ekeyname{4}\ekeyname{5}\ekeyname{6}\ekeyname{7}\ekeyname{8}\dots\ % \ikeyname{9} for first, % second, \dots\ ninth child; \ikeyname{l,aspect=short step}, for the last child, etc. For the % complete specification, see section~\ref{ref:node-walk}. % % To see the node walk in action, consider the following examples. % In the first example, the agree arrow connects the V node, specified % simply as |()|, since the \TikZ; code follows |[V]|, and the DP node, % which is described as ``a sister of V's parent'': |!us| = up + % sibling. % \begin{forestexample} % \begin{forest} % [VP % [DP] % [V' % [V] {\draw[<->] ~()~ % .. controls +(left:1cm) and +(south west:0.4cm) .. % node[very near start,below,sloped]{\tiny agree} % ~(!us)~;} % [DP] % ] % ] % \end{forest} % \end{forestexample} % % {\footnotesize\begin{forestexample}[ekeynames={phantom,tikz,fit to tree},samplebox=\treebox,codebox=\codebox,pos=x,basicstyle=\footnotesize\ttfamily] % \begin{forest} % [CP % [DP$_1$] % [\dots % [,phantom] % [VP,tikz={\node [draw,red,~fit to tree~]{};} % [DP$_2$] % [V' % [V] % [DP$_3$] % ]]]] % \end{forest} % \end{forestexample}} % The second example uses \TikZ;'s fitting library to compute the % smallest rectangle containing node VP, its first child (DP$_2$) and its last grandchild (DP$_3$). % The example also illustrates that the \TikZ; code % can be specified via the ``normal'' option syntax, i.e.\ as a value % to option \ikeyname{tikz}.\footnote{\label{fn:fit-to-tree}Actually, there's a simpler way to do this: use \ikeyname{fit to tree}!\\\raisebox{\dimexpr-\dp\codebox+1ex\relax}{\box\treebox}\hfill\box\codebox} % \begin{forestexample}[point=tikz,ekeynames={phantom,tikz}] % \begin{forest} % [CP % [DP$_1$] % [\dots % [,phantom] % [VP,tikz={\node [draw,red,fit=~()(!1)(!ll)~] {};} % [DP$_2$] % [V' % [V] % [DP$_3$] % ]]]] % \end{forest} % \end{forestexample} % % % \subsection{Node positioning} % \label{sec:node-positioning} % % \FoRest; positions the nodes by a recursive bottom-up algorithm which, for every non-terminal node, % computes the positions of the node's children relative to their parent. By default, all the % children will be aligned horizontally some distance down from their parent: the ``normal'' tree % grows down. More generally, however, the direction of growth can change from node to node; this is % controlled by option \ikeyname{grow}=\meta{direction}.\footnote{The direction can be specified either in % degrees (following the standard mathematical convention that $0$ degrees is to the right, and that % degrees increase counter-clockwise) or by the compass directions: \texttt{east}, \texttt{north east}, % \texttt{north}, etc.} The system thus computes and stores the positions of children using a % coordinate system dependent on the parent, called an \emph{ls-coordinate system}: the origin is the % parent's anchor; l-axis is in the direction of growth in the parent; s-axis is orthogonal to the % l-axis (positive side in the counter-clockwise direction from $l$-axis); l stands for \emph{l}evel, % s for \emph{s}ibling. The example shows the ls-coordinate system for a node with |grow=45|. % % \begin{forestexample}[point=grow,ekeynames=grow] % \begin{forest} background tree % [parent, grow=45 % [child 1][child 2][child 3][child 4][child 5] % ] % \draw[,->](-135:1cm)--(45:3cm) node[below]{$l$}; % \draw[,->](-45:1cm)--(135:3cm) node[right]{$s$}; % \end{forest} % \end{forestexample} % % \begin{forestexample}[basicstyle=\scriptsize\ttfamily,samplebox=\treebox,codebox=\codebox,pos=x] % \newcommand\measurexdistance[5][####1]{\measurexorydistance{#2}{#3}{#4}{#5}{\x}{-|}{(5pt,0)}{#1}} % \newcommand\measureydistance[5][####1]{\measurexorydistance{#2}{#3}{#4}{#5}{\y}{|-}{(0,5pt)}{#1}} % \tikzset{dimension/.style={<->,>=latex,thin,every rectangle node/.style={midway,font=\scriptsize}}, % guideline/.style=dotted} % \newdimen\absmd % \def\measurexorydistance#1#2#3#4#5#6#7#8{% % \path #1 #3 #6 coordinate(md1) #1; \draw[guideline] #1 -- (md1); % \path (md1) #6 coordinate(md2) #2; \draw[guideline] #2 -- (md2); % \path let \p1=($(md1)-(md2)$), \n1={abs(#51)} in \pgfextra{\xdef\md{#51}\global\absmd=\n1\relax}; % \def\distancelabelwrapper##1{#8}% % \ifdim\absmd>5mm % \draw[dimension] (md1)--(md2) node[#4]{\distancelabelwrapper{\uselengthunit{mm}\rndprintlength\absmd}}; % \else % \ifdim\md>0pt % \draw[dimension,<-] (md1)--+#7; \draw[dimension,<-] let \p1=($(0,0)-#7$) in (md2)--+(\p1); % \else % \draw[dimension,<-] let \p1=($(0,0)-#7$) in (md1)--+(\p1); \draw[dimension,<-] (md2)--+#7; % \fi % \draw[dimension,-] (md1)--(md2) node[#4]{\distancelabelwrapper{\uselengthunit{mm}\rndprintlength\absmd}}; % \fi} % \end{forestexample} % \input{\jobname.tmp} % % The l-coordinate of children is (almost) completely under your control, i.e.\ you set what is % often called the level distance by yourself. Simply set option \ikeyname{l} to change the % distance of a node from its parent. More precisely, \ikeyname{l}, and the related option % \ikeyname{s}, control the distance between the (node) anchors of a node and its parent. The % anchor of a node can be changed using option \ikeyname{anchor}: by default, nodes are anchored at % their base; see \cite[\S16.5.1]{tikzpgf2.10}.) In the example below, positions of the anchors are % shown by dots: observe that anchors of nodes with the same \ikeyname{l} are aligned and that the % distances between the anchors of the children and the parent are as specified in the % code.\footnote{Here are the definitons of the macros for measuring distances. Args: the x or y % distance between points \#2 and \#3 is measured; \#4 is where the distance line starts (given as an % absolute coordinate or an offset to \#2); \#5 are node options; the optional arg \#1 is the format of % label. (Lengths are printed using package \texttt{printlen}.) % % \vskip-2ex \box\codebox} % \begin{forestexample}[pos=t,ekeynames={for tree,tikz,l,anchor}] % \begin{forest} background tree, % for tree={draw,tikz={\fill[](.anchor)circle[radius=1pt];}} % [parent % [child 1, ~l~=10mm, ~anchor~=north west] % [child 2, ~l~=10mm, ~anchor~=south west] % [child 3, ~l~=12mm, ~anchor~=south] % [child 4, ~l~=12mm, ~anchor~=base east] % ] % \measureydistance[\texttt{l(child)}=#1]{(!2.anchor)}{(.anchor)}{(!1.anchor)+(-5mm,0)}{left} % \measureydistance[\texttt{l(child)}=#1]{(!3.anchor)}{(.anchor)}{(!4.anchor)+(5mm,0)}{right} % \measurexdistance[\texttt{s sep(parent)}=#1]{(!1.south east)}{(!2.south west)}{+(0,-5mm)}{below} % \measurexdistance[\texttt{s sep(parent)}=#1]{(!2.south east)}{(!3.south west)}{+(0,-5mm)}{below} % \measurexdistance[\texttt{s sep(parent)}=#1]{(!3.south east)}{(!4.south west)}{+(0,-8mm)}{below} % \end{forest} % \end{forestexample} % % Positioning the chilren in the s-dimension is the job and \emph{raison d'etre} of the package. As a % first approximation: the children are positioned so that the distance between them is at least the % value of option \ikeyname{s sep} (s-separation), which defaults to double \PGF;'s |inner_xsep| (and this % is 0.3333em by default). As you can see from the example above, s-separation is the distance % between the borders of the nodes, not their anchors! % % A fuller story is that \ikeyname{s sep} does not control the s-distance between two siblings, but rather % the distance between the subtrees rooted in the siblings. When the green and the yellow child of % the white node are s-positioned in the example below, the horizontal % distance between the green and the yellow subtree is computed. It can be seen with the naked eye % that the closest nodes of the subtrees are the TP and the DP with a red border. Thus, the children % of the root CP (top green DP and top yellow TP) are positioned so that the horizontal distance % between the red-bordered TP and DP equals \ikeyname{s sep}. % \begin{forestexample}[ekeynames={for tree,s sep}] % \begin{forest} % important/.style={name=#1,draw={red,thick}} % [CP, ~s sep~=3mm, for tree=draw % [DP, for tree={fill=green} % [D][NP[N][CP[C][TP,important=left % [T][vP[v][VP[DP][V'[V][DP]]]]]]]] % [TP,for tree={fill=yellow} % [T][vP[v][VP[DP,important=right][V'[V][DP]]]]] % ] % \measurexdistance[\texttt{s sep(root)}=#1] % {(left.north east)}{(right.north west)}{(.north)+(0,3mm)}{above} % \end{forest} % \end{forestexample} % % Note that \foRest; computes the same distances between nodes % regardless of whether the nodes are filled or not, or whether their % border is drawn or not. Filling the node or drawing its border does % not change its size. You can change the size by adjusting \TikZ;'s % |inner_sep| and |outer_sep| \citep[\S16.2.2]{tikzpgf2.10}, as shown % below: % \begin{forestexample}[ekeynames={for tree,s sep}] % \begin{forest} % important/.style={name=#1,draw={red,thick}} % [CP, s sep=3mm, for tree=draw % [DP, for tree={fill=green,~inner sep~=0} % [D][NP,important=left[N][CP[C][TP[T][vP[v] % [VP[DP][V'[V][DP]]]]]]]] % [TP,for tree={fill=yellow,~outer sep~=2pt} % [T,important=right][vP[v][VP[DP][V'[V][DP]]]]] % ] % \measurexdistance[\texttt{s sep(root)}=#1] % {(left.north east)}{(right.north west)}{(.north)+(0,3mm)}{above} % \end{forest} % \end{forestexample} % (This looks ugly!) Observe that having increased |outer sep| makes the edges stop touching % borders of the nodes. By (\PGF;'s) default, the |outer sep| is exactly half of the border % line width, so that the edges start and finish precisely at the border. % % Let's play a bit and change the \ikeyname{l} of the root of the yellow subtree. Below, we set the % vertical % distance of the yellow TP to its parent to 3\,cm: and the yellow submarine sinks diagonally \dots\@ % Now, the closest nodes are the higher yellow DP and the green VP. % \begin{forestexample}[ekeynames={l,s sep,for tree}] % \begin{forest} % important/.style={name=#1,draw={red,thick}} % [CP, s sep=3mm, for tree=draw % [DP, for tree={fill=green} % [D][NP[N][CP[C][TP % [T][vP[v][VP,important=left[DP][V'[V][DP]]]]]]]] % [TP,for tree={fill=yellow}, l=3cm % [T][vP[v][VP[DP,important=right][V'[V][DP]]]]] % ] % \measurexdistance[\texttt{s sep(root)}=#1] % {(left.north east)}{(right.north west)}{(.north)+(0,3mm)}{above} % \end{forest} % \end{forestexample} % % Note that the yellow and green nodes are not vertically aligned anymore. The positioning algorithm % has no problem with that. But you, as a user, might have, so here's a neat trick. (This only works % in the ``normal'' circumstances, which are easier to see than describe.) % \begin{forestexample}[label=ex:l*,ekeynames={l,*,phantom,for tree}] % \begin{forest} % [CP, for tree=draw % [DP, for tree={fill=green},~l*~=3 % [D][NP]] % [TP,for tree={fill=yellow} % [T][VP[DP][V'[V][DP]]]] % ] % \end{forest} % \end{forestexample} % We have changed DP's \ikeyname{l}'s value via ``augmented assignment'' known from % many programming languages: above, we have used |l*=3| to triple % \ekeyname{l}'s value; we could have also said |l+=5mm| or |l-=5mm| to % increase or decrease its value by 5\,mm, respectively. This % mechanism works for every numeric and dimensional option in \foRest;. % % Let's now play with option \ikeyname{s sep}. % \begin{forestexample}[ekeynames={s sep,l,*,for tree}] % \begin{forest} % [CP, for tree=draw, ~s sep~=0 % [DP, for tree={fill=green},l*=3 % [D][NP]] % [TP,for tree={fill=yellow} % [T][VP[DP][V'[V][DP]]]] % ] % \end{forest} % \end{forestexample} % Surprised? You shouldn't be. The value of \ikeyname{s sep} at a given node controls the s-distance % \emph{between the subtrees rooted in the children of that node}! It has no influence over the % internal geometry of these subtrees. In the above example, we have set |s_sep=0| only for the root % node, so the green and the yellow subtree are touching, although internally, their nodes are not. % Let's play a bit more. In the following example, we set the \ikeyname{s sep} to: $0$ at the last % branching level (level 3; the root is level 0), to 2\,mm at level 2, to 4\,mm at level 1 and to % 6\,mm at level 0. % % \begin{forestexample}[label=ex:spread-s,point={level},ekeynames={level,for tree,s sep}] % \begin{forest} % for tree={~s sep~=(3-level)*2mm} % [CP, for tree=draw % [DP, for tree={fill=green},l*=3 % [D][NP]] % [TP,for tree={fill=yellow} % [T][VP[DP][V'[V][DP]]]] % ] % \measurexdistance{(!11.south east)}{(!12.south west)}{+(0,-5mm)}{below} % \path(md2)-|coordinate(md)(!221.south east); % \measurexdistance{(!221.south east)}{(!222.south west)}{(md)}{below} % \measurexdistance{(!21.north east)}{(!22.north west)}{+(0,2cm)}{above} % \measurexdistance{(!1.north east)}{(!221.north west)}{+(0,-2.4cm)}{below} % \end{forest} % \end{forestexample} % As we go up the tree, the nodes ``spread.'' At the lowest level, V and DP are touching. In the % third level, the \ikeyname{s sep} of level 2 applies, so DP and V' are 2\,mm apart. At the second % level we % have two pairs of nodes, D and NP, and T and TP: they are 4\,mm apart. Finally, at level 1, the % \ikeyname{s sep} of level 0 applies, so the green and yellow DP are 6\,mm apart. (Note that D and NP are % at level 2, not 4! Level is a matter of structure, not geometry.) % % As you have probably noticed, this example also demostrated that we can compute the value of an % option using an (arbitrarily complex) formula. This is thanks to \PGF;'s module |pgfmath|. % \FoRest; provides an interface to |pgfmath| by defining |pgfmath| functions for every node option, % and some other information, like the \ikeyname{level} we have used above, the number of children % \ikeyname{n children}, the sequential number of the child \ikeyname{n}, etc. For details, see % \S\ref{ref:pgfmath}. % % The final separation parameter is \ikeyname{l sep}. It determines the minimal % separation of a % node from its descendants. It the value of \ikeyname{l} is too small, then \emph{all} the % children (and thus their subtrees) % are pushed % away from the parent (by increasing their \ikeyname{l}s), so that the distance between the node's % and each child's subtree % boundary is at least \ikeyname{l sep}. The initial \ikeyname{l} can be too small for % two reasons: either % some child is too high, or the parent is too deep. The first problem is easier to see: we force the % situation using a bottom-aligned multiline node. (Multiline nodes can be easily created using |\\| % as a line-separator. However, you must first specify the horizontal alignment using option % \ikeyname{align} (see \S\ref{ref:node-appearance}). % Bottom vertical alignment is achieved by setting \ikeyname{base}|=|\ikeyname{bottom,aspect=base}; % the default, unlike in \TikZ;, is \ikeyname{base}|=|\ikeyname{top,aspect=base}). % \begin{forestexample}[point={align,base},ekeynames={align,base}] % \begin{forest} % [parent % [child] % [child] % [a very\\tall\\child, align=center, base=bottom] % ] % \end{forest} % \end{forestexample} % % The defaults for \ikeyname{l} and \ikeyname{l sep} are set so that they ``cooperate.'' % What this % means and why it is necessary is a complex issue explained in \S\ref{sec:defaults}, which you will % hopefully never have to read \dots\@ You might be out of luck, however. What if you % needed to decrease the level distance? And nothing happened, like below on the left? Or, what if % you used lots of parenthesis in your nodes? And got a strange vertical misalignment, like below % on the right? Then rest assured that these (at least) are features not bugs and read % \S\ref{sec:defaults}. % \begin{forestexample}[pos=t,label=ex:misalignments,ekeynames={phantom,for children,fit,for,baseline,edge,for descendants,content,{id=.pgfmath,nfc}}] % \begin{forest} % [,phantom,for children={l sep=1ex,fit=band, % for=1{edge'=,l=0},baseline} % [{l+=5mm},for descendants/.pgfmath=content % [AdjP[AdvP][Adj'[Adj][PP]]]] % [default % [AdjP[AdvP][Adj'[Adj][PP]]]] % [{l-=5mm},for descendants/.pgfmath=content % [AdjP[AdvP][Adj'[Adj][PP]]]] % ] % \path (current bounding box.west)|-coordinate(l1)(!212.base); % \path (current bounding box.west)|-coordinate(l2)(!2121.base); % \path (current bounding box.east)|-coordinate(r1)(!212.base); % \path (current bounding box.east)|-coordinate(r2)(!2121.base); % \draw[dotted] (l1)--(r1) (l2)--(r2); % \end{forest} % \hspace{4cm} % \raisebox{0pt}[\height][0pt]{\begin{forest} % [x forest, baseline % [x[x[x[x[x[x[x[x[x[x[x[x[x]]]]]]]]]]]]] % [(x)[(x)[(x)[(x)[(x)[(x)[(x)[(x)[(x)[(x)[(x)[(x)[(x)]]]]]]]]]]]]] % ] % \end{forest}} % \end{forestexample} % % \subsubsection{The defaults, or the hairy details of vertical alignment} % \label{sec:defaults} % % In this section we discuss the default values of options controlling the l-alignment of the nodes. % The defaults are set with top-down trees in mind, so l-alignment is actually vertical alignment. % There are two desired effects of the defaults. First, the spacing between the nodes of a tree % should adjust to the current font size. Second, the nodes of a given level should be vertically % aligned (at the base), if possible. % % Let us start with the base alignment: \TikZ;'s default is to anchor the nodes at their center, % while \foRest;, given the usual content of nodes in linguistic representations, rather anchors them % at the base \cite[\S16.5.1]{tikzpgf2.10}. The difference is particularly clear for a ``phonological'' % representation: % \begin{forestexample}[ekeynames={for tree,anchor}] % \begin{forest} for tree={anchor=center} % [maybe[m][a][y][b][e]] % \end{forest}\quad % \begin{forest} % [maybe[m][a][y][b][e]] % \end{forest} % \end{forestexample} % The following example shows that the vertical distance between nodes depends on the current font size. % \begin{forestexample} % \hbox{\small A small tree % \begin{forest} baseline % [VP[DP][V'[V][DP]]] % \end{forest} % \normalsize and % \large % a large tree % \begin{forest} baseline % [VP[DP][V'[V][DP]]] % \end{forest}} % \end{forestexample} % Furthermore, the distance between nodes also depends on the value of \PGF;'s |inner_sep| (which % also depends on the font size by default: it equals 0.3333\,em). % \[\ikeyname{l sep}=\mbox{height}(\mbox{strut})+\mbox{\texttt{inner ysep}}\] % The default value of \ikeyname{s sep} depends on |inner_xsep|: more precisely, it equals double % |inner_xsep|). % \begin{forestexample}[ekeynames={baseline,for tree}] % \begin{forest} baseline,for tree=draw % [VP[DP][V'[V][DP]]] % \end{forest} % \pgfkeys{/pgf/inner sep=0.6666em} % \begin{forest} baseline,for tree=draw % [VP[DP][V'[V][DP]]] % \end{forest} % \end{forestexample} % Now a hairy detail: the formula for the default \ikeyname{l}. % \[\ikeyname{l}=\ikeyname{l sep}+2\cdot\mbox{\texttt{outer ysep}}+\mbox{total % height}(\mbox{`dj'})\] % % To understand what this is all about we must first explain why it is necessary to set the default % \ikeyname{l} at all? Wouldn't it be enough to simply set \ikeyname{l sep} (leaving % \ikeyname{l} at 0)? % The problem is that not all letters have the same height and depth. A tree where the vertical % position of the nodes would be controlled solely by (a constant) \ikeyname{l sep} could % result in a ragged tree (although the height of the child--parent edges would be constant). % \begin{forestexample}[ekeynames={baseline,for children,no edge,name,for descendants,l}] % \begin{forest} % [default,baseline,for children={no edge} % [DP % [AdjP[Adj]] % [D'[D][NP,name=np]]]] % \path (current bounding box.west)|-coordinate(l)(np.base); % \path (current bounding box.east)|-coordinate(r)(np.base); % \draw[dotted] (l)--(r); % \end{forest} % \begin{forest} % [{l=0},baseline,for children={no edge} % [DP,for descendants={l=0} % [AdjP[Adj]] % [D'[D][NP,name=np]]]] % \path (current bounding box.west)|-coordinate(l)(np.base); % \path (current bounding box.east)|-coordinate(r)(np.base); % \draw[dotted] (l)--(r); % \end{forest} % \end{forestexample} % The vertical misalignment of Adj in the right tree is a consequence of the fact that letter j is the % only letter with non-zero depth in the tree. Since only \ikeyname{l sep} (which is constant % throughout the tree) controls the vertical positioning, Adj, child of Ad\emph{j}P, is pushed lower % than the other nodes on level 2. If the content of the nodes is variable enough (various heights % and depths), the cumulative effect can be quite strong, see the right tree of example % \ref{ex:misalignments}. % % Setting only a default \ikeyname{l sep} thus does not work well enough in general. The same % is true for the reverse possibility, setting a default \ikeyname{l} (and leaving \ikeyname{l sep} at 0). In the example below, the depth of the multiline node (anchored at the top % line) is such that the child--parent edges are just too short if the level distance is kept constant. % Sometimes, misalignment is much preferred \dots % \begin{forestexample}[ekeynames={align,{center,aspect=align},for tree,l sep}] % \mbox{}\begin{forest} % [default % [first child[a][b][c]] % [second child\\\scriptsize(a copy), % align=center[a][b][c]] % ] % \end{forest}\\ % \begin{forest} for tree={l sep=0} % [{\texttt{l sep}=0} % [first child[a][b][c]] % [second child\\\scriptsize(a copy), % align=center[a][b][c]] % ] % \end{forest} % \end{forestexample} % % Thus, the idea is to make \ikeyname{l} and \ikeyname{l sep} work as a team: % \ikeyname{l} prevents % misalignments, if possible, while \ikeyname{l sep} determines the minimal vertical distance % between levels. Each of the two options deals with a certain kind of a ``deviant'' node, i.e.\ a % node which is too high or too deep, or a node which is not high or deep enough, so we need to % postulate what a \emph{standard} node is, and synchronize them so that their effect on standard % nodes is the same. % % By default, \foRest; sets the standard node to be a node containing letters d and j. Linguistic % representations consist mainly of letters, and in the \TeX's default Computer Modern font, d is the % highest letter (not character!), and j the deepest, so this decision guarantees that trees % containing only letters will look nice. If the tree contains many parentheses, like the right % tree of example \ref{ex:misalignments}, the default will of course fail % and the standard node needs to be modified. But for many applications, including nodes with % indices, the default works. % % The standard node can be changed using macro \icmdname{forestStandardNode}; % see \ref{ref:standard-node}. % % \subsection{Advanced option setting} % \label{sec:advanced-option-setting} % % We have already seen that the value of options can be manipulated: in \ref{ex:romannumeral} we have % converted numeric content from arabic into roman numerals using the \emph{wrapping} mechanism % |content=\romannumeral#1|; in \ref{ex:l*}, we have tripled the value of |l| % by saying |l*=3|. In this section, we will learn about the mechanisms for setting and % referring to option values offered by \foRest;. % % One other way to access an option value is using macro \icmdname{forestoption}. The macro takes a % single argument: an option name. (For details, see \S\ref{ref:options-and-keys}.) In the % following example, the node's child sequence number is appended to the existing content. (This is % therefore also an example of wrapping.) % \begin{forestexample}[label=ex:forestoption,ekeynames={phantom,delay,for descendants,content,n},ecmdnames={forestoption}] % \begin{forest} % [,phantom,delay={for descendants={ % content=#1$_{~\forestoption~{n}}$}} % [c][o][u][n][t]] % \end{forest} % \end{forestexample} % % However, only options of the current node can be accessed using \icmdname{forestoption}. To % access option values of other nodes, \foRest;'s extensions to the \PGF;'s mathematical library % |pgfmath|, documented in \citep[part VI]{tikzpgf2.10}, must be used. To see |pgfmath| in action, % first take a look at the crazy tree on the title page, and observe how the nodes are % rotated: the value given to (\TikZ;) option \texttt{rotate} is a full-fledged |pgfmath| expression % yielding an integer % in the range from $-30$ to $30$. Similiarly, \ikeyname{l}\ikeyname{+} adds a random float % in the $[-5,5]$ range to the current value of \ikeyname{l}. % % Example \ref{ex:spread-s} demonstrated that information about % the node, like the node's level, can be accessed within |pgfmath| expressions. All % options are accessible in this way, i.e.\ every option has a corresponding |pgfmath| function. % For example, we could rotate the node based on its content: % \begin{forestexample}[ekeynames={delay,for tree,rotate,content}] % \begin{forest} % delay={for tree={~rotate=content~}} % [30[-10[5][0]][-90[180]][90[-60][90]]] % \end{forest} % \end{forestexample} % % All numeric, dimensional and boolean options of \foRest; automatically pass the given value % through |pgfmath|. If you need pass the value through |pgfmath| % for a string option, use the \ikeyname{id=.pgfmath,nfc} handler. The following example sets the node's % content to its child sequence number (the root has child sequence number 0). % \begin{forestexample}[ekeynames={delay,for tree,content,n,{id=.pgfmath,nfc}}] % \begin{forest} % delay={for tree={content/~.pgfmath~=int(n)}} % [[[][][]][[][]]] % \end{forest} % \end{forestexample} % % As mentioned above, using |pgfmath| it is possible to access options of non-current nodes. This % is achieved by providing the option function with a \imeta{relative node name} % (see~\S\ref{ref:relative-node-names}) argument.\footnote{The form without % parentheses \texttt{option\string_name} that we have been using until now to refer to an option of % the % current node is just a short-hand notation for \texttt{option\string_name()} --- note that in some % contexts, like preceding \texttt{+} or \texttt{-}, the short form does not work! (The same % seems to be true for all pgfmath functions with ``optional'' arguments.)} In the next example, we % rotate the node based on the content of its parent. % \begin{forestexample}[ekeynames={delay,for tree,rotate,content,u}] % \begin{forest} % delay={for descendants={rotate=content~("!u")~}} % [30[-10[5][0]][-90[180]][90[-60][90]]] % \end{forest} % \end{forestexample} % Note that the argument of the option function is surrounded by double quotation marks: this is % to prevent evaluation of the relative node name as a |pgfmath| function --- which it is not. % % Handlers \ikeyname{id=.wrap pgfmath arg,nfc} and \ikeyname{id=.wrap $n$ pgfmath args,nfc} % (for $n=2,\dots,8$) combine the wrapping mechanism with the |pgfmath| evaluation. The % idea is to compute (most often, just access option values) arguments using |pgfmath| and then % wrap them with the given macro. Below, this is used to include the number of parent's children in % the index. % \begin{forestexample}[ekeynames={phantom,delay,for descendants,content,n,n children,{id=.wrap 3 pgfmath args,nfc}}] % \begin{forest} [,phantom,delay={for descendants={ % ~content/.wrap 3 pgfmath args= % {#1$_{#2/#3}$}{content}{n}{n_children("!u")}~}} % [c][o][u][n][t]] % \end{forest} % \end{forestexample} % Note the underscore |__| character in |n__children|: in |pgfmath| function names, spaces, % apostrophes and other non-alphanumeric characters from option names are all replaced by % underscores. % % As another example, let's make the numerals example \ref{ex:numerals-simple} a bit fancier. % The numeral type is read off the parent's content and used to construct the appropriate control % sequence (|\@arabic|, |\@roman| and |\@alph|). (Also, the numbers are not specified in content % anymore: we simply read the sequence number \ikeyname{n}. And, to save some horizontal space for the % code, each child of the root is pushed further down.) % \begin{forestexample}[ekeynames={delay,where ,level,content,n,for children,l,{id=.wrap 2 pgfmath args,nfc}}] % \begin{forest} % delay={where level={2}{~content/.wrap 2 pgfmath args= % {\csname @#1\endcsname{#2}}{content("!u")}{n}~}{}}, % for children={l*=n}, % [\LaTeX numerals, % [arabic[][][][]] % [roman[][][][]] % [alph[][][][]] % ] % \end{forest} % \end{forestexample} % % The final way to use |pgfmath| expressions in \foRest;: \ikeyname{if} clauses. In % section~\ref{sec:options}, we have seen that every option has a corresponding \ikeyname{id={{if }}}|...| % (and \ikeyname{id={{where }}}|...|) option. However, these are just a matter of convenience. The full % power resides % in the general \ikeyname{if} option, which takes three arguments: % |if=|\meta{condition}\meta{true options}\meta{false options}, where \meta{condition} can be any % |pgfmath| expression % (non-zero means true, zero means false). (Once again, option \ikeyname{where} is an abbreviation % for \ikeyname{for tree}|={|\ikeyname{if}|=...}|.) In the following example, \ikeyname{if} option % is used to orient the % arrows from the smaller number to the greater, and to color the odd and even numbers differently. % % \forestset{random tree/.style n args={3}{^^A #1=max levels, #2=max children, #3=max content % content/.pgfmath={random(0,#3)}, % if={#1>0}{repeat={random(0,#2)}{append={[,random tree={#1-1}{#2}{#3}]}}}{}}} % \begin{forestexample}[ekeynames={before typesetting nodes,for descendants,if,content,edge,edge label,for tree,if},point=if] % \pgfmathsetseed{314159} % \begin{forest} % before typesetting nodes={ % for descendants={ % if={content()>content("!u")}{edge=->}{ % if={content()] () to[out=south west,in=south] (#1);}, % delay={~#1.content~={##1},content=$t$}}, % [CP[][C'[C][\dots[,phantom][VP[DP][V'[V][DP,move=!r1]]]]]] % \end{forest} % \end{forestexample} % % In the following example, the content of the branching nodes is computed by \foRest;: a branching % node is a sum of its % children. Besides the use of the relative node setting, this example notably uses a recursive % style: for each child of the node, style \keyname{calc} first applies itself to the child and then % adds the result to the node; obviously, recursion is made to stop at terminal nodes. % \begin{forestexample}[ekeynames={id={{if }},n children,content,for children,delay,{id=.pgfmath,nfc}}] % \begin{forest} % calc/.style={if n children={0}{}{content=0,for children={ % calc,~!u.content~/.pgfmath=int(content("!u")+content())}}}, % delay=calc, % [[[3][4][5]][[3][9]][8][[[1][2][3]]]] % \end{forest} % \end{forestexample} % % % \subsection{Externalization} % \label{tut:externalization} % % \FoRest; can be quite slow, due to the slowness of both \PGF;/\TikZ; and its own computations. % However, using \emph{externalization}, the amount of time spent in \foRest; in everyday life can % be reduced dramatically. The idea is to typeset the trees only once, saving them in separate % PDFs, and then, on the subsequent compilations of the document, simply include these PDFs instead % of doing the lenghty tree-typesetting all over again. % % \FoRest;'s externalization mechanism is built on top of \TikZ;'s |external| library. It % enhances it by automatically detecting the code and context changes: the tree is recompiled if and % only if either the code in the \ikeyname{forest} environment or the context (arbitrary parameters; by % default, the parameters of the standard node) changes. % % To use \foRest;'s externalization facilities, say:\footnote{When you switch on % the externalization for a document containing many \keyname{forest} environments, the first % compilation can take quite a while, much more than the compilation without externalization. (For % example, more than ten minutes for the document you are reading!) Subsequent compilations, % however, will be very fast.}\ekeyname{external} % \begin{lstlisting}[point=external] % \usepackage[external]{forest} % ~\tikzexternalize~ % \end{lstlisting} % % If your \ikeyname{forest} environment contains some macro, you will probably want the externalized % tree to be recompiled when the definition of the macro changes. To achieve this, use % \icmdname{forestset}|{|\ikeyname{id={external/depends on macro}}|=|\cmdname{macro}|}|. The effect is % local to the \TeX\ group. % % \TikZ;'s externalization library promises a |\label| inside the externalized graphics to work % out-of-box, while |\ref| inside the externalized graphics should work only if the externalization % is run manually or by |make| \citep[\S32.4.1]{tikzpgf2.10}. A bit surprisingly perhaps, the % situation is roughly reversed in \foRest;. |\ref| inside the externalized graphics will work % out-of-box. |\label| inside the externalized graphics will not work at all. Sorry. (The reason % is that \foRest; prepares the node content in advance, before merging it in the whole tree, which % is when \TikZ;'s externalization is used.) % % \subsection{Expansion control in the bracket parser} % \label{tut:bracket} % % By default, macros in the bracket encoding of a tree are not % expanded until nodes are being drawn --- this way, node % specification can contain formatting instructions, as illustrated in % section~\ref{sec:basic-usage}. However, sometimes it is useful to % expand macros while parsing the bracket representation, for example to % define tree templates such as the X-bar template, familiar % to generative grammarians:\footnote{Honestly, dynamic node creation might be a better way to do % this; see~\S\ref{ref:dynamic}.} % \begin{forestexample}[ecmdnames=bracketset,ekeynames={action character}] % ~\bracketset{action character=@}~ % \def\XP#1#2#3{#1P[#2][#1'[#1][#3]]} % \begin{forest} % [~@~\XP T{DP}{~@~\XP V{DP}{DP}}] % \end{forest} % \end{forestexample} % In the above example, the |\XP| macro is preceded by the \emph{action character} |@|: as % the result, the token following the action character was expanded before the parsing proceeded. % % The action character is not hard coded into \foRest;. Actually, there is no action character by % default. (There's enough special characters in \foRest; already, anyway, and the situations where % controlling the expansion is preferable to using the pgfkeys interface are not numerous.) It is % defined at the top of the example by processing key \ikeyname{action character} in the % \ikeyname{id={/bracket},nfc} path; the definition is local to the \TeX\ group. % % Let us continue with the description of the expansion control facilities of the bracket parser. % The expandable token following the % action character is expanded only once. Thus, if one defined macro % |\VP| in terms of the general |\XP| and tried to use it in the same % fashion as |\XP| above, he would fail. The correct way is to follow % the action character by a braced expression: the braced expression % is fully expanded before bracket-parsing is resumed. % \begin{forestexample}[ecmdnames=bracketset,ekeynames=action character] % \bracketset{action character=@} % \def\XP#1#2#3{#1P[#2][#1'[#1][#3]]} % \def\VP#1#2{\XP V{#1}{#2}} % \begin{forest} % [@\XP T{DP}{~@{~\VP{DP}{DP}~}~}] % \end{forest} % \end{forestexample} % % In some applications, the need for macro expansion might be much % more common than the need to embed formatting instructions. % Therefore, the bracket parser provides commands |@+| and |@-|: |@+| % switches to full expansion mode --- all tokens are fully expanded % before parsing them; |@-| switches back to the default mode, where % nothing is automatically expanded. % \begin{forestexample}[ecmdnames=bracketset,ekeynames=action character] % \bracketset{action character=@} % \def\XP#1#2#3{#1P[#2][#1'[#1][#3]]} % \def\VP#1#2{\XP V{#1}{#2}} % \begin{forest} ~@+~ % [\XP T{DP}{\VP{DP}{DP}}] % \end{forest} % \end{forestexample} % % All the action commands discussed above were dealing only with % \TeX's macro expansion. There is one final action command, |@@|, % which yields control to the user code and expects it to call % |\bracketResume| to resume parsing. This is useful to e.g.\ % implement automatic node enumeration: % \begin{forestexample}[ecmdnames=bracketset,ekeynames={action character,phantom,for % ,n,baseline,delay,where ,level,content}] % \bracketset{action character=@} % \newcount\xcount % \def\x#1{~@@~\advance\xcount1 % \edef\xtemp{[$\noexpand\times_{\the\xcount}$[#1]]}% % \expandafter\bracketResume\xtemp % } % \begin{forest} % phantom, % delay={where level=1{content={\strut #1}}{}} % ~@+~ % [\x{f}\x{o}\x{r}\x{e}\x{s}\x{t}] % \end{forest} % \end{forestexample} % This example is fairly complex, so let's discuss how it works. |@+| switches to the full % expansion mode, so that macro |\x| can be easily run. The real magic hides in this macro. In % order to be able to advance the node counter |\xcount|, the macro takes control from \foRest; by % the |@@| command. Since we're already in control, we can use |\edef| to define the node content. % Finally, the |\xtemp| macro containing the node specification is expanded with the resume command % sticked in front of the expansion. % % \section{Reference} % \label{sec:reference} % % \subsection{Environments} % \label{ref:environments} % % \begin{syntax} % \item[,,environment]|\begin{|\rkeyname{forest}|}|\meta{tree}|\end{|\rkeyname{forest}|}| % \rcmdname[item]{Forest}[*]\marg{tree} % % The environment and the starless version of the macro introduce a group; the starred macro does % not, so the created nodes can be used afterwards. (Note that this will leave a lot of temporary % macros lying around. This shouldn't be a problem, however, since all of them reside in the % |\forest| namespace.) % \end{syntax} % % \subsection{The bracket representation} % \label{ref:bracket} % % A bracket representation of a tree is a token list with the following syntax: % \begin{eqnarray*} % \meta{tree}&=&\left[\meta{preamble}\right]\meta{node}\\ % \meta{node}&=&\texttt{[}\left[\meta{content}\right]\left[\texttt{,}\meta{keylist}\right] % \left[\meta{children}\right]\texttt{]}\meta{afterthought}\\ % \meta{preamble}&=&\meta{keylist}\\ % \meta{keylist}&=&\meta{key--value}\left[,\meta{keylist}\right]\\ % \meta{key--value}&=&\meta{key}\OR\meta{key}\texttt{=}\meta{value}\\ % \meta{children}&=&\meta{node}\left[\meta{children}\right] % \end{eqnarray*} % % The actual input might be different, though, since expansion may have occurred during the input % reading. Expansion control sequences of \foRest;'s bracket parser are shown below. % \begin{center} % \begin{tabular}{ll} % \rstyle\meta{action character}\texttt{-}&no-expansion mode (default): nothing is expanded\\ % \rstyle\meta{action character}\texttt{+}&expansion mode: everything is fully expanded\\ % \rstyle\meta{action character}\texttt{}\meta{token}&expand \meta{token}\\ % \rstyle\meta{action character}\texttt{}\meta{\TeX-group}&fully expand \meta{\TeX-group}\\ % \rstyle\meta{action character}\meta{action character}&yield control;\\&upon finishing its job, % user's code should call \texttt{\string\bracketResume} % \end{tabular} % \end{center} % % \paragraph{Customization} To customize the bracket parser, call % \rcmdname{bracketset}\meta{keylist}, where the keys can be the following. % \begin{syntax} % \rkeyname[item={[}]{opening bracket}|=|\meta{character} % \rkeyname[item={{{{]}}}}]{closing bracket}|=|\meta{character} % \rkeyname[item=none]{action character}|=|\meta{character} % \end{syntax} % % By redefining the following two keys, the bracket parser can be used outside \foRest;. % \begin{syntax} % \rkeyname[item]{new node}|=|\meta{preamble}\meta{node specification}\meta{csname}. % Required semantics: create a new node given the preamble (in the case of a new % root node) and the node specification and store the new node's id into \meta{csname}. % \rkeyname[item]{set afterthought}|=|\meta{afterthought}\meta{node id}. % Required semantics: store the afterthought in the node with given id. % \end{syntax} % % \subsection{Options and keys} % \label{ref:option-types} % \label{ref:options-and-keys} % % The position and outlook of nodes is controlled by \emph{options}. Many options can be set for a % node. \emph{Each node's options are set independently of other nodes:} in particular, setting an % option of a node does \emph{not} set this option for the node's descendants. % % Options are set using \PGF;'s key management utility |pgfkeys| \citep[\S55]{tikzpgf2.10}. In the % bracket representation of a tree (see~\S\ref{ref:bracket}), each node can be given a % \meta{keylist}. After parsing the representation of the tree, the keylists of the % nodes are processed (recursively, in a depth-first, parent-first fashion). The preamble is % processed first, in % the context of the root node.\footnote{The value of a key (if it is given) is interpreted as one % or more arguments to the key command. % If there is only one argument, the situation is simple: the whole value is the argument. When the % key takes more than one argument, each argument should be enclosed in braces, unless, as usual in % \TeX, the argument is a single token. (The pairs of braces can be separated by whitespace.) An % argument should also be enclosed in braces if it contains a special character: a comma \texttt{,}, an % equal sign \texttt{=} or a bracket \texttt{[]}.} % % The node whose keylist is being processed is the \emph{current node}. During the processing of % the keylist, the current node can temporarily change. This mainly happens when propagators % (\S\ref{ref:propagators}) are being processed. % % Options can be set in various ways, depending on the option type (the types are listed below). % The most straightforward way is to use the key with the same name as the option: % \begin{syntax} % \item \meta{option}|=|\meta{value} Sets the value of \meta{option} of the current node to % \meta{value}. % % Notes: (i) Obviously, this does not work for read-only options. (ii) Some option types override % this behaviour. % \end{syntax} % It is also possible to set a non-current option: % \begin{syntax} % \item % \imeta{relative node name}|.|\meta{option}|=|\meta{value} Sets the value of % \meta{option} of the node specified by \meta{relative node name} to \meta{value}. % % Notes: \begin{inparaenum}[(i)] % \item\emph{\meta{value} is evaluated in the context of the current node.} % \item In general, the resolution of \meta{relative node name} depends on the % current node; see \S\ref{ref:relative-node-names}. % \item \meta{option} can also be an ``augmented operator'' (see below) or an additional % option-setting key defined for a specific option. % \end{inparaenum} % \end{syntax} % The option values can be not only set, but also read. % \begin{itemize} % \item Using macros \rcmdname{forestoption}|{|\meta{option}|}| and % \rcmdname{foresteoption}|{|\meta{option}|}|, options of the current node can be accessed in \TeX\ % code. (``\TeX\ code'' includes \meta{value} expressions!). % % In the context of |\edef| or \PGF;'s handler |.expanded| \citep[\S55.4.6]{tikzpgf2.10}, % \cmdname{forestoption} expands precisely to the token list of the option value, while % \cmdname{foresteoption} allows the option value to be expanded as well. % \item Using |pgfmath| functions defined by \foRest;, options of both current and non-current nodes % can be accessed. For details, see \S\ref{ref:pgfmath}. % \end{itemize} % % We continue with listing of all keys defined for every option. The set of defined keys and their % meanings depends on the option type. Option types and the type-specific keys can be found in the % list below. Common to all types are two simple conditionals, \ikeyname{id={{if }}}\meta{option} % and \ikeyname{id={{where }}}\meta{option}, which are % defined for every \meta{option}; for details, see \S\ref{ref:conditionals}. % % \begin{syntax} % \rmeta[item]{toks} contains \TeX's \meta{balanced text} \citep[275]{texbook}. % % A toks \meta{option} additionally defines the following keys: % \begin{syntax} % \item {\rstyle\meta{option}}\rkeyname{+}|=|\meta{toks} appends the given \meta{toks} to the % current value of the option. % % \item {\rstyle\meta{option}}\rkeyname{-}|=|\meta{toks} prepends the given \meta{toks} to the % current value of the option. % % \rkeyname[margin={},item]{id={{if in }}}{\rstyle\meta{option}}|=|\meta{toks}\meta{true % keylist}\meta{false keylist} checks if \meta{toks} occurs in the option value; if it does, % \meta{true keylist} are executed, otherwise \meta{false keylist}. % % \rkeyname[margin={},item]{id={{where in }}}\meta{option}|=|\meta{toks}\meta{true % keylist}\meta{false keylist} is a style equivalent to \ikeyname{for tree}|={|\keyname{if in }\meta{option}=\meta{toks}\meta{true keylist}\meta{false keylist}|}|: for every node in % the subtree rooted in the current node, \keyname{if in }\meta{option} is executed in % the context of that node. % \end{syntax} % % \rmeta[item]{autowrapped toks} is a subtype of \imeta{toks} and contains \TeX's \meta{balanced % text} \citep[275]{texbook}. % % {\rstyle\meta{option}}|=|\meta{toks} of an autowrapped \meta{option} is equivalent to % \meta{option}|/|\ikeyname{id=.wrap value,nfc}|=|\meta{toks} of a normal \meta{toks} option. % % Keyvals {\rstyle\meta{option}}\rkeyname{+}|=|\meta{toks} and % {\rstyle\meta{option}\rkeyname{-}}|=|\meta{toks} are equivalent to % \meta{option}\keyname{+}|/|\ikeyname{id=.wrap value,nfc}|=|\meta{toks} and % \meta{option}\keyname{-}|/|\ikeyname{id=.wrap value,nfc}|=|\meta{toks}, respectively. The % normal toks behaviour can be accessed via keys {\rstyle\meta{option}|'|}, % {\rstyle\meta{option}|+'|} and {\rstyle\meta{option}|-'|}. % % \rmeta[item]{keylist} is a subtype of \imeta{toks} and contains a comma-separated list of % \meta{key}[|=|\meta{value}] pairs. % % Augmented operators {\rstyle\meta{option}\keyname{+}} and {\rstyle\meta{option}\keyname{-}} automatically % insert a comma before/after the appended/prepended material. % % {\rstyle\meta{option}}|=|\meta{keylist} of a keylist option is equivalent to % \meta{option}\keyname{+}|=|\meta{keylist}. In other words, keylists behave additively by % default. The rationale is that one usually wants to add keys to a keylist. The usual, % non-additive behaviour can be accessed by {\rstyle\meta{option}\rkeyname{'}}|=|\meta{keylist}. % % \rmeta[item]{dimen} contains a dimension. % % The value given to a dimension option is automatically evaluated by pgfmath. In other words: % % {\rstyle\meta{option}}|=|\meta{pgfmath} is an implicit \meta{option}|/.pgfmath=|\meta{pgfmath}. % % For a \meta{dimen} option \meta{option}, the following additional keys (``augmented % assignments'') are defined: % \begin{itemize} % \item {\rstyle\meta{option}\rkeyname{+}}|=|\meta{value} is equivalent to \meta{option}|=|\meta{option}|()+|\meta{value} % \item {\rstyle\meta{option}\rkeyname{-}}|=|\meta{value} is equivalent to \meta{option}|=|\meta{option}|()-|\meta{value} % \item {\rstyle\meta{option}\rkeyname{*}}|=|\meta{value} is equivalent to \meta{option}|=|\meta{option}|()*|\meta{value} % \item {\rstyle\meta{option}\rkeyname{:}}|=|\meta{value} is equivalent to \meta{option}|=|\meta{option}|()/|\meta{value} % \end{itemize} % % The evaluation of \meta{pgfmath} can be quite slow. There are two tricks to speed things up % \emph{if} the \meta{pgfmath} expression is simple, i.e.\ just a \TeX\ \meta{dimen}: % \begin{enumerate} % \item |pgfmath| evaluation of simple values can be sped up by prepending \ikeyname{+} to the value % \citep[\S62.1]{tikzpgf2.10}; % \item use the key {\rstyle\meta{option}\rkeyname{'}}|=|\meta{value} to invoke a normal \TeX\ assignment. % \end{enumerate} % % The two above-mentioned speed-up tricks work for the augmented assignments as well. The keys % for the second, \TeX-only trick are: {\rstyle\meta{option}\rkeyname{'+}}, % {\rstyle\meta{option}\rkeyname{'-}}, {\rstyle\meta{option}\rkeyname{'*}} and % {\rstyle\meta{option}\rkeyname{':}} --- note that for the latter two, the value should be an % integer. % % \rmeta[item]{count} contains an integer. % % The additional keys and their behaviour are the same as for the \meta{dimen} options. % % \rmeta[item]{boolean} contains $0$ (false) or $1$ (true). % % In the general case, the value given to a \meta{boolean} option is automatically % parsed by pgfmath (just as for \meta{count} and \meta{dimen}): if the computed value is % non-zero, $1$ is stored; otherwise, $0$ is stored. Note that |pgfmath| recognizes constants % |true| and |false|, so it is possible to write \meta{option}|=true| and % \meta{option}|=false|. % % If key \meta{option} is given no argument, pgfmath evaluation does not apply and a true value is % set. To quickly set a false value, use key {\rstyle\rkeyname{id={{not }}}\meta{option}} (with % no arguments). % \end{syntax} % % The following subsections are a complete reference to the part of the user interface residing in % the |pgfkeys|' path \keyname{/forest}. In plain language, they list all the options known to % \foRest;. More precisely, however, not only options are listed, but also other keys, such as % propagators, conditionals, etc. % % Before listing the keys, it is worth mentioning that users can also define their own keys. The % easiest way to do this is by using \emph{styles}. Styles are a feature of the |pgfkeys| package. % They are % named keylists, whose usage ranges from mere abbreviations through templates to devices % implementing recursion. To define a style, use \PGF;'s handler \keyname{.style} % \citep[\S55.4.4]{tikzpgf2.10}: \meta{style name}|/.style=|\meta{keylist}. % % Using the following keys, users can also declare their own options. The new options will behave % exactly like the predefined ones. % \begin{syntax} % \rkeyname[item]{declare toks}|=|\meta{option name}\meta{default value} Declares a \meta{toks} option. % \rkeyname[item]{declare autowrapped toks}|=|\meta{option name}\meta{default value} Declares an % \meta{autowrapped toks} option. % \rkeyname[item]{declare keylist}|=|\meta{option name}\meta{default value} Declares a % \meta{keylist} option. % \rkeyname[item]{declare dimen}|=|\meta{option name}\meta{default value} Declares a \meta{dimen} option. % \rkeyname[item]{declare count}|=|\meta{option name}\meta{default value} Declares a \meta{count} option. % \rkeyname[item]{declare boolean}|=|\meta{option name}\meta{default value} Declares a % \meta{boolean} option. % \end{syntax} % % The style definitions and option declarations given % among the other keys in the bracket specification are local to the current tree. To define % globally accessible styles and options (well, definitions are always local to the current \TeX\ % group), use macro |\forestset| outside the % \ikeyname{forest} environment:\footnote{\cmdname{forestset}\meta{keylist} is equivalent to % \cmdname{pgfkeys}\texttt{\{}/forest,\meta{keylist}\texttt{\}}.} % \begin{syntax} % \rcmdname[item]{forestset}\marg{keylist} % % Execute \meta{keylist} with the default path set to \keyname{/forest}. % \begin{advise} % \item Usually, no current node is set when this macro is called. Thus, executing node options % in this place will \emph{fail}. However, if you have some nodes lying around, you can use % propagator \ikeyname{for name}|=|\meta{node name} to set the node with the given name as % current. % \end{advise} % \end{syntax} % % \subsubsection{Node appearance} % \label{ref:node-appearance} % % The following options apply at stage \ikeyname{typesetting nodes}. Changing them % afterwards has no effect in the normal course of events. % % \begin{syntax} % \rkeyname[item={{{{{}}}}}]{align}|=|\keyname{left,aspect=align}\OR\keyname{center,aspect=align}\OR\keyname{right,aspect=align}\OR\meta{toks: tabular header} % % Creates a left/center/right-aligned multiline node, or a tabular node. In the % \ikeyname{content} option, the lines of the node should separated by |\\| and the columns (if % any) by |&|, as usual. % % The vertical alignment of the multiline/tabular node can be specified by option \ikeyname{base}. % % \begin{forestexample}[ekeynames={l sep,align,base}] % \begin{forest} l sep+=2ex % [special value&actual value\\\hline % \rkeyname{left,aspect=align}&||\texttt{@\{\}l@\{\}}\\ % \rkeyname{center,aspect=align}&||\texttt{@\{\}c@\{\}}\\ % \rkeyname{right,aspect=align}&||\texttt{@\{\}r@\{\}}\\ % ,~align~=ll,draw % [top base\\right aligned, ~align~=right,~base~=top] % [left aligned\\bottom base, ~align~=left,~base~=bottom] % ] % \end{forest} % \end{forestexample} % % Internally, setting this option has two effects: % \begin{enumerate} % \item The option value (a |tabular| environment header specification) is set. The special % values \keyname{left}, \keyname{center} and \keyname{right} invoke styles setting the actual % header to the value shown in the above example. % \begin{advise} % \item If you know that the \keyname{align} was set with a special value, you can easily check % the value using \ikeyname{id={{if in }}}\ikeyname{align}. % \end{advise} % \item Option \ikeyname{content format} is set to the following value: % \begin{lstlisting} % \noexpand\begin{tabular}[\forestoption{base}]{\forestoption{align}}% % \forestoption{content}% % \noexpand\end{tabular}% % \end{lstlisting} % As you can see, it is this value that determines that options \keyname{base}, \keyname{align} and % \keyname{content} specify the vertical alignment, header and content of the table. % \end{enumerate} % % \rkeyname[item=t]{base}|=|\meta{toks: vertical alignment} % % This option controls the vertical alignment of multiline (and in general, \texttt{tabular}) nodes % created with \ikeyname{align}. Its value becomes the optional argument to the \texttt{tabular} % environment. Thus, sensible values are \rkeyname{t,aspect=base} (the top line of the table will % be the baseline) and \rkeyname{b,aspect=base} (the bottom line of the table will be the baseline). % Note that this will only have effect if the node is anchored on a baseline, like in the default % case of \ikeyname{anchor}|=base|. % % For readability, you can use \rkeyname{top,aspect=base} and \rkeyname{bottom,aspect=base} instead % of \keyname{t} and \keyname{b}. (\keyname{top} and \keyname{bottom} are still stored as % \keyname{t} and \keyname{b}.) % % \rkeyname[item={{{{{}}}}}]{content}|=|\meta{autowrapped toks} The content of the node. % % Normally, the value of option \keyname{content} is given implicitely by virtue of the special % (initial) position of content in the bracket representation (see~\S\ref{ref:bracket}). However, % the option also be set explicitely, as any other option. % % \begin{forestexample}[ekeynames={for tree,id={{if }},n,n'},point={content,delay},ekeynames={content,delay}] % \begin{forest} % delay={for tree={ % if n=1{content=L} % {if n'=1{content=R} % {content=C}}}} % [[[][][]][[][][]]] % \end{forest} % \end{forestexample} % Note that the execution of the \keyname{content} option should usually be delayed: otherwise, the % implicitely given content (in the example below, the empty string) will override the explicitely % given content. % % \begin{forestexample}[ekeynames={for tree,id={{if }},n,n',content},point={content}] % \begin{forest} % for tree={ % if n=1{content=L} % {if n'=1{content=R} % {content=C}}} % [[[][][]][[][][]]] % \end{forest} % \end{forestexample} % % \rkeyname[item=\forestoption{content}]{content format}|=|\meta{toks} % % When typesetting the node under the default conditions (see option \ikeyname{node format}), the % value of this option is passed to the \TikZ; \texttt{node} operation as its \meta{text} argument % \citep[\S16.2]{tikzpgf2.10}. The default value of the option simply puts the content in the % node. % % This is a fairly low level option, but sometimes you might still want to change its value. If % you do so, take care of what is expanded when. For details, read the documentation of option % \ikeyname{node format} and macros \icmdname{forestoption} and \icmdname{foresteoption}; for an % example, see option \ikeyname{align}. % % \rkeyname[item]{math content} The content of the node will be typeset in a math environment. % % This style is just an abbreviation for \ikeyname{content % format}|={\ensuremath{\forestoption{content}}}|. % % \rkeyname[item]{node format}|=|\meta{toks} % \hfill|\noexpand\node|\\ % \mbox{}\hfill|[\forestoption{node options},anchor=\forestoption{anchor}]|\\ % \mbox{}\hfill|(\forestoption{name}){\foresteoption{content format}};| % % The node is typeset by executing the expansion of this option's value in a |tikzpicture| % environment. % % Important: the value of this option is first expanded using |\edef| and only then executed. Note % that in its default value, \ikeyname{content format} is fully expanded using % \icmdname{foresteoption}: this is necessary for complex content formats, such as |tabular| % environments. % % This is a low level option. Ideally, there should be no need to change its value. If you do, % note that the \TikZ; node you create should be named using the value of option \ikeyname{name}; % otherwise, parent--child edges can't be drawn, see option \ikeyname{edge path}. % % \rkeyname[item={{{{{}}}}}]{node options}|=|\meta{keylist} % % When the node is being typeset under the default conditions (see option \ikeyname{node format}), % the content of this option is passed to \TikZ; as options to the % \TikZ; |node| operation \citep[\S16]{tikzpgf2.10}. % % This option is rarely manipulated manually: almost all options unknown to \foRest; are % automatically appended to \keyname{node options}. Exceptions are (i) \ikeyname{label} and % \ikeyname{pin}, which require special attention in order to work; and (ii) \ikeyname{anchor}, % which is saved in order to retain the information about the selected anchor. % % \begin{forestexample}[ekeynames={for descendants,anchor,child anchor,parent anchor,grow,l sep,for tree,where,delay,content,node options,rotate,{id=.pgfmath,nfc}}] % \begin{forest} % for descendants={anchor=east,child anchor=east}, % grow=west,anchor=north,parent anchor=north, % l sep=1cm, % for tree={~fill=yellow~},where={n()>3}{~draw=red~}{}, % delay={for tree={content/.pgfmath=~node_options~}} % [root,rotate=90, % [,~fill=white~] % [,~node options'~] % [] % [] % [,~node options~={~ellipse~}] % ] % \end{forest} % \end{forestexample} % % % % \rkeyname[item=false]{phantom}|=|\meta{boolean} % % A phantom node and its surrounding edges are taken into account when packing, but not % drawn. (This option applies in stage \ikeyname{draw tree}.) % \begin{forestexample}[point=phantom,ekeynames=phantom] % \begin{forest} % [VP[DP][V',phantom[V][DP]]] % \end{forest} % \end{forestexample} % % \end{syntax} % % % % \subsubsection{Node position} % \label{ref:ref-node-position} % % Most of the following options apply at stage \ikeyname{pack}. Changing them % afterwards has no effect in the normal course of events. (Options \ikeyname{l}, % \ikeyname{s}, \ikeyname{x}, \ikeyname{y} and \ikeyname{anchor} are exceptions; see their documentation for % details). % % \begin{syntax} % % \rkeyname[item=base]{anchor}|=|\meta{toks: \TikZ; anchor name} % % This is essentially a \TikZ; option \citep[see][\S16.5.1]{tikzpgf2.10} --- it is passed to % \TikZ; as a node option when the node is typeset (this option thus applies in stage % \ikeyname{typeset nodes}) --- but it is also saved by \foRest;. % % The effect of this option is only observable when a node has a sibling: the anchors of all % siblings are s-aligned (if their \ikeyname{l}s have not been modified after packing). % % In the \TikZ; code, you can refer to the node's anchor using the generic anchor % \rkeyname{anchor,aspect=generic anchor}. % % \rkeyname[item=center]{calign}|=|\alternative{child,child edge,midpoint,edge midpoint,fixed % angles,fixed edge angles}\\\alternative{first,last,center}. % % The packing algorithm positions the children so that they don't overlap, effectively computing % the minimal distances between the node anchors of the children. This option (\keyname{calign} % stands for child alignment) specifies how the children are positioned % with respect to the parent (while respecting the above-mentioned minimal distances). % % The child alignment methods refer to the primary and the secondary child, and to the primary and % the secondary angle. These are set using the keys described just after \keyname{calign}. % % \let\outerleftmargin\leftmargin % \begin{syntax} % \item\keyname{calign}|=|\rkeyname{child,aspect=calign} s-aligns the node anchors of the parent and % the primary child. % \item\keyname{calign}|=|\rkeyname{child edge,aspect=calign} s-aligns the parent anchor of the parent % and the child anchor of the primary child. % \item \keyname{calign}|=|\rkeyname{first,aspect=calign} is an abbreviation for % |calign=child,calign_child=1|. % \item \keyname{calign}|=|\rkeyname{last,aspect=calign} is an abbreviation for % |calign=child,calign_child=-1|. % \item\keyname{calign}|=|\rkeyname{midpoint,aspect=calign} s-aligns the parent's node anchor and the % midpoint between the primary and the secondary child's node anchor. % \item\keyname{calign}|=|\rkeyname{edge midpoint,aspect=calign} s-aligns the parent's parent anchor % and the midpoint between the primary and the secondary child's child anchor. % \item \keyname{calign}|=|\rkeyname{center,aspect=calign} is an abbreviation for\\ % |calign=midpoint,| |calign_primary_child=1,| |calign_secondary_child=-1|. % \begin{forestexample} % \begin{forest} % [center,calign=center[1] % [first,calign=first[A][B][C]][3][4][5][6] % [last,calign=last[A][B][C]][8]] % \end{forest} % \end{forestexample} % \item\keyname{calign}|=|\rkeyname{fixed angles,aspect=calign}: The angle between the direction of % growth at the current node (specified by option \ikeyname{grow}) and the line through the node % anchors of the parent and the primary/secondary child will equal the primary/secondary angle. % % To achieve this, the block of children might be spread or further distanced from the parent. % \item\keyname{calign}|=|\rkeyname{fixed edge angles,aspect=calign}: The angle between the direction of % growth at the current node (specified by option \ikeyname{grow}) and the line through the % parent's parent anchor and the primary/secondary child's child anchor will equal the % primary/secondary angle. % % To achieve this, the block of children might be spread or further distanced from the parent. % \begin{forestexample}[point=calign,ekeynames={calign,fixed edge angles,calign primary angle,calign secondary angle,for tree,l}] % \begin{forest} % calign=fixed edge angles, % calign primary angle=-30,calign secondary angle=60, % for tree={l=2cm} % [CP[C][TP]] % \draw[dotted] (!1) -| coordinate(p) () (!2) -| (); % \path ()--(p) node[pos=0.4,left,inner sep=1pt]{-30}; % \path ()--(p) node[pos=0.1,right,inner sep=1pt]{60}; % \end{forest} % \end{forestexample} % \end{syntax} % \rkeyname[item]{calign child}|=|\meta{count} is an abbreviation for \ikeyname{calign primary % child}|=|\meta{count}. % \rkeyname[item=1]{calign primary child}|=|\meta{count} Sets the primary child. % (See \ikeyname{calign}.) % % \meta{count} is the child's sequence number. Negative numbers start counting at the last child. % \rkeyname[item=-1]{calign secondary child}|=|\meta{count} Sets the secondary child. % (See \ikeyname{calign}.) % % \meta{count} is the child's sequence number. Negative numbers start counting at the last child. % \rkeyname[item]{calign angle}|=|\meta{count} is an abbreviation for \ikeyname{calign primary % angle}|=-|\meta{count}, \ikeyname{calign secondary angle}|=|\meta{count}. % \rkeyname[item=-35]{calign primary angle}|=|\meta{count} Sets the primary angle. % (See \ikeyname{calign}.) % \rkeyname[item=35]{calign secondary angle}|=|\meta{count} Sets the secondary angle. % (See \ikeyname{calign}.) % \rkeyname[item]{calign with current} s-aligns the node anchors of the current node and its % parent. This key is an abbreviation for:\\ % |for_parent/.wrap_pgfmath_arg={calign=child,calign primary child=##1}{n}|. % \rkeyname[item]{calign with current edge} s-aligns the child anchor of the current node and the % parent anchor of its parent. This key is an abbreviation for:\\ % |for_parent/.wrap_pgfmath_arg={calign=child edge,calign primary child=##1}{n}|. % % \rkeyname[item=tight]{fit}|=|\alternative{tight,rectangle,band} % % \begin{forestexample}[pos=x,samplebox=\treebox,codebox=\codebox,basicstyle=\footnotesize\ttfamily] % \makeatletter\tikzset{use path/.code={\tikz@addmode{\pgfsyssoftpath@setcurrentpath#1} % \appto\tikz@preactions{\let\tikz@actions@path#1}}}\makeatother % \forestset{show boundary/.style={ % before drawing tree={get min s tree boundary=\minboundary, get max s tree boundary=\maxboundary}, % tikz+={\draw[red,use path=\minboundary]; \draw[red,use path=\maxboundary];}}} % \end{forestexample} % \input{\jobname.tmp} % % This option sets the type of the (s-)boundary that will be computed for the subtree rooted in the % node, thereby determining how it will be packed into the subtree rooted in the node's parent. % There are three choices:\footnote{Below is the definition of style \keyname{show boundary}. The % \keyname{use path} trick is adjusted from \TeX\ Stackexchange question % \href{http://tex.stackexchange.com/questions/26382/calling-a-previously-named-path-in-tikz}{Calling % a previously named path in tikz}. % % \vskip-2ex \box\codebox} % \begin{itemize} % \item\keyname{fit}|=|\rkeyname{tight,aspect=fit}: an exact boundary of the node's subtree is computed, % resulting in a compactly packed tree. Below, the boundary of subtree L is drawn. % \begin{forestexample}[point={fit,tight},ekeynames={fit,{tight,aspect=fit},delay,for tree,name,content,{id=.pgfmath,nfc}}] % \begin{forest} % delay={for tree={name/.pgfmath=content}} % [root % [L,fit=tight, % default % show boundary % [L1][L2][L3]] % [R] % ] % \end{forest} % \end{forestexample} % \makeatletter\tikzset{use path/.code={% % \tikz@addmode{\pgfsyssoftpath@setcurrentpath#1}% % \appto\tikz@preactions{\let\tikz@actions@path#1}% % }}\makeatother % \item\keyname{fit}|=|\rkeyname{rectangle,aspect=fit}: puts the node's subtree in a rectangle and effectively % packs this rectangle; the resulting tree will usually be wider. % \begin{forestexample}[point={fit,rectangle},ekeynames={fit,{rectangle,aspect=fit},delay,for tree,name,content,{id=.pgfmath,nfc}}] % \begin{forest} % delay={for tree={name/.pgfmath=content}} % [root % [L,fit=rectangle, % show boundary % [L1][L2][L3]] % [R] % ] % \end{forest} % \end{forestexample} % \item\keyname{fit}|=|\rkeyname{band,aspect=fit}: puts the node's subtree in a rectangle of ``infinite % depth'': the space under the node and its descendants will be kept clear. % \begin{forestexample}[point={fit,band},ekeynames={fit,{band,aspect=fit},delay,for tree,name,content,{id=.pgfmath,nfc}}] % \begin{forest} % delay={for tree={name/.pgfmath=content}} % [root % [L[L1][L2][L3]] % [C,fit=band] % [R[R1][R2][R3]] % ] % \draw[thin,red] % (C.south west)--(C.north west) % (C.north east)--(C.south east); % \draw[thin,red,dotted] % (C.south west)--+(0,-1) % (C.south east)--+(0,-1); % \end{forest} % \end{forestexample} % \end{itemize} % % \rkeyname[item=270]{grow}|=|\meta{count} The direction of the tree's growth at the node. % % The growth direction is understood as in \TikZ;'s tree library \citep[\S18.5.2]{tikzpgf2.10} % when using the default growth method: the (node anchor's of the) children of the node are placed % on a line orthogonal to the current direction of growth. (The final result might be different, % however, if \ikeyname{l} is changed after packing or if some child undergoes tier alignment.) % % This option is essentially numeric (|pgfmath| function \keyname{grow} will always return an % integer), but there are some twists. The growth direction can be specified either numerically % or as a compass direction (|east|, |north east|, \dots). Furthermore, like in \TikZ;, setting % the growth direction using key \keyname{grow} additionally sets the value of option % \ikeyname{reversed} to |false|, while setting it with \rkeyname{grow'} sets it to |true|; to % change the growth direction without influencing \ikeyname{reversed}, use key \rkeyname{grow''}. % % Between stages \ikeyname{pack} and \ikeyname{compute xy}, the value of \keyname{grow} should not % be changed. % % \begin{forestexample}[ekeynames={delay,id={{where in }},content,for ,current,grow,grow',grow'',{id=.pgfmath,nfc}}] % \begin{forest} % delay={where in content={~grow~}{ % for current/.pgfmath=content, % content=\texttt{#1} % }{} % } % [{~grow~=south} % [{~grow'~=west}[1][2][3] % [{~grow''~=90}[1][2][3]]] % [2][3][4] % [{~grow~=east}[1][2][3] % [{~grow''~=90}[1][2][3]]]] % \end{forest} % \end{forestexample} % % \rkeyname[item=false]{ignore}|=|\meta{boolean} % % If this option is set, the packing mechanism ignores the node, i.e.\ it pretends that the node has % no boundary. Note: this only applies to the node, not to the tree. % % Maybe someone will even find this option useful for some reason \dots % % \rkeyname[item=false]{ignore edge}|=|\meta{boolean} % % If this option is set, the packing mechanism ignores the edge from the node to the parent, i.e.\ % nodes and other edges can overlap it. (See \S\ref{sec:bugs} for some problematic situations.) % % \begin{forestexample}[ekeynames={ignore edge,l,*}] % \begin{forest} % [A[B[B][B][B][B]][C % [\texttt{not ignore edge},l*=2]]] % \end{forest} % \begin{forest} % [A[B[B][B][B][B]][C % [\texttt{ignore edge},l*=2,~ignore edge~]]] % \end{forest} % \end{forestexample} % % \rkeyname[item]{l}|=|\meta{dimen} The l-position of the node, in the parent's ls-coordinate system. (The % origin of a node's ls-coordinate system is at its (node) anchor. The l-axis points in the % direction of the tree growth at the node, which is given by option \ikeyname{grow}. The s-axis is % orthogonal to the l-axis; the positive side is in the counter-clockwise direction from |l| axis.) % % The initial value of \keyname{l} is set from the standard node. By default, it equals: % \[\ikeyname{l sep}+2\cdot\mbox{\texttt{outer ysep}}+\mbox{total % height(standard node)}\] % % The value of \keyname{l} can be changed at any point, with different effects. % \begin{itemize} % \item The value of \keyname{l} at the beginning of stage \ikeyname{pack} determines the minimal % l-distance between the anchors of the node and its parent. Thus, changing \keyname{l} before % packing will influence this process. (During packing, \keyname{l} can be increased due to % parent's \ikeyname{l sep}, tier alignment, or \ikeyname{calign} method \keyname{fixed (edge) % angles}\ekeyname{fixed angles},\ekeyname{fixed edge angles}.) % % \item Changing \keyname{l} after packing but before stage \ikeyname{compute xy} will result in a % manual adjustment of the computed position. (The augmented operators can be useful here.) % % \item Changing \keyname{l} after the absolute positions have been computed has no effect in the % normal course of events. % \end{itemize} % % \rkeyname[item]{l sep}|=|\meta{dimen} The minimal l-distance between the node and its % descendants. % % This option determines the l-distance between the \emph{boundaries} of the node and its descendants, % not node anchors. The final effect is that there will be a \keyname{l sep} wide band, % in the l-dimension, between the node and all its descendants. % % The initial value of \keyname{l sep} is set from the standard node and equals % \[\mbox{height}(\mbox{strut})+\mbox{\texttt{inner ysep}}\] % % Note that despite the similar name, the semantics of \keyname{l sep} and \keyname{s sep} are % quite different. % % \rkeyname[item=false]{reversed}|=|\meta{boolean} % % If |false|, the children are positioned around the node in the counter-clockwise direction; if % |true|, in the clockwise direction. See also \ikeyname{grow}. % % \rkeyname[item]{s}|=|\meta{dimen} The s-position of the node, in the parent's ls-coordinate system. % (The origin of a node's ls-coordinate system is at its (node) anchor. The l-axis points in the % direction of the tree growth at the node, which is given by option \ikeyname{grow}. The s-axis is % orthogonal to the l-axis; the positive side is in the counter-clockwise direction from |l| axis.) % % The value of \keyname{s} is computed by the packing mechanism. Any value given before packing is % overridden. In short, it only makes sense to (inspect and) change this option after stage % \ikeyname{pack}, which can be useful for manual corrections, like below. (B is closer to A than C % because packing proceeds from the first to the last child --- the position of B would be the same % if there was no C.) Changing the value of \keyname{s} after stage \ikeyname{compute xy} has no % effect. % \begin{forestexample}[point=s,ekeynames={before computing xy,s}] % \begin{minipage}{.5\linewidth} % \begin{forest} % [no manual correction of B % [A[1][2][3][4]] % [B] % [C[1][2][3][4]] % ] % \end{forest} % % \begin{forest} % [manual correction of B % [A[1][2][3][4]] % [B,before computing xy={s=(s("!p")+s("!n"))/2}] % [C[1][2][3][4]] % ] % \end{forest} % \end{minipage} % \end{forestexample} % % \rkeyname[item]{s sep}|=|\meta{dimen} % % The subtrees rooted in the node's children will be kept at least \keyname{s sep} apart in the % s-dimension. Note that \keyname{s sep} is about the minimal distance between node % \emph{boundaries}, not node anchors. % % The initial value of \keyname{s sep} is set from the standard node and equals % $2\cdot\mbox{\texttt{inner xsep}}$. % % Note that despite the similar name, the semantics of \keyname{s sep} and \keyname{l sep} are % quite different. % % \rkeyname[item={{{{{}}}}}]{tier}|=|\meta{toks} % % Setting this option to something non-empty ``puts a node on a tier.'' All the nodes on the same % tier are aligned in the l-dimension. % % Tier alignment across changes in growth direction is impossible. In the case of incompatible % options, \foRest; will yield an error. % % Tier alignment also does not work well with \ikeyname{calign}|=|\keyname{fixed (edge) % angles}\ekeyname{fixed angles}\ekeyname{fixed edge angles}, because these child alignment methods % may change the l-position of the children. When this might happen, \foRest; will yield a warning. % % \rkeyname[item]{x}=\meta{dimen} % \vspace{-\parskip} % \rkeyname[item]{y}=\meta{dimen} % % \keyname{x} and \keyname{y} are the coordinates of the node in the ``normal'' (paper) coordinate % system, relative to the root of the tree that is being drawn. So, essentially, they are absolute % coordinates. % % The values of \keyname{x} and \keyname{y} are computed in stage \ikeyname{compute xy}. It only % makes sense to inspect and change them (for manual adjustments) afterwards (normally, in the % \ikeyname{before drawing tree} hook, see \S\ref{ref:stages}.) % \begin{forestexample}[label=ex:adjustxy,ekeynames={y,-,grow',l,for tree,before drawing tree}] % \begin{forest} % for tree={grow'=45,l=1.5cm} % [A[B][C][D,before drawing tree={~y-~=4mm}[1][2][3][4][5]][E][F]] % \end{forest} % \end{forestexample} % % \end{syntax} % % \subsubsection{Edges} % \label{ref:ref-edge} % % These options determine the shape and position of the edge from a node to its parent. They apply % at stage \ikeyname{draw tree}. % % \begin{syntax} % \rkeyname[item={{{{{}}}}}]{child anchor}|=|\meta{toks} See \ikeyname{parent anchor}. % % \rkeyname[item=draw]{edge}|=|\meta{keylist} % % When \ikeyname{edge path} has its default value, the value of this option is passed as options to % the \TikZ; |\path| expression used to draw the edge between the node and its parent. % % Also see key \ikeyname{no edge}. % % \begin{forestexample}[point=edge,ekeynames={edge,no edge,for tree,grow',l,anchor,child anchor}] % \begin{forest} for tree={grow'=0,l=2cm,anchor=west,child anchor=west}, % [root % [normal] % [none,~no~ edge] % [dotted,edge=dotted] % [dashed,edge=dashed] % [dashed,edge={dashed,red}] % ] % \end{forest} % \end{forestexample} % % \rkeyname[item={{{{{}}}}}]{edge label}|=|\meta{toks: \TikZ; code} % % When \ikeyname{edge path} has its default value, the value of this option is used at the end of % the edge path specification to typeset a node (or nodes) along the edge. % % The packing mechanism is not sensitive to edge labels. % % \begin{forestexample}[ekeynames={edge label}] % \begin{forest} % [VP % [V,~edge label~={node[midway,left,font=\scriptsize]{head}}] % [DP,~edge label~={node[midway,right,font=\scriptsize]{complement}}] % ] % \end{forest} % \end{forestexample} % % \rkeyname[item]{edge path}|=|\meta{toks: \TikZ; code} % \hfill |\noexpand\path[\forestoption{edge}]|\\ % \mbox{}\hfill |(!u.parent anchor)--(.child anchor)\forestoption{edge label};| % % This option contains the code that draws the edge from the node to its parent. By default, it % creates a path consisting of a single line segment between the node's \ikeyname{child anchor} and % its parent's \ikeyname{parent anchor}. Options given by \ikeyname{edge} are passed to the path; by % default, the path is simply drawn. Contents of \ikeyname{edge label} are used to potentially place % a node (or nodes) along the edge. % % When setting this option, the values of options \ikeyname{edge} and \ikeyname{edge label} can be % used in the edge path specification to include the values of options \ikeyname{edge} and \ikeyname{edge % node}. Furthermore, two generic anchors, \ikeyname{parent anchor,aspect=generic anchor} and \ikeyname{child anchor,aspect=generic anchor}, are defined, % to facilitate access to options \ikeyname{parent anchor} and \ikeyname{child anchor} from the \TikZ; code. % % The node positioning algorithm is sensitive to edges, i.e.\ it will avoid a node overlapping an % edge or two edges overlapping. However, the positioning algorithm always behaves as if the % \keyname{edge path} had the default value --- \emph{changing the \keyname{edge path} does not % influence the packing!} Sorry. (Parent--child edges can be ignored, however: see option % \ikeyname{ignore edge}.) % % \rkeyname[item={{{{{}}}}}]{parent anchor}|=|\meta{toks: \TikZ; anchor} (Information also applies to % option \ikeyname{child anchor}.) % % \FoRest; defines generic anchors \rkeyname{parent anchor,aspect=generic anchor} and % \rkeyname{child anchor,aspect=generic anchor} (which work only for \foRest; and not also \TikZ; % nodes, of course) to facilitate reference to the desired endpoints of child--parent edges. % Whenever one of these anchors is invoked, it looks up the value of the \keyname{parent anchor} or % \keyname{child anchor} of the node named in the coordinate specification, and forwards the request % to the (\TikZ;) anchor given as the value. % % The indented use of the two anchors is chiefly in \ikeyname{edge path} specification, but they can % used in any \TikZ; code. % \begin{forestexample}[ekeynames={parent anchor,child anchor,for tree}] % \begin{forest} % for tree={~parent anchor~=south,~child anchor~=north} % [VP[V][DP]] % \path[fill=red] (.parent anchor) circle[radius=2pt] % (!1.child anchor) circle[radius=2pt] % (!2.child anchor) circle[radius=2pt]; % \end{forest} % \end{forestexample} % % The empty value (which is the default) is interpreted as in \TikZ;: as an edge to the appropriate % border point. % % % \rkeyname[item]{no edge} Clears the edge options (\ikeyname{edge}|'={}|) and sets \ikeyname{ignore % edge}. % % \rkeyname[item]{triangle} Makes the edge to parent a triangular roof. Works only for south-growing % trees. Works by changing the value of \ikeyname{edge path}. % % \end{syntax} % % \subsubsection{Readonly} % \label{ref:readonly-options} % % The values of these options provide various information about the tree and its nodes. % % \begin{syntax} % \rkeyname[item]{id=id}|=|\meta{count}) The internal id of the node. % % \rkeyname[item]{level}|=|\meta{count} The hierarchical level of the node. The root is on level $0$. % % \rkeyname[item]{max x}|=|\meta{dimen} \vspace{-\parskip} % \rkeyname[item]{max y}|=|\meta{dimen} \vspace{-\parskip} % \rkeyname[item]{min x}|=|\meta{dimen} \vspace{-\parskip} % \rkeyname[item]{min y}|=|\meta{dimen} % Measures of the node, in the shape's coordinate system % \citep[see][\S16.2,\S48,\S75]{tikzpgf2.10} shifted so that the node anchor is at the origin. % % In |pgfmath| expressions, these options are accessible as |max__x|, |max__y|, |min__x| and |min__y|. % % \rkeyname[item]{n}|=|\meta{count} The child's sequence number in the list of its parent's % children. % % The enumeration starts with 1. For the root node, \keyname{n} equals $0$. % % \rkeyname[item]{n'}|=|\meta{count} Like \ikeyname{n}, but starts counting at the last child. % % In |pgfmath| expressions, this option is accessible as |n__|. % % \rkeyname[item]{n children}|=|\meta{count} The number of children of the node. % % In |pgfmath| expressions, this option is accessible as |n__children|. % \end{syntax} % % \subsubsection{Miscellaneous} % \label{ref:miscellaneous} % % \begin{syntax} % \rkeyname[item]{afterthought}|=|\meta{toks} Provides the afterthought explicitely. % % This key is normally not used by the end-user, but rather called by the bracket parser. By % default, this key is a style defined by |afterthought/.style={tikz+={#1}}|: afterthoughts are % interpreted as (cumulative) \TikZ; code. If you'd like to use afterthoughts for some other % purpose, redefine the key --- this will take effect even if you do it in the tree preamble. % % \rkeyname[item]{alias}|=|\meta{toks} Sets the alias for the node's name. % % Unlike \ikeyname{name}, \keyname{alias} is \emph{not} an option: you cannot e.g.\ query it's % value via a |pgfmath| expression. % % Aliases can be used as the \meta{forest node name} part of a relative node name and as the % argument to the \ikeyname{name,aspect=step} step of a node walk. The latter includes the usage % as the argument of the \ikeyname{id={{for }}}\ikeyname{name} propagator. % % Technically speaking, \foRest; alias is \emph{not} a \TikZ; alias! However, you can still use % it as a ``node name'' in \TikZ; coordinates, since \foRest; hacks \TikZ;'s implicit node % coordinate system to accept relative node names; see \S\ref{ref:forest-cs}. % % \rkeyname[item]{baseline} The node's anchor becomes the baseline of the whole tree % \citep[cf.][\S69.3.1]{tikzpgf2.10}. % % In plain language, when the tree is inserted in your (normal \TeX) text, it will be vertically % aligned to the anchor of the current node. % % Behind the scenes, this style sets the alias of the current node to \keyname{forest@baseline@node}. % \begin{forestexample}[ekeynames={baseline,use as bounding box'}] % {\tikzexternaldisable % Baseline at the % \begin{forest} % [parent,~baseline~,use as bounding box' % [child]] % \end{forest} % and baseline at the % \begin{forest} % [parent % [child,~baseline~,use as bounding box']] % \end{forest}.} % \end{forestexample} % % \rkeyname[item=\begin{tikzpicture}]{begin draw}|/.code=|\meta{toks: \TeX\ code} \vspace{-\parskip} % \rkeyname[item=\end{tikzpicture}]{end draw}|/.code=|\meta{toks: \TeX\ code} % % The code produced by \ikeyname{draw tree} is put in the environment specified by \keyname{begin % draw} and \keyname{end draw}. Thus, it is this environment, normally a |tikzpicture|, that does % the actual drawing. % % A common use of these keys might be to enclose the |tikzpicture| environment in a |center| % environment, thereby automatically centering all trees; or, to provide the \TikZ; code to execute % at the beginning and/or end of the picture. % % Note that \keyname{begin draw} and \keyname{end draw} are \emph{not} node options: they are % |\pgfkeys|' code-storing keys \citep[\S55.4.3--4]{tikzpgf2.10}. % % % \rkeyname[item={{{{{}}}}}]{begin forest}|/.code=|\meta{toks: \TeX\ code} \vspace{-\parskip} % \rkeyname[item={{{{{}}}}}]{end forest}|/.code=|\meta{toks: \TeX\ code} % % The code stored in these (|\pgfkeys|) keys is executed at the beginning and end of the % \ikeyname{forest} environment / \icmdname{Forest} macro. % % Using these keys is only effective \emph{outside} the \ikeyname{forest} environment, and the % effect lasts until the end of the current \TeX\ group. % % For example, executing \icmdname{forestset}|{begin forest/.code=\small}| will typeset all trees (and only % trees) in the small font size. % % % \rkeyname[item]{fit to tree} Fits the \TikZ; node to the current node's subtree. % % This key should be used like \keyname{/tikz/fit} of the \TikZ;'s fitting library % \citep[see][\S34]{tikzpgf2.10}: as an option to \emph{\TikZ;'s} |node| operation, the obvious % restriction being that \keyname{fit to tree} must be used in the context of some \foRest; node. % For an example, see footnote~\ref{fn:fit-to-tree}. % % This key works by calling \keyname{/tikz/fit} and providing it with the the coordinates of the % subtree's boundary. % % \rkeyname[item]{get min s tree boundary}|=|\meta{cs} \vspace{-\parskip} % \rkeyname[item]{get max s tree boundary}|=|\meta{cs} % % Puts the boundary computed during the packing process into the given \meta{cs}. The boundary is % in the form of \PGF; path. The |min| and |max| versions give the two sides of the node. For an % example, see how the boundaries in the discussion of \ikeyname{fit} were drawn. % % \rkeyname[item]{label}|=|\meta{toks: \TikZ; node} The current node is labelled by a \TikZ; node. % % The label is specified as a \TikZ; option \texttt{label} \citep[\S16.10]{tikzpgf2.10}. % Technically, the value of this option is passed to \TikZ;'s as a late option % \citep[\S16.14]{tikzpgf2.10}. (This is so because \foRest; must first typeset the nodes % separately to measure them (stage \ikeyname{typeset nodes}); the preconstructed nodes are inserted % in the big picture later, at stage \ikeyname{draw tree}.) Another option with the same % technicality is \ikeyname{pin}. % % \rkeyname[item]{name}|=|\meta{toks} Sets the name of the node.\hfill\texttt{node@}\meta{id} % % The expansion of \meta{toks} becomes the \meta{forest node name} of the node. Node names must % be unique. The \TikZ; node created from the \foRest; node will get the name specified by this % option. % % \rkeyname[item]{node walk}|=|\meta{node walk} This key is the most general way to use a \meta{node % walk}. % % Before starting the \meta{node walk}, key \rkeyname{id={node walk/before walk}} is processed. % Then, the \meta{step}s composing the \meta{node walk} are processed: making a step (normally) % changes the current node. After every step, key \rkeyname{id={node walk/every step}} is % processed. After the walk, key \rkeyname{id={node walk/after walk}} is processed. % % \keyname{node walk/before walk}, \keyname{node walk/every step} and \keyname{node walk/after % walk} are processed with \keyname{/forest} as the default path: thus, \foRest;'s options and % keys described in \S\ref{ref:options-and-keys} can be used normally inside their definitions. % % \begin{advise} % \item Node walks can be tail-recursive, i.e.\ you can call another node walk from \keyname{node % walk/after walk} --- embedding another node walk in \keyname{node walk/before walk} or % \keyname{node walk/every step} will probably fail, because the three node walk styles are not % saved and restored (a node walk doesn't create a \TeX\ group). % \item \keyname{every step} and \keyname{after walk} can be redefined even during the walk. % Obviously, redefining \keyname{before walk} during the walk has no effect (in the current % walk). % \end{advise} % % \rkeyname[item]{pin}|=|\meta{toks: \TikZ; node} The current node gets a pin, see % \citep[\S16.10]{tikzpgf2.10}. % % The technical details are the same as for \ikeyname{label}. % % \rkeyname[item]{use as bounding box} The current node's box is used as a bounding box for the % whole tree. % % \rkeyname[item]{use as bounding box'} Like \ikeyname{use as bounding box}, but subtracts the % (current) inner and outer sep from the node's box. For an example, see \ikeyname{baseline}. % % \rkeyname[item]{TeX}|=|\meta{toks: \TeX\ code} The given code is executed immediately. % % This can be used for e.g.\ enumerating nodes: % \begin{forestexample}[point=TeX,ekeynames={TeX,delay,where ,tier,content,GP1},label=ex:enumerate] % \newcount\xcount % \begin{forest} GP1, % delay={TeX={\xcount=0}, % where tier={x}{TeX={\advance\xcount1}, % content/.expanded={##1$_{\the\xcount}$}}{}} % [ % [O[x[f]]] % [R[N[x[o]]]] % [O[x[r]]] % [R[N[x[e]]][x[s]]] % [O[x[t]]] % [R[N[x]]] % ] % \end{forest} % \end{forestexample} % % \rkeyname[item]{TeX'}|=|\meta{toks: \TeX\ code} This key is a combination of keys \ikeyname{TeX} % and \ikeyname{TeX''}: the given code is both executed and externalized. % % \rkeyname[item]{TeX''}|=|\meta{toks: \TeX\ code} The given code is externalized, i.e.\ it will be % executed when the externalized images are loaded. % % The image-loading and \keyname{TeX'(')} produced code are intertwined. % % \rkeyname[item={{{{{}}}}}]{tikz}|=|\meta{toks: \TikZ; code} ``Decorations.'' % % The code given as the value of this option will be included in the |tikzpicture| environment % used to draw the tree. The code given to various nodes is appended in a depth-first, % parent-first fashion. The code is included after all nodes of the tree have been drawn, so it % can refer to any node of the tree. Furthermore, relative node names can be used to refer to % nodes of the tree, see \S\ref{ref:relative-node-names}. % % By default, bracket parser's afterthoughts feed the value of this option. See % \ikeyname{afterthought}. % % \end{syntax} % % \subsubsection{Propagators} % \label{ref:propagators} % % Propagators pass the given \meta{keylist} to other node(s), delay their processing, or cause them % to be processed only under certain conditions. % % A propagator can never fail --- i.e.\ if you use \keyname{for next} on the last child of some node, % no error will arise: the \meta{keylist} will simply not be passed to any node. (The generic % node walk propagator \keyname{for} is % an exception. While it will not fail if the final node of the walk does not exist (is null), its node walk % can fail when trying to walk away from the null node.) % % \paragraph{Spatial propagators} % pass the given \meta{keylist} to other node(s) in the tree. (\keyname{for} and \keyname{for % }\meta{step} always pass the \meta{keylist} to a single node.) % % \begin{syntax} % \rkeyname[item]{for}|=|\meta{node walk}\meta{keylist} Processes \meta{keylist} in the context of the final % node in the \meta{node walk} starting at the current node. % % \rkeyname[item]{id={{for }}}\meta{step}|=|\meta{keylist} Walks a single-step node-walk % \meta{step} from the current node and passes the given \meta{keylist} to the final (i.e.\ second) node. % % \meta{step} must be a long node walk step; see \S\ref{ref:node-walk}. \keyname{for % }\meta{step}|=|\meta{keylist} is equivalent to \ikeyname{for}|=|\meta{step}{keylist}. % % Examples: |for_parent={l_sep+=3mm}|, |for_n=2{circle,draw}|. % % \rkeyname[item]{for ancestors}|=|\meta{keylist} % \rkeyname[item]{for ancestors'}|=|\meta{keylist} Passes the \meta{keylist} to itself, too. % \begin{forestexample}[ekeynames={for ancestors',delay,content,edge}] % \pgfkeys{/forest, % inptr/.style={% % red,delay={content={\textbf{##1}}}, % edge={draw,line width=1pt,red}}, % ptr/.style={~for ancestors'~=inptr} % } % \begin{forest} % [x % [x[x[x][x]][x[x,ptr][x]]] % [x[x[x][x]][x[x][x]]]] % \end{forest} % \end{forestexample} % % \rkeyname[item]{for all next}|=|\meta{keylist} Passes the \meta{keylist} to all the following siblings. % % \rkeyname[item]{for all previous}|=|\meta{keylist} Passes the \meta{keylist} to all the preceding siblings. % % \rkeyname[item]{for children}|=|\meta{keylist} % % \rkeyname[item]{for descendants}|=|\meta{keylist} % % \rkeyname[item]{for tree}|=|\meta{keylist} % % Passes the key to the current node and its the descendants. % % This key should really be named \keyname{for subtree} \dots % % \end{syntax} % % \paragraph{Conditionals} % \label{ref:conditionals} % % For all conditionals, both the true and the false keylist are obligatory! Either keylist can be % empty, however --- but don't omit the braces! % % \begin{syntax} % \rkeyname[item]{if}|=|\meta{pgfmath condition}\meta{true keylist}\meta{false keylist} % % If \meta{pgfmath condition} evaluates to |true| (non-zero), \meta{true keylist} is processed (in % the context of the current node); otherwise, \meta{false keylist} is processed. % % For a detailed description of % |pgfmath| expressions, see \cite[part VI]{tikzpgf2.10}. (In short: write the usual mathematical % expressions.) % % \rkeyname[item]{id={{if }}}\meta{option}|=|\meta{value}\meta{true keylist}\meta{false keylist} % % A simple conditional is defined for every \meta{option}: if \meta{value} equals the value of the % option at the current node, \meta{true keylist} is executed; otherwise, \meta{false keylist}. % % \rkeyname[item]{where}|=|\meta{value}\meta{true keylist}\meta{false keylist} % % Executes conditional \ikeyname{if} for every node in the current subtree. % % \rkeyname[item]{id={{where }}}\meta{option}|=|\meta{value}\meta{true keylist}\meta{false keylist} % % Executes simple conditional \ikeyname{id={{if }}}\meta{option} for every node in the current subtree. % % \rkeyname[item]{id={{if in }}}\meta{option}|=|\meta{toks}\meta{true keylist}\meta{false % keylist} % % Checks if \meta{toks} occurs in the option value; if it does, \meta{true keylist} are executed, % otherwise \meta{false keylist}. % % This conditional is defined only for \meta{toks} options, see \S\ref{ref:options-and-keys}. % % \rkeyname[item]{id={{where in }}}\meta{toks option}|=|\meta{toks}\meta{true keylist}\meta{false keylist} % % A style equivalent to \ikeyname{for tree}|=|\ikeyname{id={{if in }}}\meta{option}=\meta{toks}\meta{true % keylist}\meta{false keylist}: for every node in the subtree rooted in the current node, % \ikeyname{id={{if in }}}\meta{option} is executed in the context of that node. % % This conditional is defined only for \meta{toks} options, see \S\ref{ref:options-and-keys}. % \end{syntax} % % \paragraph{Temporal propagators} % There are two kinds of temporal propagators. The |before_...| propagators defer the processing of % the given keys to a hook just before some stage in the computation. The \keyname{delay} % propagator is ``internal'' to the current hook (the first hook, the given options, is % implicit): the keys in a hook are processed cyclically, and \keyname{delay} delays the % processing of the given options until the next cycle. All these keys can be nested without % limit. For details, see~\S\ref{ref:stages}. % \begin{syntax} % \rkeyname[item]{delay}|=|\meta{keylist} Defers the processing of the \meta{keylist} until the next % cycle. % \rkeyname[item]{delay n}|=|\meta{integer}\meta{keylist} Defers the processing of the % \meta{keylist} for $n$ cycles. $n$ may be $0$, and it may be given as a |pgfmath| expression. % \rkeyname[item]{if have delayed}|=|\meta{true keylist}\meta{false keylist} If any options were % delayed in the current cycle (more precisely, up to the point of the execution of this key), % process \meta{true keylist}, otherwise process \meta{false keylist}. (\ikeyname{delay n} will % trigger ``true'' for the intermediate cycles.) % \rkeyname[item]{before typesetting nodes}|=|\meta{keylist} Defers the processing of the % \meta{keylist} to until just before the nodes are typeset. % \rkeyname[item]{before packing}|=|\meta{keylist} Defers the processing of the % \meta{keylist} to until just before the nodes are packed. % \rkeyname[item]{before computing xy}|=|\meta{keylist} Defers the processing of the % \meta{keylist} to until just before the absolute positions of the nodes are computed. % \rkeyname[item]{before drawing tree}|=|\meta{keylist} Defers the processing of the % \meta{keylist} to until just before the tree is drawn. % \end{syntax} % % \paragraph{Other propagators} % \begin{syntax} % \rkeyname[item]{repeat}|=|\meta{number}\meta{keylist} The \meta{keylist} is processed \meta{number} % times. % % The \meta{number} expression is evaluated using |pgfmath|. Propagator \keyname{repeat} also % works in node walks. % \end{syntax} % % \subsubsection{Stages} % \label{ref:stages} % % \FoRest; does its job in several steps. The normal course of events is the following: % \begin{enumerate} % \item\label{step:parsing-bracket} The bracket representation of the tree if parsed and stored in a % data structure. % \item\label{step:given-options} The given options are processed, including the options in the % preamble, which are processed first (in the context of the root node). % \item\label{step:typeset-nodes} Each node is typeset in its own |tikzpicture| environment, saved % in a box and its measures are taken. % \item\label{step:pack} The nodes of the tree are \emph{packed}, i.e.\ the relative positions of the nodes are % computed so that the nodes don't overlap. That's difficult. The result: option \ikeyname{s} is % set for all nodes. (Sometimes, the value of \ikeyname{l} is adjusted as well.) % \item\label{step:compute-xy} Absolute positions, or rather, positions of the nodes relative to the % root node are computed. That's easy. The result: options \ikeyname{x} and \ikeyname{y} are % set. % \item\label{step:draw-tree} The \TikZ; code that will draw the tree is produced. (The nodes are % drawn by using the boxes typeset in step~\ref{step:typeset-nodes}.) % \end{enumerate} % % Steps~\ref{step:parsing-bracket} and \ref{step:given-options} collect user input and are thus % ``fixed''. However, the other steps, which do the actual work, are under user's control. % % First, hooks exist which make it possible (and easy) to change node's properties between the % processing stages. For a simple example, see example~\ref{ex:adjustxy}: the manual adjustment of % \ikeyname{y} can only be done after the absolute positions have been computed, so the processing % of this option is deferred by \ikeyname{before drawing tree}. For a more realistic example, see % the definition of style \ikeyname{GP1}: before packing, \texttt{outer xsep} is set to a high (user % determined) value to keep the $\times$s uniformly spaced; before drawing the tree, the % \texttt{outer xsep} is set to \texttt{0pt} to make the arrows look better. % % Second, the execution of the processing stages \ref{step:typeset-nodes}--\ref{step:draw-tree} is % \emph{completely} under user's control. To facilitate adjusting the processing flow, the approach % is twofold. The outer level: \foRest; initiates the processing by executing style % \keyname{stages}, which by default executes the processing stages % \ref{step:typeset-nodes}--\ref{step:draw-tree}, preceding the execution of each stage by % processing the options embedded in temporal propagators \keyname{before ...} (see % \S\ref{ref:propagators}). The inner level: each processing step is the sole resident of a % stage-style, which makes it easy to adjust the workings of a single step. What follows is the % default content of style \keyname{stages}, including the default content of the individual % stage-styles. % \begin{syntax} % \rkeyname[item]{stages} % \begin{syntax} % \item \ikeyname{process keylist}|=|\ikeyname{before typesetting nodes} % \rkeyname[item]{typeset nodes stage}\hfill % |{|\ikeyname{id={{for }}}\ikeyname{root'}|=|\ikeyname{typeset nodes}|}| % \item \ikeyname{process keylist}|=|\ikeyname{before packing} % \rkeyname[item]{pack stage}\hfill % |{|\ikeyname{id={{for }}}\ikeyname{root'}|=|\ikeyname{pack}|}| % \item \ikeyname{process keylist}|=|\ikeyname{before computing xy} % \rkeyname[item]{compute xy stage}\hfill % |{|\ikeyname{id={{for }}}\ikeyname{root'}|=|\ikeyname{compute xy}|}| % \item \ikeyname{process keylist}|=|\ikeyname{before drawing tree} % \rkeyname[item]{draw tree stage}\hfill % |{|\ikeyname{id={{for }}}\ikeyname{root'}|=|\ikeyname{draw tree}|}| % \end{syntax} % \end{syntax} % % Both style \keyname{stages} and the individual stage-styles may be freely modified by the user. % Obviously, a style must be redefined before it is processed, so it is safest to do so either % outside the \ikeyname{forest} environment (using macro \icmdname{forestset}) or in the preamble % (in a non-deferred fashion). % % Here's the list of keys used either in the default processing or useful in an alternative % processing flow. % \begin{syntax} % \rkeyname[item]{typeset nodes} Typesets each node of the current node's subtree in its own % |tikzpicture| environment. The result is saved in a box and its measures are taken. % % \rkeyname[item]{typeset nodes'} Like \ikeyname{typeset nodes}, but the node box's content is not % overwritten if the box already exists. % % \rkeyname[item]{typeset node} Typesets the \emph{current} node, saving the result in the node box. % % This key can be useful also in the default \ikeyname{stages}. If, for example, the node's content % is changed and the node retypeset just before drawing the tree, the node will be positioned as if % it contained the ``old'' content, but have the new content: this is how the constant distance % between $\times$s is implemented in the \ikeyname{GP1} style. % % \rkeyname[item]{pack} The nodes of the tree are \emph{packed}, i.e.\ the relative positions of % the nodes are computed so that the nodes don't overlap. The result: option \ikeyname{s} is set % for all nodes; sometimes (in tier alignment and for some values of \ikeyname{calign}), the value % of some nodes' \ikeyname{l} is adjusted as well. % % \rkeyname[item]{pack'} ``Non-recursive'' packing: packs the children of the current node only. % (Experimental, use with care, especially when combining with tier alignment.) % % \rkeyname[item]{compute xy} Computes the positions of the nodes relative to the (formal) root % node. The results are stored into options \ikeyname{x} and \ikeyname{y}. % % \rkeyname[item]{draw tree} Produces the \TikZ; code that will draw the tree. First, the nodes % are drawn (using the boxes typeset in step~\ref{step:typeset-nodes}), followed by edges and % custom code (see option \ikeyname{tikz}). % % \rkeyname[item]{draw tree'} Like \ikeyname{draw tree}, but the node boxes are included in the % picture using \cmdname{copy}, not \cmdname{box}, thereby preserving them. % % \rkeyname[item]{draw tree box}|=|[\meta{\TeX\ box}] The picture drawn by the subsequent % invocations of \ikeyname{draw tree} and \ikeyname{draw tree'} is put into \meta{\TeX\ box}. If % the argument is omitted, the subsequent pictures are typeset normally (the default). % % \rkeyname[item]{process keylist}|=|\meta{keylist option name} Processes the keylist saved in % option \meta{keylist option name} for all the nodes in the \emph{whole} tree. % % This key is not sensitive to the current node: it processes the keylists for the whole tree. % The calls of this key should \emph{not} be nested. % % Keylist-processing proceeds in cycles. In a given cycle, the value of option \meta{keylist % option name} is processed for every node, in a recursive (parent-first, depth-first) fashion. % During a cycle, keys may be \emph{delayed} using key \ikeyname{delay}. (Keys of the dynamically % created nodes are automatically delayed.) Keys delayed in a cycle are processed in the next % cycle. The number of cycles in unlimited. When no keys are delayed in a cycle, the processing % of a hook is finished. % \end{syntax} % % \subsubsection{Dynamic tree} % \label{ref:dynamic} % % The following keys can be used to change the geometry of the tree by creating new nodes and % integrating them into the tree, moving and copying nodes around the tree, and removing nodes from % the tree. % % The node that will be (re)integrated into the tree can be specified in the following ways: % \begin{syntax} % \item \meta{empty}: uses the last (non-integrated, i.e.\ created/removed/replaced) node. % \item \meta{node}: a new node is created using the given bracket representation (the node may % contain children, i.e.\ a tree may be specified), and used as the argument to the key. % % The bracket representation must be enclosed in brackets, which will usually be enclosed in % braces to prevent them being parsed while parsing the ``host tree.'' % \item \imeta{relative node name}: the node \meta{relative node name} resolves to will be used. % \end{syntax} % % Here is the list of dynamic tree keys: % % \begin{syntax} % \rkeyname[item]{append}|=|\meta{empty}\OR|[|\meta{node}|]|\OR\meta{relative node name} % % The specified node becomes the new final child of the current node. If the specified node had a % parent, it is first removed from its old position. % % \begin{forestexample}[label=ex:append,point=append,ekeynames={append,delay,for tree,n,content,n',repeat}] % \begin{forest} % before typesetting nodes={for tree={ % if n=1{content=L} % {if n'=1{content=R} % {content=C}}}} % [,repeat=2{append={[ % ,repeat=3{append={[]}} % ]}}] % \end{forest} % \end{forestexample} % % \rkeyname[item]{create}|=[|\meta{node}|]| % % Create a new node. The new node becomes the last node. % % \rkeyname[item]{insert after}|=|\meta{empty}\OR|[|\meta{node}|]|\OR\meta{relative node name} % % The specified node becomes the new following sibling of the current node. If the specified node had a % parent, it is first removed from its old position. % % \rkeyname[item]{insert before}|=|\meta{empty}\OR|[|\meta{node}|]|\OR\meta{relative node name} % % The specified node becomes the new previous sibling of the current node. If the specified node had a % parent, it is first removed from its old position. % % \rkeyname[item]{prepend}|=|\meta{empty}\OR|[|\meta{node}|]|\OR\meta{relative node name} % % The specified node becomes the new first child of the current node. If the specified node had a % parent, it is first removed from its old position. % % \rkeyname[item]{remove} % % The current node is removed from the tree and becomes the last node. % % The node itself is not deleted: it is just not integrated in the tree anymore. Removing the root % node has no effect. % % \rkeyname[item]{replace by}|=|\meta{empty}\OR|[|\meta{node}|]|\OR\meta{relative node name} % % The current node is replaced by the specified node. The current node becomes the last node. % % It the specified node is a new node containing a dynamic tree key, it can refer to the replaced % node by the \meta{empty} specification. This works even if multiple replacements are made. % % If \keyname{replace by} is used on the root node, the ``replacement'' becomes the root node % (\ikeyname{set root} is used). % % \rkeyname[item]{set root} % % The current node becomes the new \emph{formal} root of the tree. % % Note: If the current node has a parent, it is \emph{not} removed from it. The node becomes the % root only in the sense that the default implementation of stage-processing will consider it a % root, and thus typeset/pack/draw the (sub)tree rooted in this root. The processing of keys such % as \ikeyname{for parent} and \ikeyname{for root} is not affected: \ikeyname{for root} finds the % real, geometric root of the current node. To access the formal root, use node walk step % \ikeyname{root'}, or the corresponding propagator \ikeyname{id={{for }}}\ikeyname{root'}. % \end{syntax} % % If given an existing node, most of the above keys \emph{move} this node % (and its subtree, of course). Below are the versions of these operations which rather \emph{copy} % the node: either the whole subtree (|'|) or just the node itself (|''|). % \begin{syntax} % \rkeyname[item]{append'}, \rkeyname{insert after'}, \rkeyname{insert before'}, \rkeyname{prepend'}, % \rkeyname{replace by'} % % Same as versions without |'| (also the same arguments), but it is the copy of the specified node % and its subtree that is integrated in the new place. % \rkeyname[item]{append''}, \rkeyname{insert after''}, \rkeyname{insert before''}, \rkeyname{prepend''}, % \rkeyname{replace by''} % % Same as versions without |''| (also the same arguments), but it is the copy of the specified node % (without its subtree) that is integrated in the new place. % \rkeyname[item]{copy name template}|=|\meta{empty}\OR\meta{macro definition} \hfill\meta{empty} % % Defines a template for constructing the \ikeyname{name} of the copy from the name of the % original. \meta{macro definition} should be either empty (then, the \ikeyname{name} is % constructed from the \ikeyname{id=id}, as usual), or an expandable macro taking one argument (the % name of the original). % \end{syntax} % % \begin{advise} % \item You might want to \ikeyname{delay} the processing of the copying operations, giving the % original nodes the chance to process their keys first! % \end{advise} % % \begin{forestexample} % \begin{forest} % copy name template={copy of #1} % [CP,delay={prepend'=subject} % [VP[DP,name=subject[D][NP]][V'[V][DP]]]] % \draw[->,dotted] (subject)--(copy of subject); % \end{forest} % \end{forestexample} % % A dynamic tree operation is made in two steps: % \begin{itemize} % \item If the argument is given by a \meta{node} argument, the new node is created immediately, % i.e.\ while the dynamic tree key is being processed. Any options of the new node are % implicitely \ikeyname{delay}ed. % \item The requested changes in the tree structure are actually made between the cycles of keylist % processing. % \end{itemize} % % \begin{advise} % \item Such a two-stage approach is employed because changing the tree structure during the dynamic % tree key processing would lead to an unmanageable order of keylist processing. % \item A consequence of this approach is that nested dynamic tree keys take several cycles to % complete. Therefore, be careful when using \ikeyname{delay} and dynamic tree keys % simultaneously: in such a case, it is often safer to use \ikeyname{before typesetting nodes} % instead of \ikeyname{delay}, see example \ref{ex:append}. % \item Further examples: title page (in style |random tree|), \ref{ex:xlist}. % \end{advise} % % \subsection{Handlers} % \label{ref:handlers} % % \begin{syntax} % \rkeyname[item]{id=.pgfmath,nfc}|=|\meta{pgfmath expression} % % The result is the evaluation of \meta{pgfmath expression} in the context of the current node. % % \rkeyname[item]{id=.wrap value,nfc}|=|\meta{macro definition} % % The result is the (single) expansion of the given % \meta{macro definition}. The defined macro takes one parameter. The current value of the % handled option will be passed as that parameter. % % \rkeyname[item]{id=.wrap $n$ pgfmath args,nfc}|=|\meta{macro definition}\meta{arg $1$}\dots\meta{arg $n$} % % The result is the (single) expansion of the given \meta{macro definition}. The defined macro % takes $n$ parameters, where $n\in\{2,\dots,8\}$. Expressions \meta{arg $1$} to \meta{arg $n$} % are evaluated using |pgfmath| and passed as arguments to the defined macro. % % \rkeyname[item]{id=.wrap pgfmath arg,nfc}|=|\meta{macro definition}\meta{arg} % % Like \ikeyname{id=.wrap $n$ pgfmath args,nfc} for $n=1$. % \end{syntax} % % \subsection{Relative node names} % \label{ref:relative-node-names} % % \begin{syntax} % \item\rmeta{relative node name}|=|[\meta{forest node name}][|!|\meta{node walk}] % % \meta{relative node name} refers to the \foRest; node at the end of the \meta{node walk} % starting at node named \meta{forest node name}. If \meta{forest node name} is omitted, the walk % starts at the current node. If \meta{node walk} is omitted, the ``walk'' ends at the start % node. (Thus, an empty \meta{relative node name} refers to the current node.) % \end{syntax} % % Relative node names can be used in the following contexts: % \begin{itemize} % \item \FoRest;'s |pgfmath| option functions (\S\ref{ref:pgfmath}) take a relative node name as % their argument, e.g.\ |content("!u")| and |content("!parent")| refer to the content of the % parent node. % \item An option of a non-current node can be set by \meta{relative node name}|.|\meta{option % name}|=|\meta{value}, see \S\ref{ref:options-and-keys}. % \item The |forest| coordinate system, both explicit and implicit; see \S\ref{ref:forest-cs}. % \end{itemize} % % \subsubsection{Node walk} % \label{ref:node-walk} % % A \rmeta{node walk} is a sequence of \rmeta{step}s describing a path through the tree. % The primary use of node walks is in relative node names. However, they can also be used in a % ``standalone'' way, using key \ikeyname{node walk}; see \S\ref{ref:miscellaneous}. % % Steps are keys in the \keyname{/forest/node walk} path. (\foRest; always sets this path as % default when a node walk is to be used, so step keynames can be used.) Formally, a \meta{node % walk} is thus a keylist, and steps must be separated by commas. There is a twist, however. Some % steps also have \emph{short} names, which consist of a single character. The comma between two % adjacent short steps can be omitted. Examples: % \begin{itemize} % \item |parent,parent,n=2| or |uu2|: the grandparent's second child (of the current node) % \item |first leaf,uu|: the grandparent of the first leaf (of the current node) % \end{itemize} % The list of long steps: % \newcommand\nwritem[1]{\rkeyname[item]{#1,aspect=step}\ekeyname{for #1,aspect=propagator,def}} % \begin{syntax} % \nwritem{current} an ``empty'' step: the current node remains the same\footnote{While it % might at first sight seem stupid to have an empty step, this is not the case. For example, % using propagator \ikeyname{for current} derived from this step, one can process a \meta{keylist} % constructed using \texttt{.wrap (n) pgfmath arg(s)}\ekeyname{id=.wrap % pgfmath arg,nfc}\ekeyname{id=.wrap $n$ pgfmath args,nfc} or \ikeyname{id=.wrap value,nfc}.} % \nwritem{first} the primary child % \nwritem{first leaf} the first leaf (terminal node) % \rkeyname[item]{group,aspect=step}|=|\meta{node walk} treat the given \meta{node walk} as a single step % \nwritem{last} the last child % \nwritem{last leaf} the last leaf % \nwritem{id=id}|=|\meta{id} the node with the given id % \nwritem{linear next} the next node, in the processing order % \nwritem{linear previous} the previous node, in the processing order % \nwritem{n}|=|$n$ the $n$th child; counting starts at $1$ (not $0$) % \nwritem{n'}|=|$n$ the $n$th child, starting the count from the last child % \nwritem{name} the node with the given name % \nwritem{next} the next sibling % \nwritem{next leaf} the next leaf % % (the current node need not be a leaf) % \nwritem{next on tier} the next node on the same tier as the current node % \rkeyname[item]{node walk,aspect=step}|=|\meta{node walk} embed the given \meta{node walk} % % (the \ikeyname{id={node walk/before walk}} and \ikeyname{id={node walk/after walk}} are processed) % \nwritem{parent} the parent % \nwritem{previous} the previous sibling % \nwritem{previous leaf} the previous leaf % % (the current node need not be a leaf) % \nwritem{previous on tier} the next node on the same tier as the current node % \rkeyname[item]{repeat}|=|$n$\meta{node walk} repeat the given \meta{node walk} $n$ times % % (each step in every repetition counts as a step) % \nwritem{root} the root node % \nwritem{root'} the formal root node (see \ikeyname{set root} in \S\ref{ref:dynamic}) % \nwritem{sibling} the sibling % % (don't use if the parent doesn't have exactly two children \dots) % \nwritem{to tier}|=|\meta{tier} the first ancestor of the current node on the given \meta{tier} % \rkeyname[item]{trip,aspect=step}|=|\meta{node walk} after walking the embedded \meta{node walk}, return to the % current node; the return does not count as a step % \end{syntax} % % For each long \meta{step} except \keyname{node walk}, \keyname{group}, \keyname{trip} and % \keyname{repeat}, propagator \ikeyname{id={{for }}}\meta{step} is also defined. Each such % propagator takes a \meta{keylist} argument. If the step takes an argument, then so does its % propagator; this argument precedes the \meta{keylist}. See also \S\ref{ref:propagators}. % % Short steps are single-character keys in the \keyname{/forest/node walk} path. They are defined % as styles resolving to long steps, e.g.\ |1/.style={n=1}|. The list of predefined short steps % follows. % \begin{syntax} % \rkeyname[item]{1}, % \rkeyname{2}, % \rkeyname{3}, % \rkeyname{4}, % \rkeyname{5}, % \rkeyname{6}, % \rkeyname{7}, % \rkeyname{8}, % \rkeyname{9} the first, \dots, ninth child % \rkeyname[item]{l,aspect=short step} the last child % \rkeyname[item]{u} the parent (up) % \rkeyname[item]{p} the previous sibling % \rkeyname[item]{n,aspect=short step} the next sibling % \rkeyname[item]{s,aspect=short step} the sibling % \rkeyname[item]{P} the previous leaf % \rkeyname[item]{N} the next leaf % \rkeyname[item]{F} the first leaf % \rkeyname[item]{L} the last leaf % \rkeyname[item]{id=<<<,display=\protect\myindexgt,text=>,aspect=short step} % the next node on the current tier % \rkeyname[item]{<} the previous node on the current tier % \rkeyname[item]{c} the current node % \rkeyname[item]{r} the root node % \end{syntax} % \begin{advise} % \item You can define your own short steps, or even redefine predefined short steps! % \end{advise} % % \subsubsection{The \texttt{forest} coordinate system} % \label{ref:forest-cs} % % Unless package options \ikeyname{tikzcshack} is set to |false|, \TikZ;'s implicit node coordinate % system \citep[\S13.2.3]{tikzpgf2.10} is hacked to accept relative node names.\footnote{Actually, % the hack can be switched on and off on the fly, using \cmdname{i}\keyname{fforesttikzcshack}.}. % % The explicit \texttt{forest} coordinate system is called simply |forest| and used like this: % |(forest_cs:|\meta{forest cs spec}|)|; see \citep[\S13.2.5]{tikzpgf2.10}. \meta{forest cs spec} % is a keylist; the following keys are accepted. % % \begin{syntax} % \rkeyname[item]{name,aspect=forest cs}|=|\meta{node name} The node with the given name becomed the current node. The % resulting point is its (node) anchor. % \rkeyname[item]{id=id,aspect=forest cs}|=|\meta{node id} The node with the given name becomed the current node. The % resulting point is its (node) anchor. % \rkeyname[item]{go,aspect=forest cs}|=|\meta{node walk} Walk the given node walk, starting at the current node. The node % at the end of the walk becomes the current node. The resulting point is its (node) anchor. % \rkeyname[item]{anchor,aspect=forest cs}|=|\meta{anchor} The resulting point is the given anchor of the current node. % \rkeyname[item]{l,aspect=forest cs}|=|\meta{dimen} \vspace{-\parskip} % \rkeyname[item]{s,aspect=forest cs}|=|\meta{dimen} Specify the \ikeyname{l} and \ikeyname{s} % coordinate of the resulting point. % % The coordinate system is the node's ls-coordinate system: its origin is at its (node) anchor; the % l-axis points in the direction of the tree growth at the node, which is given by option % \ikeyname{grow}; the s-axis is orthogonal to the l-axis; the positive side is in the % counter-clockwise direction from |l| axis. % % The resulting point is computed only after both \ikeyname{l} and \ikeyname{s} were given. % \item Any other key is interpreted as a \imeta{relative node name}[.\meta{anchor}]. % \end{syntax} % % \subsection{New \texttt{pgfmath} functions} % \label{ref:pgfmath} % % For every option, \foRest; defines a pgfmath function with the same name, with the % proviso that all non-alphanumeric characters in the option name are replaced by an underscore % |__| in the pgfmath function name. % % Pgfmath functions corresponding to options take one argument, a \imeta{relative node name} % (see~\S\ref{ref:relative-node-names}) expression, making it possible to refer to option values of % non-current nodes. The \meta{relative node name} expression must be enclosed in double quotes in % order to % prevent pgfmath evaluation: for example, to refer to the content of the parent, write % \ikeyname{content}|("!u")|. To refer to the option of the current node, use empty parentheses: % \ikeyname{content}|()|.\footnote{In most cases, the parentheses are optional, so \texttt{content} % is ok. A known case where this doesn't work is preceding an operator: \texttt{l+1cm} will fail.} % % Three string functions are also added to |pgfmath|: \rkeyname{strequal} tests the equality of % its two arguments; \rkeyname{instr} tests if the first string is a substring of the second one; % \rkeyname{strcat} joins an arbitrary number of strings. % % Some random notes on |pgfmath|: \begin{inparaenum}[(i)] % \item |&&|, \verb!||! and |!| are boolean ``and'', ``or'' and ``not'', respectively. % \item The equality operator (for numbers and dimensions) is |==|, \emph{not} |=|. % \end{inparaenum} And some examples: % % \begin{forestexample}[pos=t,ekeynames={for tree,grow',calign,l,l sep,child % anchor,anchor,fit,tier,level,delay,before typesetting nodes,content,{id=.wrap 2 pgfmath args,nfc},{id=.pgfmath,nfc}}] % \begin{forest} % for tree={grow'=0,calign=first,l=0,l sep=2em,child anchor=west,anchor=base % west,fit=band,tier/.pgfmath=~level~()}, % fullpath/.style={if n=0{}{content/.wrap 2 % pgfmath args={##1/##2}{~content~("!u")}{~content~()}}}, % delay={for tree=fullpath,content=/}, % before typesetting nodes={for tree={content=\strut#1}} % [ % [home % [joe % [\TeX]] % [saso % [\TeX]] % [a user with a long name % [\TeX]]] % [usr]] % \end{forest} % \end{forestexample} % % \begin{forestexample}[point=instr,ekeynames={delay,for tree,if,content,n children}] % \begin{forest} % delay={for tree={if= % {!instr("!P",~content~) && ~n_children~==0} % {fill=yellow} % {} % }} % [CP[DP][C'[C][TP[DP][T'[T][VP[DP][V'[V][DP]]]]]]] % \end{forest} % \end{forestexample} % % \begin{forestexample}[point=instr,ekeynames={where ,n children,tier,content,no edge,tikz}] % \begin{forest} % where n children=0{tier=word, % if={~instr~("!P",~content~("!u"))}{no edge, % tikz={\draw (!.north west)-- % (!.north east)--(!u.south)--cycle; % }}{} % }{}, % [VP[DP[John]][V'[V[loves]][DP[Mary]]]] % \end{forest} % \end{forestexample} % % % \subsection{Standard node} % \label{ref:standard-node} % % \begin{syntax} % \item\rcmdname{forestStandardNode}\meta{node}\meta{environment fingerprint}\meta{calibration % procedure}\meta{exported options} % % This macro defines the current \emph{standard node}. The standard node declares some options as % \emph{exported}. When a new node is created, the values of the exported options are initialized % from the standard node. At the beginning of every \ikeyname{forest} environment, it is checked whether % the \emph{environment fingerprint} of the standard node has changed. If it did, the standard % node is \emph{calibrated}, adjusting the values of exported options. The \emph{raison d'etre} for % such a system is given in \S\ref{sec:defaults}. % % In \meta{node}, the standard node's content and possibly other options are specified, using the % usual bracket representation. The \meta{node}, however, \emph{must not contain children}. The % default: \texttt{[dj]}. % % The \meta{environment fingerprint} must be an expandable macro definition. It's expansion % should change whenever the calibration is necessary. % % \meta{calibration procedure} is a keylist (processed in the |/forest| path) which calculates the % values of exported options. % % \meta{exported options} is a comma-separated list of exported options. % % This is how the default standard node is created: % \begin{lstlisting} % \forestStandardNode[dj] % {% % \forestOve{\csname forest@id@of@standard node\endcsname}{content},% % \the\ht\strutbox,\the\pgflinewidth,% % \pgfkeysvalueof{/pgf/inner ysep},\pgfkeysvalueof{/pgf/outer ysep},% % \pgfkeysvalueof{/pgf/inner xsep},\pgfkeysvalueof{/pgf/outer xsep}% % } % { % l sep={\the\ht\strutbox+\pgfkeysvalueof{/pgf/inner ysep}}, % l={l_sep()+abs(max_y()-min_y())+2*\pgfkeysvalueof{/pgf/outer ysep}}, % s sep={2*\pgfkeysvalueof{/pgf/inner xsep}} % } % {l sep,l,s sep} % \end{lstlisting} % \end{syntax} % % \subsection{Externalization} % \label{ref:externalization} % % Externalized tree pictures are compiled only once. The result of the compilation is saved into a % separate |.pdf| file and reused on subsequent compilations of the document. If the code of the % tree (or the context, see below) is changed, the tree is automatically recompiled. % % Externalization is enabled by: % \begin{lstlisting} % \usepackage[~external~]{forest} % ~\tikzexternalize~ % \end{lstlisting} % Both lines are necessary. \TikZ;'s externalization library is automatically loaded if necessary. % % \begin{syntax} % \rkeyname[item]{id={external/optimize}} Parallels \keyname{/tikz/external/optimize}: if |true| (the % default), the processing of non-current trees is skipped during the embedded compilation. % \rkeyname[item]{id={external/context}} If the expansion of the macro stored in % this option changes, the tree is recompiled. % \rkeyname[item]{id={external/depends on macro}}|=|\meta{cs} Adds the definition of macro \meta{cs} to % \keyname{external/context}. Thus, if the definition of \meta{cs} is changed, the tree will be % recompiled. % \end{syntax} % % \foRest; respects or is compatible with several (not all) keys and commands of \TikZ;'s % externalization library. In particular, the following keys and commands might be useful; see % \cite[\S32]{tikzpgf2.10}. % \begin{itemize} % \item\keyname{/tikz/external/remake next} % \item\keyname{/tikz/external/prefix} % \item\keyname{/tikz/external/system call} % \item\cmdname{tikzexternalize} % \item\cmdname{tikzexternalenable} % \item\cmdname{tikzexternaldisable} % \end{itemize} % \FoRest; does not disturbe the externalization of non-\foRest; pictures. (At least it % shouldn't \dots) % % The main auxiliary file for externalization has suffix |.for|. The externalized pictures have % suffices |-forest-|$n$ (their prefix can be set by \keyname{/tikz/external/prefix}, e.g.\ to a % subdirectory). Information on all trees that were ever externalized in the document (even if % they were changed or deleted) is kept. If you need a ``clean'' |.for| file, delete it and % recompile. Deleting |-forest-|$n$|.pdf| will result in recompilation of a specific tree. % % Using \keyname{draw tree} and \keyname{draw tree'} multiple times \emph{is} compatible with % externalization, as is drawing the tree in the box (see \ikeyname{draw tree box}). If you are % trying to externalize a \ikeyname{forest} environment which utilizes \ikeyname{TeX} to produce a % visible effect, you will probably need to use \ikeyname{TeX'} and/or \ikeyname{TeX''}. % % \subsection{Package options} % \label{ref:package-options} % % \begin{syntax} % \rkeyname[item=false]{external}|=|\alternative{true,false} % % Enable/disable externalization, see \S\ref{ref:externalization}. % \rkeyname[item=true]{tikzcshack}|=|\alternative{true,false} % % Enable/disable the hack into \TikZ;'s implicite coordinate syntax hacked, see % \S\ref{ref:relative-node-names}. % % \rkeyname[item=true]{tikzinstallkeys}|=|\alternative{true,false} % % Install certain keys into the \keyname{/tikz} path. Currently: \ikeyname{fit to tree}. % \end{syntax} % % \section{Gallery} % \label{sec:gallery} % % % \subsection{Styles} % \label{sec:gallery-styles} % % \paragraph{\rkeyname{GP1}} % For Government Phonology (v1) representations. Here, the big trick % is to evenly space $\times$s by having a large enough |outer_xsep| % (adjustable), and then, before drawing (timing control option % |before_drawing_tree|), setting |outer_xsep| back to 0pt. The last step % is important, otherwise the arrows between $\times$s won't draw! % % \box\GPone % % An example of an ``embedded'' |GP1| style: % \begin{forestexample}[pos=b,ekeynames={where ,tier,for children,content,tikz,l,+,no edge}] % \begin{forest} % myGP1/.style={ % ~GP1~, % delay={where tier={x}{ % for children={content=\textipa{##1}}}{}}, % tikz={\draw[dotted](.south)-- % (!1.north west)--(!l.north east)--cycle;}, % for children={l+=5mm,no edge} % } % [VP[DP[John,tier=word,myGP1 % [O[x[dZ]]] % [R[N[x[6]]]] % [O[x[n]]] % [R[N[x]]] % ]][V'[V[loves,tier=word,myGP1 % [O[x[l]]] % [R[N[x[a]]]] % [O[x[v]]] % [R[N[x]]] % [O[x[z]]] % [R[N[x]]] % ]][DP[Mary,tier=word,myGP1 % [O[x[m]]] % [R[N[x[e]]]] % [O[x[r]]] % [R[N[x[i]]]] % ]]]] % \end{forest}% % \end{forestexample} % % And an example of annotations. % \begin{forestexample} % \begin{forest}[,phantom,s sep=1cm % [{[ei]}, GP1 % [R[N[x[A,~el~[I,~head~,~associate=N~]]][x]]] % ] % [{[mars]}, GP1 % [O[x[m]]] % [R[N[x[a]]][x,~encircle~,densely dotted[r]]] % [O[x,~encircle~,~govern=<~[s]]] % [R,~fen~[N[x]]] % ] % ]\end{forest} % \end{forestexample} % % % \paragraph{rlap and llap} The \foRest; versions of \TeX's \cmdname{rlap}\ and \cmdname{llap}: the % ``content'' added by these styles will influence neither the packing algorithm nor the anchor % positions. % \begin{forestexample}[pos=b,point={rlap,llap},ekeynames={TeX,delay,where ,tier,content,GP1}] % \forestset{ % llap/.style={tikz+={ % \edef\forest@temp{\noexpand\node[\forestoption{node options}, % anchor=base east,at=(.base east)]} % \forest@temp{#1\phantom{\forestoption{content format}}}; % }}, % rlap/.style={tikz+={ % \edef\forest@temp{\noexpand\node[\forestoption{node options}, % anchor=base west,at=(.base west)]} % \forest@temp{\phantom{\forestoption{content format}}#1}; % }} % } % \newcount\xcount % \begin{forest} GP1, % delay={ % TeX={\xcount=0}, % where tier={x}{TeX={\advance\xcount1},rlap/.expanded={$_{\the\xcount}$}}{} % } % [ % [O[x[f]]] % [R[N[x[o]]]] % [O[x[r]]] % [R[N[x[e]]][x[s]]] % [O[x[t]]] % [R[N[x]]] % ] % \end{forest} % \end{forestexample} % % \paragraph{xlist} This style makes it easy to put ``separate'' % trees in a picture and enumerate them. For an example, see the |nice_empty_nodes| % style. % \begin{forestexample}[pos=t,label=ex:xlist] % \makeatletter % \forestset{ % xlist/.style={ % phantom, % for children={no edge,replace by={[,append, % delay={content/.wrap pgfmath arg={\@alph{##1}.}{n()+#1}} % ]}} % }, % xlist/.default=0 % } % \makeatother % \end{forestexample} % \input{\jobname.tmp} % % \paragraph{nice empty nodes} % We often need empty nodes: tree (a) shows how they look like by % default: ugly. % % First, we don't want the gaps: we change the shape of empty nodes to coordinate. We get tree (b). % % Second, the empty nodes seem too close % to the other (especially empty) nodes (this is a result of a small % default |s_sep|). We could use a greater \ikeyname{s sep}, but a better solution seems % to be to use |calign=node_angle|. The result is shown in (c). % % However, at the transitions from empty to non-empty nodes, tree (d) % above seems to zigzag (although the base points of the spine nodes % are perfectly in line), and the edge to the empty node left to VP % seems too long (it reaches to the level of VP's base, while we'd % prefer it to stop at the same level as the edge to VP itself). The % first problem is solved by substituting |node_angle| for % |edge_angle|; the second one, by anchoring siblings of % empty nodes at north. % \begin{forestexample}[pos=b,ekeynames={fixed angles,fixed edge angles,calign,for tree,delay,where % ,content,for ,parent,for children,anchor}] % \forestset{ % ~nice empty nodes~/.style={ % for tree={calign=fixed edge angles}, % delay={where content={}{shape=coordinate,for parent={for children={anchor=north}}}{}} % }} % \begin{forest} % [,~xlist~ % [CP, %(a) % [][[][[][VP[DP[John]][V'[V[loves]][DP[Mary]]]]]]] % [CP, delay={where content={}{shape=coordinate}{}} %(b) % [][[][[][VP[DP[John]][V'[V[loves]][DP[Mary]]]]]]] % [CP, for tree={calign=fixed angles}, %(c) % delay={where content={}{shape=coordinate}{}} % [][[][[][VP[DP[John]][V'[V[loves]][DP[Mary]]]]]]] % [CP, ~nice empty nodes~ %(d) % [][[][[][VP[DP[John]][V'[V[loves]][DP[Mary]]]]]]] % ] % \end{forest} % \end{forestexample} % % % \subsection{Examples} % \label{sec:examples} % % The following example was inspired by a question on \TeX\ Stackexchange: % \href{http://tex.stackexchange.com/questions/39103/how-to-change-the-level-distance-in-tikz-qtree-for-one-level-only}{How to change the level distance in tikz-qtree for one level only?}. The question is about |tikz-qtree|: how to adjust the level distance for the first level only, in order to avoid first-level labels crossing the parent--child edge. While this example solves the problem (by manually shifting the offending labels; see \texttt{elo} below), it does more: the preamble is setup so that inputing the tree is very easy. % % \begin{forestexample}[pos=t,ekeynames={id={{if }},n,no edge,tikz,strequal,strcat,child anchor,parent % anchor,anchor,calign,for tree,s sep,l,n children,declare toks,delay,content,before typesetting nodes,for descendants,+,{id=.wrap pgfmath arg,nfc},{id=.wrap 2 pgfmath args,nfc}}] % \def\getfirst#1;#2\endget{#1} % \def\getsecond#1;#2\endget{#2} % \forestset{declare toks={elo}{}} % edge label options % \begin{forest} % anchors/.style={anchor=#1,child anchor=#1,parent anchor=#1}, % for tree={ % s sep=0.5em,l=8ex, % if n children=0{anchors=north}{ % if n=1{anchors=south east}{anchors=south west}}, % content format={$\forestoption{content}$} % }, % anchors=south, outer sep=2pt, % nomath/.style={content format=\forestoption{content}}, % dot/.style={tikz+={\fill (.child anchor) circle[radius=#1];}}, % dot/.default=2pt, % dot=3pt,for descendants=dot, % decision edge label/.style n args=3{ % edge label/.expanded={node[midway,auto=#1,anchor=#2,\forestoption{elo}]{\strut$#3$}} % }, % decision/.style={if n=1 % {decision edge label={left}{east}{#1}} % {decision edge label={right}{west}{#1}} % }, % delay={for descendants={ % decision/.expanded/.wrap pgfmath arg={\getsecond#1\endget}{content}, % content/.expanded/.wrap pgfmath arg={\getfirst#1\endget}{content}, % }}, % [N,nomath % [I;{p_1=0.5},nomath,elo={yshift=4pt} % [{5,1};a] % [II;b,nomath % [{1,2};m] % [{2,3};n] % ] % ] % [II;{p_2=0.5},nomath,elo={yshift=4pt} % [;c % [{1,0};z] % [{2,2};t] % ] % [;d % [{3,1};z] % [{0,0};t] % ] % ] {\draw[dashed](!1.anchor)--(!2.anchor) node[pos=0.5,above]{I};} % ] % \end{forest} % \end{forestexample} % % % \section{Known bugs} % \label{sec:bugs} % % If you find a bug (there are bound to be some \dots), please contact % me at \href{mailto:saso.zivanovic@guest.arnes.si}{saso.zivanovic@guest.arnes.si}. % % \paragraph{System requirements} This package requires \LaTeX\ and e\TeX. If you use something % else: sorry. % % The requirement for \LaTeX\ might be dropped in the future, when I get some time and energy for a % code-cleanup (read: to remedy the consequences of my bad programming practices and general % disorganization). % % The requirement for e\TeX\ will probably stay. If nothing else, \foRest; is heavy on boxes: every % node requires its own \dots\ and consequently, I have freely used e\TeX\ constructs in the code % \dots % % \paragraph{\PGF; internals} \FoRest; relies on some details of \PGF; implementation, like the name % of the ``not yet positioned'' nodes. Thus, a new bug might appear with the development of \PGF;. % If you notice one, please let me know. % % \paragraph{Edges cutting through sibling nodes} % \label{sec:cutting-edge} % % In the following example, the R--B edge crosses the AAA node, although \ikeyname{ignore edge} is % set to the default |false|. % \begin{forestexample}[ekeynames={calign,{first,aspect=calign},align,{center,aspect=align},base,{bottom,aspect=base}}] % \begin{forest} % calign=first % [R[AAAAAAAAAA\\AAAAAAAAAA\\AAAAAAAAAA,align=center,base=bottom][B]] % \end{forest} % \end{forestexample} % This happens because s-distances between the adjacent children are % computed before child alignment (which is obviously the correct order in the general case), but % child alignment non-linearly influences the edges. Observe that the with a different value of % \ikeyname{calign}, the problem does not arise. % \begin{forestexample}[ekeynames={calign,{last,aspect=calign},align,{center,aspect=align},base,{bottom,aspect=base}}] % \begin{forest} % calign=last % [R[AAAAAAAAAA\\AAAAAAAAAA\\AAAAAAAAAA,align=center,base=bottom][B]] % \end{forest} % \end{forestexample} % While it would be possible to fix the situation after child alignment (at least for some child % alignment methods), I have decided against that, since the distances between siblings would soon % become too large. If the AAA node in the example above was large enough, B could easily be pushed % off the paper. The bottomline is, please use manual adjustment to fix such situations. % % \paragraph{Orphans} % \label{sec:orphans} % % If the \ikeyname{l} coordinates of adjacent children are too different (as a result of manual adjustment or % tier alignment), the packing algorithm might have nothing so say about the desired distance % between them: in this sense, node C below is an ``orphan.'' % \begin{forestexample}[ekeynames={for tree,s sep,l,*}] % \begin{forest} % for tree={s sep=0,draw}, % [R[A][B][C,l*=2][D][E]] % \end{forest} % \end{forestexample} % To prevent orphans from ending up just anywhere, I have decided to vertically align them with % their preceding sibling --- although I'm not certain that's really the best solution. In other % words, you can rely that the sequence of s-coordinates of siblings is non-decreasing. % % The decision also incluences a similar situation, illustrated below. The packing algorithm puts % node E immediately next to B (i.e.\ under C): however, the monotonicity-retaining mechanism then % vertically aligns it with its preceding sibling, D. % \begin{forestexample}[ekeynames={for tree,s sep,tier}] % \begin{forest} % for tree={s sep=0,draw}, % [R[A[B,tier=bottom]][C][D][E,tier=bottom]] % \end{forest} % \end{forestexample} % % Obviously, both examples also create the situation of an edge crossing some sibling node(s). % Again, I don't think anything sensible can be done about this, in general. % % \section{Changelog} % % \begin{description} % \item[v1.05 (2014/03/07)] \mbox{} % \begin{compactitem} % \item Fix the node boundary code for rounded rectangle. (Patch contributed by Paul Gaborit.) % \end{compactitem} % \item[v1.04 (2013/10/17)] \mbox{} % \begin{compactitem} % \item Fixed an \href{http://tex.stackexchange.com/questions/138986/error-using-tikzexternalize-with-forest/139145}{externalization bug}. % \end{compactitem} % \item[v1.03 (2013/01/28)] \mbox{} % \begin{compactitem} % \item Bugfix: options of dynamically created nodes didn't get processed. % \item Bugfix: the bracket parser was losing spaces before opening braces. % \item Bugfix: a family of utility macros dealing with affixing token lists was not expanding % content correctly. % \item Added style \ikeyname{math content}. % \item Replace key \keyname{tikz preamble} with more general \ikeyname{begin draw} and % \ikeyname{end draw}. % \item Add keys \ikeyname{begin forest} and \ikeyname{end forest}. % \end{compactitem} % \item[v1.02 (2013/01/20)] \mbox{} % \begin{compactitem} % \item Reworked style \ikeyname{stages}: it's easier to modify the processing flow now. % \item Individual stages must now be explicitely called in the context of some (usually root) % node. % \item Added \ikeyname{delay n} and \ikeyname{if have delayed}. % \item Added (experimental) \ikeyname{pack'}. % \item Added reference to the \href{https://github.com/sasozivanovic/forest-styles}{style % repository}. % \end{compactitem} % \item[v1.01 (2012/11/14)] \mbox{} % % \begin{compactitem} % \item Compatibility with the |standalone| package: temporarily disable the effect of % |standalone|'s package option |tikz| while typesetting nodes. % \item Require at least the [2010/08/21] (v2.0) release of package |etoolbox|. % \item Require version [2010/10/13] (v2.10, rcs-revision 1.76) of \PGF;/\TikZ;. Future % compatibility: adjust to the change of the ``not yet positioned'' node name (2.10 |@| % $\rightarrow$ 2.10-csv |PGFINTERNAL|). % \item Add this changelog. % \end{compactitem} % \item[v1.0 (2012/10/31)] First public version % \end{description} % % \paragraph{Acknowledgements} Many thanks to the people who have reported bugs! In the % chronological order: Markus P\"ochtrager, Timothy Dozat, Ignasi Furio.\footnote{If you're in the % list but don't want to be, my apologies and please let me know about it!} % % \newpage % \part{Implementation} % % A disclaimer: the code could've been much cleaner and better-documented \dots % % Identification. % \begin{macrocode} \ProvidesPackage{forest}[2014/03/07 v1.05 Drawing (linguistic) trees] \RequirePackage{tikz}[2010/10/13] \usetikzlibrary{shapes} \usetikzlibrary{fit} \usetikzlibrary{calc} \usepgflibrary{intersections} \RequirePackage{pgfopts} \RequirePackage{etoolbox}[2010/08/21] \RequirePackage{environ} %\usepackage[trace]{trace-pgfkeys} % \end{macrocode} % % |/forest| is the root of the key hierarchy. % \begin{macrocode} \pgfkeys{/forest/.is family} \def\forestset#1{\pgfqkeys{/forest}{#1}} % \end{macrocode} % % \section{Patches} % These patches apply to pgf/tikz 2.10. % % Serious: forest cannot load if this is not patched; disable % \texttt{/handlers/.wrap n pgfmath} for n=6,7,8 if you cannot patch. % \begin{macrocode} \long\def\forest@original@pgfkeysdefnargs@#1#2#3#4{% \ifcase#2\relax \pgfkeyssetvalue{#1/.@args}{}% \or \pgfkeyssetvalue{#1/.@args}{##1}% \or \pgfkeyssetvalue{#1/.@args}{##1##2}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6##7}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6##7##8}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6##7##8##9}% \else \pgfkeys@error{\string\pgfkeysdefnargs: expected <= 9 arguments, got #2}% \fi \pgfkeysgetvalue{#1/.@args}\pgfkeys@tempargs \def\pgfkeys@temp{\expandafter#4\csname pgfk@#1/.@@body\endcsname}% \expandafter\pgfkeys@temp\pgfkeys@tempargs{#3}% % eliminate the \pgfeov at the end such that TeX gobbles spaces % by using % \pgfkeysdef{#1}{\pgfkeysvalueof{#1/.@@body}##1} % (with expansion of '#1'): \edef\pgfkeys@tempargs{\noexpand\pgfkeysvalueof{#1/.@@body}}% \def\pgfkeys@temp{\pgfkeysdef{#1}}% \expandafter\pgfkeys@temp\expandafter{\pgfkeys@tempargs##1}% \pgfkeyssetvalue{#1/.@body}{#3}% } \long\def\forest@patched@pgfkeysdefnargs@#1#2#3#4{% \ifcase#2\relax \pgfkeyssetvalue{#1/.@args}{}% \or \pgfkeyssetvalue{#1/.@args}{##1}% \or \pgfkeyssetvalue{#1/.@args}{##1##2}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6}% %%%%% removed: %%%%% \or %%%%% \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6##7}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6##7##8}% \or \pgfkeyssetvalue{#1/.@args}{##1##2##3##4##5##6##7##8##9}% \else \pgfkeys@error{\string\pgfkeysdefnargs: expected <= 9 arguments, got #2}% \fi \pgfkeysgetvalue{#1/.@args}\pgfkeys@tempargs \def\pgfkeys@temp{\expandafter#4\csname pgfk@#1/.@@body\endcsname}% \expandafter\pgfkeys@temp\pgfkeys@tempargs{#3}% % eliminate the \pgfeov at the end such that TeX gobbles spaces % by using % \pgfkeysdef{#1}{\pgfkeysvalueof{#1/.@@body}##1} % (with expansion of '#1'): \edef\pgfkeys@tempargs{\noexpand\pgfkeysvalueof{#1/.@@body}}% \def\pgfkeys@temp{\pgfkeysdef{#1}}% \expandafter\pgfkeys@temp\expandafter{\pgfkeys@tempargs##1}% \pgfkeyssetvalue{#1/.@body}{#3}% } \ifx\pgfkeysdefnargs@\forest@original@pgfkeysdefnargs@ \let\pgfkeysdefnargs@\forest@patched@pgfkeysdefnargs@ \fi % \end{macrocode} % % Minor: a leaking space in the very first line. % \begin{macrocode} \def\forest@original@pgfpointintersectionoflines#1#2#3#4{% { % % Compute orthogonal vector to #1--#2 % \pgf@process{#2}% \pgf@xa=\pgf@x% \pgf@ya=\pgf@y% \pgf@process{#1}% \advance\pgf@xa by-\pgf@x% \advance\pgf@ya by-\pgf@y% \pgf@ya=-\pgf@ya% % Normalise a bit \c@pgf@counta=\pgf@xa% \ifnum\c@pgf@counta<0\relax% \c@pgf@counta=-\c@pgf@counta\relax% \fi% \c@pgf@countb=\pgf@ya% \ifnum\c@pgf@countb<0\relax% \c@pgf@countb=-\c@pgf@countb\relax% \fi% \advance\c@pgf@counta by\c@pgf@countb\relax% \divide\c@pgf@counta by 65536\relax% \ifnum\c@pgf@counta>0\relax% \divide\pgf@xa by\c@pgf@counta\relax% \divide\pgf@ya by\c@pgf@counta\relax% \fi% % % Compute projection % \pgf@xc=\pgf@sys@tonumber{\pgf@ya}\pgf@x% \advance\pgf@xc by\pgf@sys@tonumber{\pgf@xa}\pgf@y% % % The orthogonal vector is (\pgf@ya,\pgf@xa) % % % Compute orthogonal vector to #3--#4 % \pgf@process{#4}% \pgf@xb=\pgf@x% \pgf@yb=\pgf@y% \pgf@process{#3}% \advance\pgf@xb by-\pgf@x% \advance\pgf@yb by-\pgf@y% \pgf@yb=-\pgf@yb% % Normalise a bit \c@pgf@counta=\pgf@xb% \ifnum\c@pgf@counta<0\relax% \c@pgf@counta=-\c@pgf@counta\relax% \fi% \c@pgf@countb=\pgf@yb% \ifnum\c@pgf@countb<0\relax% \c@pgf@countb=-\c@pgf@countb\relax% \fi% \advance\c@pgf@counta by\c@pgf@countb\relax% \divide\c@pgf@counta by 65536\relax% \ifnum\c@pgf@counta>0\relax% \divide\pgf@xb by\c@pgf@counta\relax% \divide\pgf@yb by\c@pgf@counta\relax% \fi% % % Compute projection % \pgf@yc=\pgf@sys@tonumber{\pgf@yb}\pgf@x% \advance\pgf@yc by\pgf@sys@tonumber{\pgf@xb}\pgf@y% % % The orthogonal vector is (\pgf@yb,\pgf@xb) % % Setup transformation matrx (this is just to use the matrix % inversion) % \pgfsettransform{{\pgf@sys@tonumber\pgf@ya}{\pgf@sys@tonumber\pgf@yb}{\pgf@sys@tonumber\pgf@xa}{\pgf@sys@tonumber\pgf@xb}{0pt}{0pt}}% \pgftransforminvert% \pgf@process{\pgfpointtransformed{\pgfpoint{\pgf@xc}{\pgf@yc}}}% }% } \def\forest@patched@pgfpointintersectionoflines#1#2#3#4{% {% added the percent sign in this line % % Compute orthogonal vector to #1--#2 % \pgf@process{#2}% \pgf@xa=\pgf@x% \pgf@ya=\pgf@y% \pgf@process{#1}% \advance\pgf@xa by-\pgf@x% \advance\pgf@ya by-\pgf@y% \pgf@ya=-\pgf@ya% % Normalise a bit \c@pgf@counta=\pgf@xa% \ifnum\c@pgf@counta<0\relax% \c@pgf@counta=-\c@pgf@counta\relax% \fi% \c@pgf@countb=\pgf@ya% \ifnum\c@pgf@countb<0\relax% \c@pgf@countb=-\c@pgf@countb\relax% \fi% \advance\c@pgf@counta by\c@pgf@countb\relax% \divide\c@pgf@counta by 65536\relax% \ifnum\c@pgf@counta>0\relax% \divide\pgf@xa by\c@pgf@counta\relax% \divide\pgf@ya by\c@pgf@counta\relax% \fi% % % Compute projection % \pgf@xc=\pgf@sys@tonumber{\pgf@ya}\pgf@x% \advance\pgf@xc by\pgf@sys@tonumber{\pgf@xa}\pgf@y% % % The orthogonal vector is (\pgf@ya,\pgf@xa) % % % Compute orthogonal vector to #3--#4 % \pgf@process{#4}% \pgf@xb=\pgf@x% \pgf@yb=\pgf@y% \pgf@process{#3}% \advance\pgf@xb by-\pgf@x% \advance\pgf@yb by-\pgf@y% \pgf@yb=-\pgf@yb% % Normalise a bit \c@pgf@counta=\pgf@xb% \ifnum\c@pgf@counta<0\relax% \c@pgf@counta=-\c@pgf@counta\relax% \fi% \c@pgf@countb=\pgf@yb% \ifnum\c@pgf@countb<0\relax% \c@pgf@countb=-\c@pgf@countb\relax% \fi% \advance\c@pgf@counta by\c@pgf@countb\relax% \divide\c@pgf@counta by 65536\relax% \ifnum\c@pgf@counta>0\relax% \divide\pgf@xb by\c@pgf@counta\relax% \divide\pgf@yb by\c@pgf@counta\relax% \fi% % % Compute projection % \pgf@yc=\pgf@sys@tonumber{\pgf@yb}\pgf@x% \advance\pgf@yc by\pgf@sys@tonumber{\pgf@xb}\pgf@y% % % The orthogonal vector is (\pgf@yb,\pgf@xb) % % Setup transformation matrx (this is just to use the matrix % inversion) % \pgfsettransform{{\pgf@sys@tonumber\pgf@ya}{\pgf@sys@tonumber\pgf@yb}{\pgf@sys@tonumber\pgf@xa}{\pgf@sys@tonumber\pgf@xb}{0pt}{0pt}}% \pgftransforminvert% \pgf@process{\pgfpointtransformed{\pgfpoint{\pgf@xc}{\pgf@yc}}}% }% } \ifx\pgfpointintersectionoflines\forest@original@pgfpointintersectionoflines \let\pgfpointintersectionoflines\forest@patched@pgfpointintersectionoflines \fi % hah: hacking forest --- it depends on some details of PGF implementation \def\forest@pgf@notyetpositioned{not yet positionedPGFINTERNAL}% \expandafter\ifstrequal\expandafter{\pgfversion}{2.10}{% \def\forest@pgf@notyetpositioned{not yet positioned@}% }{} % \end{macrocode} % % \section{Utilities} % % Escaping |\if|s. % \begin{macrocode} \long\def\@escapeif#1#2\fi{\fi#1} \long\def\@escapeifif#1#2\fi#3\fi{\fi\fi#1} % \end{macrocode} % % A factory for creating |\...loop...| macros. % \begin{macrocode} \def\newloop#1{% \count@=\escapechar \escapechar=-1 \expandafter\newloop@parse@loopname\string#1\newloop@end \escapechar=\count@ }% {\lccode`7=`l \lccode`8=`o \lccode`9=`p \lowercase{\gdef\newloop@parse@loopname#17889#2\newloop@end{% \edef\newloop@marshal{% \noexpand\csdef{#1loop#2}####1\expandafter\noexpand\csname #1repeat#2\endcsname{% \noexpand\csdef{#1iterate#2}{####1\relax\noexpand\expandafter\expandafter\noexpand\csname#1iterate#2\endcsname\noexpand\fi}% \expandafter\noexpand\csname#1iterate#2\endcsname \let\expandafter\noexpand\csname#1iterate#2\endcsname\relax }% }% \newloop@marshal }% }% }% % \end{macrocode} % % Additional loops (for embedding). % \begin{macrocode} \newloop\forest@loop \newloop\forest@loopa \newloop\forest@loopb \newloop\forest@loopc \newloop\forest@sort@loop \newloop\forest@sort@loopA % \end{macrocode} % New counters, dimens, ifs. % \begin{macrocode} \newdimen\forest@temp@dimen \newcount\forest@temp@count \newcount\forest@n \newif\ifforest@temp \newcount\forest@temp@global@count % \end{macrocode} % % Appending and prepending to token lists. % \begin{macrocode} \def\apptotoks#1#2{\expandafter#1\expandafter{\the#1#2}} \long\def\lapptotoks#1#2{\expandafter#1\expandafter{\the#1#2}} \def\eapptotoks#1#2{\edef\pot@temp{#2}\expandafter\expandafter\expandafter#1\expandafter\expandafter\expandafter{\expandafter\the\expandafter#1\pot@temp}} \def\pretotoks#1#2{\toks@={#2}\expandafter\expandafter\expandafter#1\expandafter\expandafter\expandafter{\expandafter\the\expandafter\toks@\the#1}} \def\epretotoks#1#2{\edef\pot@temp{#2}\expandafter\expandafter\expandafter#1\expandafter\expandafter\expandafter{\expandafter\pot@temp\the#1}} \def\gapptotoks#1#2{\expandafter\global\expandafter#1\expandafter{\the#1#2}} \def\xapptotoks#1#2{\edef\pot@temp{#2}\expandafter\expandafter\expandafter\global\expandafter\expandafter\expandafter#1\expandafter\expandafter\expandafter{\expandafter\the\expandafter#1\pot@temp}} \def\gpretotoks#1#2{\toks@={#2}\expandafter\expandafter\expandafter\global\expandafter\expandafter\expandafter#1\expandafter\expandafter\expandafter{\expandafter\the\expandafter\toks@\the#1}} \def\xpretotoks#1#2{\edef\pot@temp{#2}\expandafter\expandafter\expandafter\global\expandafter\expandafter\expandafter#1\expandafter\expandafter\expandafter{\expandafter\pot@temp\the#1}} % \end{macrocode} % % Expanding number arguments. % \begin{macrocode} \def\expandnumberarg#1#2{\expandafter#1\expandafter{\number#2}} \def\expandtwonumberargs#1#2#3{% \expandafter\expandtwonumberargs@\expandafter#1\expandafter{\number#3}{#2}} \def\expandtwonumberargs@#1#2#3{% \expandafter#1\expandafter{\number#3}{#2}} \def\expandthreenumberargs#1#2#3#4{% \expandafter\expandthreenumberargs@\expandafter#1\expandafter{\number#4}{#2}{#3}} \def\expandthreenumberargs@#1#2#3#4{% \expandafter\expandthreenumberargs@@\expandafter#1\expandafter{\number#4}{#2}{#3}} \def\expandthreenumberargs@@#1#2#3#4{% \expandafter#1\expandafter{\number#4}{#2}{#3}} % \end{macrocode} % % A macro converting all non-letters in a string to |__|. |#1| = % string, |#2| = receiving macro. Used for declaring pgfmath % functions. % \begin{macrocode} \def\forest@convert@others@to@underscores#1#2{% \def\forest@cotu@result{}% \forest@cotu#1\forest@end \let#2\forest@cotu@result } \def\forest@cotu{% \futurelet\forest@cotu@nextchar\forest@cotu@checkforspace } \def\forest@cotu@checkforspace{% \expandafter\ifx\space\forest@cotu@nextchar \let\forest@cotu@next\forest@cotu@havespace \else \let\forest@cotu@next\forest@cotu@nospace \fi \forest@cotu@next } \def\forest@cotu@havespace#1{% \appto\forest@cotu@result{_}% \forest@cotu#1% } \def\forest@cotu@nospace{% \ifx\forest@cotu@nextchar\forest@end \@escapeif\@gobble \else \@escapeif\forest@cotu@nospaceB \fi } \def\forest@cotu@nospaceB{% \ifcat\forest@cotu@nextchar a% \let\forest@cotu@next\forest@cotu@have@alphanum \else \ifcat\forest@cotu@nextchar 0% \let\forest@cotu@next\forest@cotu@have@alphanum \else \let\forest@cotu@next\forest@cotu@haveother \fi \fi \forest@cotu@next } \def\forest@cotu@have@alphanum#1{% \appto\forest@cotu@result{#1}% \forest@cotu } \def\forest@cotu@haveother#1{% \appto\forest@cotu@result{_}% \forest@cotu } % \end{macrocode} % % Additional list macros. % \begin{macrocode} \def\forest@listedel#1#2{% #1 = list, #2 = item \edef\forest@marshal{\noexpand\forest@listdel\noexpand#1{#2}}% \forest@marshal } \def\forest@listcsdel#1#2{% \expandafter\forest@listdel\csname #1\endcsname{#2}% } \def\forest@listcsedel#1#2{% \expandafter\forest@listedel\csname #1\endcsname{#2}% } \edef\forest@restorelistsepcatcode{\noexpand\catcode`|\the\catcode`|\relax}% \catcode`\|=3 \gdef\forest@listdel#1#2{% \def\forest@listedel@A##1|#2|##2\forest@END{% \forest@listedel@B##1|##2\forest@END%| }% \def\forest@listedel@B|##1\forest@END{%| \def#1{##1}% }% \expandafter\forest@listedel@A\expandafter|#1\forest@END%| } \forest@restorelistsepcatcode % \end{macrocode} % % Strip (the first level of) braces from all the tokens in the argument. % \begin{macrocode} \def\forest@strip@braces#1{% \forest@strip@braces@A#1\forest@strip@braces@preend\forest@strip@braces@end } \def\forest@strip@braces@A#1#2\forest@strip@braces@end{% #1\ifx\forest@strip@braces@preend#2\else\@escapeif{\forest@strip@braces@A#2\forest@strip@braces@end}\fi } % \end{macrocode} % % \subsection{Sorting} % % Macro |\forest@sort| is the user interface to sorting. % % The user should prepare the data in an arbitrarily encoded % array,\footnote{In forest, arrays are encoded as families of % macros. An array-macro name consists of the (optional, but % recommended) prefix, the index, and the (optional) suffix (e.g.\ % \texttt{$\backslash$forest@42x}). Prefix establishes the ``namespace'', % while using more than one suffix simulates an array of named tuples. % The length of the array is stored in macro \texttt{$\backslash$n}.} % and provide the sorting macro (given in |#1|) and the array let % macro (given in |#2|): these are the only ways in which sorting % algorithms access the data. Both user-given macros should take two % parameters, which expand to array indices. The comparison macro % should compare the given array items and call |\forest@sort@cmp@gt|, % |\forest@sort@cmp@lt| or |\forest@sort@cmp@eq| to signal that the % first item is greater than, less than, or equal to the second item. % The let macro should ``copy'' the contents of the second item onto % the first item. % % The sorting direction is be given in |#3|: it can one of % |\forest@sort@ascending| and |\forest@sort@descending|. |#4| and % |#5| must expand to the lower and upper (both inclusive) indices of % the array to be sorted. % % |\forest@sort| is just a wrapper for the central sorting macro % |\forest@@sort|, storing the comparison macro, the array let macro % and the direction. The central sorting macro and the % algorithm-specific macros take only two arguments: the array bounds. % \begin{macrocode} \def\forest@sort#1#2#3#4#5{% \let\forest@sort@cmp#1\relax \let\forest@sort@let#2\relax \let\forest@sort@direction#3\relax \forest@@sort{#4}{#5}% } % \end{macrocode} % The central sorting macro. Here it is decided which sorting % algorithm will be used: for arrays at least % |\forest@quicksort@minarraylength| long, quicksort is used; % otherwise, insertion sort. % \begin{macrocode} \def\forest@quicksort@minarraylength{10000} \def\forest@@sort#1#2{% \ifnum#1<#2\relax\@escapeif{% \forest@sort@m=#2 \advance\forest@sort@m -#1 \ifnum\forest@sort@m>\forest@quicksort@minarraylength\relax\@escapeif{% \forest@quicksort{#1}{#2}% }\else\@escapeif{% \forest@insertionsort{#1}{#2}% }\fi }\fi } % \end{macrocode} % Various counters and macros needed by the sorting algorithms. % \begin{macrocode} \newcount\forest@sort@m\newcount\forest@sort@k\newcount\forest@sort@p \def\forest@sort@ascending{>} \def\forest@sort@descending{<} \def\forest@sort@cmp{% \PackageError{sort}{You must define forest@sort@cmp function before calling sort}{The macro must take two arguments, indices of the array elements to be compared, and return '=' if the elements are equal and '>'/'<' if the first is greater /less than the secong element.}% } \def\forest@sort@cmp@gt{\def\forest@sort@cmp@result{>}} \def\forest@sort@cmp@lt{\def\forest@sort@cmp@result{<}} \def\forest@sort@cmp@eq{\def\forest@sort@cmp@result{=}} \def\forest@sort@let{% \PackageError{sort}{You must define forest@sort@let function before calling sort}{The macro must take two arguments, indices of the array: element 2 must be copied onto element 1.}% } % \end{macrocode} % Quick sort macro (adapted from % \href{http://www.ctan.org/pkg/laansort}{laansort}). % \begin{macrocode} \def\forest@quicksort#1#2{% % \end{macrocode} % Compute the index of the middle element (|\forest@sort@m|). % \begin{macrocode} \forest@sort@m=#2 \advance\forest@sort@m -#1 \ifodd\forest@sort@m\relax\advance\forest@sort@m1 \fi \divide\forest@sort@m 2 \advance\forest@sort@m #1 % \end{macrocode} % The pivot element is the median of the first, the middle and the % last element. % \begin{macrocode} \forest@sort@cmp{#1}{#2}% \if\forest@sort@cmp@result=% \forest@sort@p=#1 \else \if\forest@sort@cmp@result>% \forest@sort@p=#1\relax \else \forest@sort@p=#2\relax \fi \forest@sort@cmp{\the\forest@sort@p}{\the\forest@sort@m}% \if\forest@sort@cmp@result<% \else \forest@sort@p=\the\forest@sort@m \fi \fi % \end{macrocode} % Exchange the pivot and the first element. % \begin{macrocode} \forest@sort@xch{#1}{\the\forest@sort@p}% % \end{macrocode} % Counter |\forest@sort@m| will hold the final location of the pivot % element. % \begin{macrocode} \forest@sort@m=#1\relax % \end{macrocode} % Loop through the list. % \begin{macrocode} \forest@sort@k=#1\relax \forest@sort@loop \ifnum\forest@sort@k<#2\relax \advance\forest@sort@k 1 % \end{macrocode} % Compare the pivot and the current element. % \begin{macrocode} \forest@sort@cmp{#1}{\the\forest@sort@k}% % \end{macrocode} % If the current element is smaller (ascending) or greater % (descending) than the pivot element, move it into the first part of % the list, and adjust the final location of the pivot. % \begin{macrocode} \ifx\forest@sort@direction\forest@sort@cmp@result \advance\forest@sort@m 1 \forest@sort@xch{\the\forest@sort@m}{\the\forest@sort@k} \fi \forest@sort@repeat % \end{macrocode} % Move the pivot element into its final position. % \begin{macrocode} \forest@sort@xch{#1}{\the\forest@sort@m}% % \end{macrocode} % Recursively call sort on the two parts of the list: elements before % the pivot are smaller (ascending order) / greater (descending order) % than the pivot; elements after the pivot are greater (ascending % order) / smaller (descending order) than the pivot. % \begin{macrocode} \forest@sort@k=\forest@sort@m \advance\forest@sort@k -1 \advance\forest@sort@m 1 \edef\forest@sort@marshal{% \noexpand\forest@@sort{#1}{\the\forest@sort@k}% \noexpand\forest@@sort{\the\forest@sort@m}{#2}% }% \forest@sort@marshal } % We defines the item-exchange macro in terms of the (user-provided) % array let macro. % \begin{macrocode} \def\forest@sort@xch#1#2{% \forest@sort@let{aux}{#1}% \forest@sort@let{#1}{#2}% \forest@sort@let{#2}{aux}% } % \end{macrocode} % Insertion sort. % \begin{macrocode} \def\forest@insertionsort#1#2{% \forest@sort@m=#1 \edef\forest@insertionsort@low{#1}% \forest@sort@loopA \ifnum\forest@sort@m<#2 \advance\forest@sort@m 1 \forest@insertionsort@Qbody \forest@sort@repeatA } \newif\ifforest@insertionsort@loop \def\forest@insertionsort@Qbody{% \forest@sort@let{aux}{\the\forest@sort@m}% \forest@sort@k\forest@sort@m \advance\forest@sort@k -1 \forest@insertionsort@looptrue \forest@sort@loop \ifforest@insertionsort@loop \forest@insertionsort@qbody \forest@sort@repeat \advance\forest@sort@k 1 \forest@sort@let{\the\forest@sort@k}{aux}% } \def\forest@insertionsort@qbody{% \forest@sort@cmp{\the\forest@sort@k}{aux}% \ifx\forest@sort@direction\forest@sort@cmp@result\relax \forest@sort@p=\forest@sort@k \advance\forest@sort@p 1 \forest@sort@let{\the\forest@sort@p}{\the\forest@sort@k}% \advance\forest@sort@k -1 \ifnum\forest@sort@k<\forest@insertionsort@low\relax \forest@insertionsort@loopfalse \fi \else \forest@insertionsort@loopfalse \fi } % \end{macrocode} % % Below, several helpers for writing comparison macros are % provided. They take take two (pairs of) control sequence names and % compare their contents. % % Compare numbers. % \begin{macrocode} \def\forest@sort@cmpnumcs#1#2{% \ifnum\csname#1\endcsname>\csname#2\endcsname\relax \forest@sort@cmp@gt \else \ifnum\csname#1\endcsname<\csname#2\endcsname\relax \forest@sort@cmp@lt \else \forest@sort@cmp@eq \fi \fi } % \end{macrocode} % Compare dimensions. % \begin{macrocode} \def\forest@sort@cmpdimcs#1#2{% \ifdim\csname#1\endcsname>\csname#2\endcsname\relax \forest@sort@cmp@gt \else \ifdim\csname#1\endcsname<\csname#2\endcsname\relax \forest@sort@cmp@lt \else \forest@sort@cmp@eq \fi \fi } % \end{macrocode} % Compare points (pairs of dimension) |(#1,#2)| and |(#3,#4)|. % \begin{macrocode} \def\forest@sort@cmptwodimcs#1#2#3#4{% \ifdim\csname#1\endcsname>\csname#3\endcsname\relax \forest@sort@cmp@gt \else \ifdim\csname#1\endcsname<\csname#3\endcsname\relax \forest@sort@cmp@lt \else \ifdim\csname#2\endcsname>\csname#4\endcsname\relax \forest@sort@cmp@gt \else \ifdim\csname#2\endcsname<\csname#4\endcsname\relax \forest@sort@cmp@lt \else \forest@sort@cmp@eq \fi \fi \fi \fi } % \end{macrocode} % % The following macro reverses an array. The arguments: |#1| is % the array let macro; |#2| is the start index (inclusive), and % |#3| is the end index (exclusive). % \begin{macrocode} \def\forest@reversearray#1#2#3{% \let\forest@sort@let#1% \c@pgf@countc=#2 \c@pgf@countd=#3 \advance\c@pgf@countd -1 \forest@loopa \ifnum\c@pgf@countc<\c@pgf@countd\relax \forest@sort@xch{\the\c@pgf@countc}{\the\c@pgf@countd}% \advance\c@pgf@countc 1 \advance\c@pgf@countd -1 \forest@repeata } % \end{macrocode} % % \section{The bracket representation parser} % \label{imp:bracket} % % \subsection{The user interface macros} % % Settings. % \begin{macrocode} \def\bracketset#1{\pgfqkeys{/bracket}{#1}}% \bracketset{% /bracket/.is family, /handlers/.let/.style={\pgfkeyscurrentpath/.code={\let#1##1}}, opening bracket/.let=\bracket@openingBracket, closing bracket/.let=\bracket@closingBracket, action character/.let=\bracket@actionCharacter, opening bracket=[, closing bracket=], action character, new node/.code n args={3}{% #1=preamble, #2=node spec, #3=cs receiving the id \forest@node@new#3% \forestOset{#3}{given options}{content'=#2}% \ifblank{#1}{}{% \forestOpreto{#3}{given options}{#1,}% }% }, set afterthought/.code 2 args={% #1=node id, #2=afterthought \ifblank{#2}{}{\forestOappto{#1}{given options}{,afterthought={#2}}}% } } % \end{macrocode} % % |\bracketParse| is the macro that should be called to parse a % balanced bracket representation. It takes five parameters: |#1| is the code that will be run % after parsing the bracket; |#2| is a control sequence that will receive the id of the root of the % created tree structure. (The bracket representation should follow (after optional spaces), but is % is not a formal parameter of the macro.) % \begin{macrocode} \newtoks\bracket@content \newtoks\bracket@afterthought \def\bracketParse#1#2={% \def\bracketEndParsingHook{#1}% \def\bracket@saveRootNodeTo{#2}% % \end{macrocode} % Content and afterthought will be appended to these macros. (The |\bracket@afterthought| toks register is % abused for storing the preamble as well --- that's ok, the preamble comes before any afterhoughts.) % \begin{macrocode} \bracket@content={}% \bracket@afterthought={}% % \end{macrocode} % The parser can be in three states: in content (0), in afterthought % (1), or starting (2). While in the content/afterthought state, the % parser appends all non-control tokens to the content/afterthought macro. % \begin{macrocode} \let\bracket@state\bracket@state@starting \bracket@ignorespacestrue % \end{macrocode} % By default, don't expand anything. % \begin{macrocode} \bracket@expandtokensfalse % \end{macrocode} % We initialize several control sequences that are used to store some % nodes while parsing. % \begin{macrocode} \def\bracket@parentNode{0}% \def\bracket@rootNode{0}% \def\bracket@newNode{0}% \def\bracket@afterthoughtNode{0}% % \end{macrocode} % Finally, we start the parser. % \begin{macrocode} \bracket@Parse } % \end{macrocode} % The other macro that an end user (actually a power user) can use, is % actually just a synonym for |\bracket@Parse|. It should be used to % resume parsing when the action code has finished its work. % \begin{macrocode} \def\bracketResume{\bracket@Parse}% % \end{macrocode} % % \subsection{Parsing} % % We first check if the next token is a space. Spaces need special % treatment because they are eaten by both the |\romannumeral| trick % and \TeX s (undelimited) argument parsing algorithm. If a space is % found, remember that, eat it up, and restart the parsing. % \begin{macrocode} \def\bracket@Parse{% \futurelet\bracket@next@token\bracket@Parse@checkForSpace } \def\bracket@Parse@checkForSpace{% \expandafter\ifx\space\bracket@next@token\@escapeif{% \ifbracket@ignorespaces\else \bracket@haveSpacetrue \fi \expandafter\bracket@Parse\romannumeral-`0% }\else\@escapeif{% \bracket@Parse@maybeexpand }\fi } % \end{macrocode} % % We either fully expand the next token (using a popular \TeX nical % trick \dots) or don't expand it at all, depending on the state of % |\ifbracket@expandtokens|. % \begin{macrocode} \newif\ifbracket@expandtokens \def\bracket@Parse@maybeexpand{% \ifbracket@expandtokens\@escapeif{% \expandafter\bracket@Parse@peekAhead\romannumeral-`0% }\else\@escapeif{% \bracket@Parse@peekAhead }\fi } % \end{macrocode} % We then look ahead to see what's coming. % \begin{macrocode} \def\bracket@Parse@peekAhead{% \futurelet\bracket@next@token\bracket@Parse@checkForTeXGroup } % \end{macrocode} % If the next token is a begin-group token, we append the whole group to % the content or afterthought macro, depending on the state. % \begin{macrocode} \def\bracket@Parse@checkForTeXGroup{% \ifx\bracket@next@token\bgroup% \@escapeif{\bracket@Parse@appendGroup}% \else \@escapeif{\bracket@Parse@token}% \fi } % \end{macrocode} % This is easy: if a control token is found, run the appropriate % macro; otherwise, append the token to the content or afterthought % macro, depending on the state. % \begin{macrocode} \long\def\bracket@Parse@token#1{% \ifx#1\bracket@openingBracket \@escapeif{\bracket@Parse@openingBracketFound}% \else \@escapeif{% \ifx#1\bracket@closingBracket \@escapeif{\bracket@Parse@closingBracketFound}% \else \@escapeif{% \ifx#1\bracket@actionCharacter \@escapeif{\futurelet\bracket@next@token\bracket@Parse@actionCharacterFound}% \else \@escapeif{\bracket@Parse@appendToken#1}% \fi }% \fi }% \fi } % \end{macrocode} % Append the token or group to the content or afterthought macro. If a % space was found previously, append it as well. % \begin{macrocode} \newif\ifbracket@haveSpace \newif\ifbracket@ignorespaces \def\bracket@Parse@appendSpace{% \ifbracket@haveSpace \ifcase\bracket@state\relax \eapptotoks\bracket@content\space \or \eapptotoks\bracket@afterthought\space \or \eapptotoks\bracket@afterthought\space \fi \bracket@haveSpacefalse \fi } \long\def\bracket@Parse@appendToken#1{% \bracket@Parse@appendSpace \ifcase\bracket@state\relax \lapptotoks\bracket@content{#1}% \or \lapptotoks\bracket@afterthought{#1}% \or \lapptotoks\bracket@afterthought{#1}% \fi \bracket@ignorespacesfalse \bracket@Parse } \def\bracket@Parse@appendGroup#1{% \bracket@Parse@appendSpace \ifcase\bracket@state\relax \apptotoks\bracket@content{{#1}}% \or \apptotoks\bracket@afterthought{{#1}}% \or \apptotoks\bracket@afterthought{{#1}}% \fi \bracket@ignorespacesfalse \bracket@Parse } % \end{macrocode} % Declare states. % \begin{macrocode} \def\bracket@state@inContent{0} \def\bracket@state@inAfterthought{1} \def\bracket@state@starting{2} % \end{macrocode} % % Welcome to the jungle. In the following two macros, new nodes are % created, content and afterthought are sent to them, parents and % states are changed\dots\@ Altogether, we distinguish six cases, as % shown below: in the schemas, we have just crossed the symbol after % the dots. (In all cases, we reset the |\if| for spaces.) % \begin{macrocode} \def\bracket@Parse@openingBracketFound{% \bracket@haveSpacefalse \ifcase\bracket@state\relax% in content [ ... [ % \end{macrocode} % |[...[|: we have just finished gathering the content and are about % to begin gathering the content of another node. We create a % new node (and put the content (\dots) into % it). Then, if there is a parent node, we append the new node to the % list of its children. Next, since we have just crossed an opening % bracket, we declare the newly created node to be the parent of the % coming node. The state does not change. Finally, we continue parsing. % \begin{macrocode} \@escapeif{% \bracket@createNode \ifnum\bracket@parentNode=0 \else \forest@node@Append{\bracket@parentNode}{\bracket@newNode}% \fi \let\bracket@parentNode\bracket@newNode \bracket@Parse }% \or % in afterthought ] ... [ % \end{macrocode} % |]...[|: we have just finished gathering the afterthought and are % about to begin gathering the content of another node. We add the % afterthought (\dots) to the ``afterthought node'' and change into the % content state. The parent does not change. Finally, we continue % parsing. % \begin{macrocode} \@escapeif{% \bracket@addAfterthought \let\bracket@state\bracket@state@inContent \bracket@Parse }% \else % starting % \end{macrocode} % |{start}...[|: we have just started. Nothing to do yet (we couldn't % have collected any content yet), just get into the content state and % continue parsing. % \begin{macrocode} \@escapeif{% \let\bracket@state\bracket@state@inContent \bracket@Parse }% \fi } \def\bracket@Parse@closingBracketFound{% \bracket@haveSpacefalse \ifcase\bracket@state\relax % in content [ ... ] % \end{macrocode} % |[...]|: we have just finished gathering the content of a node and % are about to begin gathering its afterthought. We create a new node % (and put the content (\dots) into it). If there is no parent node, % we're done with parsing. Otherwise, we set the newly created % node to be the ``afterthought node'', i.e.\ the node that will % receive the next afterthought, change into the afterthought mode, % and continue parsing. % \begin{macrocode} \@escapeif{% \bracket@createNode \ifnum\bracket@parentNode=0 \@escapeif\bracketEndParsingHook \else \@escapeif{% \let\bracket@afterthoughtNode\bracket@newNode \let\bracket@state\bracket@state@inAfterthought \forest@node@Append{\bracket@parentNode}{\bracket@newNode}% \bracket@Parse }% \fi }% \or % in afterthought ] ... ] % \end{macrocode} % |]...]|: we have finished gathering an afterthought of some node and % will begin gathering the afterthought of its parent. We first add % the afterthought to the afterthought node and set the current parent % to be the next afterthought node. We change the parent to the % current parent's parent and check if that node is null. If it is, % we're done with parsing (ignore the trailing spaces), otherwise we continue. % \begin{macrocode} \@escapeif{% \bracket@addAfterthought \let\bracket@afterthoughtNode\bracket@parentNode \edef\bracket@parentNode{\forestOve{\bracket@parentNode}{@parent}}% \ifnum\bracket@parentNode=0 \expandafter\bracketEndParsingHook \else \expandafter\bracket@Parse \fi }% \else % starting % \end{macrocode} % |{start}...]|: something's obviously wrong with the input here\dots % \begin{macrocode} \PackageError{forest}{You're attempting to start a bracket representation with a closing bracket}{}% \fi } % \end{macrocode} % % The action character code. What happens is determined by the next token. % \begin{macrocode} \def\bracket@Parse@actionCharacterFound{% % \end{macrocode} % If a braced expression follows, its contents will be fully expanded. % \begin{macrocode} \ifx\bracket@next@token\bgroup\@escapeif{% \bracket@Parse@action@expandgroup }\else\@escapeif{% \bracket@Parse@action@notagroup }\fi } \def\bracket@Parse@action@expandgroup#1{% \edef\bracket@Parse@action@expandgroup@macro{#1}% \expandafter\bracket@Parse\bracket@Parse@action@expandgroup@macro } \let\bracket@action@fullyexpandCharacter+ \let\bracket@action@dontexpandCharacter- \let\bracket@action@executeCharacter! \def\bracket@Parse@action@notagroup#1{% % \end{macrocode} % If + follows, tokens will be fully expanded from this point on. % \begin{macrocode} \ifx#1\bracket@action@fullyexpandCharacter\@escapeif{% \bracket@expandtokenstrue\bracket@Parse }\else\@escapeif{% % \end{macrocode} % If - follows, tokens will not be expanded from this point on. (This is the default behaviour.) % \begin{macrocode} \ifx#1\bracket@action@dontexpandCharacter\@escapeif{% \bracket@expandtokensfalse\bracket@Parse }\else\@escapeif{% % \end{macrocode} % Inhibit expansion of the next token. % \begin{macrocode} \ifx#10\@escapeif{% \bracket@Parse@appendToken }\else\@escapeif{% % \end{macrocode} % If another action characted follows, we yield the control. The user is % expected to resume the parser manually, using |\bracketResume|. % \begin{macrocode} \ifx#1\bracket@actionCharacter \else\@escapeif{% % \end{macrocode} % Anything else will be expanded once. % \begin{macrocode} \expandafter\bracket@Parse#1% }\fi }\fi }\fi }\fi } % \end{macrocode} % % \subsection{The tree-structure interface} % % This macro creates a new node and sets its content (and preamble, if it's a root node). Bracket % user must define a 3-arg key |/bracket/new node=|\meta{preamble}\meta{node % specification}\meta{node cs}. User's key must define \meta{node cs} to be a macro holding the % node's id. % \begin{macrocode} \def\bracket@createNode{% \ifnum\bracket@rootNode=0 % root node \bracketset{new node/.expanded=% {\the\bracket@afterthought}% {\the\bracket@content}% \noexpand\bracket@newNode }% \bracket@afterthought={}% \let\bracket@rootNode\bracket@newNode \expandafter\let\bracket@saveRootNodeTo\bracket@newNode \else % other nodes \bracketset{new node/.expanded=% {}% {\the\bracket@content}% \noexpand\bracket@newNode }% \fi \bracket@content={}% } % \end{macrocode} % % This macro sets the afterthought. Bracket user must define a 2-arg key % |/bracket/set_afterthought=|\meta{node id}\meta{afterthought}. % \begin{macrocode} \def\bracket@addAfterthought{% \bracketset{% set afterthought/.expanded={\bracket@afterthoughtNode}{\the\bracket@afterthought}% }% \bracket@afterthought={}% } % \end{macrocode} % % % \section{Nodes} % % Nodes have numeric ids. The node option values of node $n$ are saved in the |\pgfkeys| tree in % path |/forest/@node/|$n$. % % \subsection{Option setting and retrieval} % % Macros for retrieving/setting node options of the current node. % \begin{macrocode} % full expansion expands precisely to the value \def\forestov#1{\expandafter\expandafter\expandafter\expandonce \pgfkeysvalueof{/forest/@node/\forest@cn/#1}} % full expansion expands all the way \def\forestove#1{\pgfkeysvalueof{/forest/@node/\forest@cn/#1}} % full expansion expands to the cs holding the value \def\forestom#1{\expandafter\expandonce\expandafter{\pgfkeysvalueof{/forest/@node/\forest@cn/#1}}}\def\forestoget#1#2{\pgfkeysgetvalue{/forest/@node/\forest@cn/#1}{#2}} \def\forestoget#1#2{\pgfkeysgetvalue{/forest/@node/\forest@cn/#1}{#2}} \def\forestolet#1#2{\pgfkeyslet{/forest/@node/\forest@cn/#1}{#2}} \def\forestoset#1#2{\pgfkeyssetvalue{/forest/@node/\forest@cn/#1}{#2}} \def\forestoeset#1#2{% \edef\forest@option@temp{% \noexpand\pgfkeyssetvalue{/forest/@node/\forest@cn/#1}{#2}% }\forest@option@temp } \def\forestoappto#1#2{% \forestoeset{#1}{\forestov{#1}\unexpanded{#2}}% } \def\forestoifdefined#1#2#3{% \pgfkeysifdefined{/forest/@node/\forest@cn/#1}{#2}{#3}% } % \end{macrocode} % User macros for retrieving node options of the current node. % \begin{macrocode} \let\forestoption\forestov \let\foresteoption\forestove % \end{macrocode} % Macros for retrieving node options of a node given by its id. % \begin{macrocode} \def\forestOv#1#2{\expandafter\expandafter\expandafter\expandonce \pgfkeysvalueof{/forest/@node/#1/#2}} \def\forestOve#1#2{\pgfkeysvalueof{/forest/@node/#1/#2}} % full expansion expands to the cs holding the value \def\forestOm#1#2{\expandafter\expandonce\expandafter{\pgfkeysvalueof{/forest/@node/#1/#2}}} \def\forestOget#1#2#3{\pgfkeysgetvalue{/forest/@node/#1/#2}{#3}} \def\forestOget#1#2#3{\pgfkeysgetvalue{/forest/@node/#1/#2}{#3}} \def\forestOlet#1#2#3{\pgfkeyslet{/forest/@node/#1/#2}{#3}} \def\forestOset#1#2#3{\pgfkeyssetvalue{/forest/@node/#1/#2}{#3}} \def\forestOeset#1#2#3{% \edef\forestoption@temp{% \noexpand\pgfkeyssetvalue{/forest/@node/#1/#2}{#3}% }\forestoption@temp } \def\forestOappto#1#2#3{% \forestOeset{#1}{#2}{\forestOv{#1}{#2}\unexpanded{#3}}% } \def\forestOeappto#1#2#3{% \forestOeset{#1}{#2}{\forestOv{#1}{#2}#3}% } \def\forestOpreto#1#2#3{% \forestOeset{#1}{#2}{\unexpanded{#3}\forestOv{#1}{#2}}% } \def\forestOepreto#1#2#3{% \forestOeset{#1}{#2}{#3\forestOv{#1}{#2}}% } \def\forestOifdefined#1#2#3#4{% \pgfkeysifdefined{/forest/@node/#1/#2}{#3}{#4}% } \def\forestOletO#1#2#3#4{% option #2 of node #1 <-- option #4 of node #3 \forestOget{#3}{#4}\forestoption@temp \forestOlet{#1}{#2}\forestoption@temp} \def\forestOleto#1#2#3{% \forestoget{#3}\forestoption@temp \forestOlet{#1}{#2}\forestoption@temp} \def\forestoletO#1#2#3{% \forestOget{#2}{#3}\forestoption@temp \forestolet{#1}\forestoption@temp} \def\forestoleto#1#2{% \forestoget{#2}\forestoption@temp \forestolet{#1}\forestoption@temp} % \end{macrocode} % Node initialization. Node option declarations append to |\forest@node@init|. % \begin{macrocode} \def\forest@node@init{% \forestoset{@parent}{0}% \forestoset{@previous}{0}% previous sibling \forestoset{@next}{0}% next sibling \forestoset{@first}{0}% primary child \forestoset{@last}{0}% last child } \def\forestoinit#1{% \pgfkeysgetvalue{/forest/#1}\forestoinit@temp \forestolet{#1}\forestoinit@temp } \newcount\forest@node@maxid \def\forest@node@new#1{% #1 = cs receiving the new node id \advance\forest@node@maxid1 \forest@fornode{\the\forest@node@maxid}{% \forest@node@init \forest@node@setname{node@\forest@cn}% \forest@initializefromstandardnode \edef#1{\forest@cn}% }% } \let\forestoinit@orig\forestoinit \def\forest@node@copy#1#2{% #1=from node id, cs receiving the new node id \advance\forest@node@maxid1 \def\forestoinit##1{\forestoletO{##1}{#1}{##1}}% \forest@fornode{\the\forest@node@maxid}{% \forest@node@init \forest@node@setname{\forest@copy@name@template{\forestOve{#1}{name}}}% \edef#2{\forest@cn}% }% \let\forestoinit\forestoinit@orig } \forestset{ copy name template/.code={\def\forest@copy@name@template##1{#1}}, copy name template/.default={node@\the\forest@node@maxid}, copy name template } \def\forest@tree@copy#1#2{% #1=from node id, #2=cs receiving the new node id \forest@node@copy{#1}\forest@node@copy@temp@id \forest@fornode{\forest@node@copy@temp@id}{% \expandafter\forest@tree@copy@\expandafter{\forest@node@copy@temp@id}{#1}% \edef#2{\forest@cn}% }% } \def\forest@tree@copy@#1#2{% \forest@node@Foreachchild{#2}{% \expandafter\forest@tree@copy\expandafter{\forest@cn}\forest@node@copy@temp@childid \forest@node@Append{#1}{\forest@node@copy@temp@childid}% }% } % \end{macrocode} % Macro |\forest@cn| holds the current node id (a number). Node 0 is a special ``null'' node which % is used to signal the absence of a node. % \begin{macrocode} \def\forest@cn{0} \forest@node@init % \end{macrocode} % % \subsection{Tree structure} % Node insertion/removal. % % For the lowercase variants, |\forest@cn| is the parent/removed node. For the uppercase variants, % |#1| is the parent/removed node. For efficiency, the public macros all expand the arguments % before calling the internal macros. % \begin{macrocode} \def\forest@node@append#1{\expandtwonumberargs\forest@node@Append{\forest@cn}{#1}} \def\forest@node@prepend#1{\expandtwonumberargs\forest@node@Insertafter{\forest@cn}{#1}{0}} \def\forest@node@insertafter#1#2{% \expandthreenumberargs\forest@node@Insertafter{\forest@cn}{#1}{#2}} \def\forest@node@insertbefore#1#2{% \expandthreenumberargs\forest@node@Insertafter{\forest@cn}{#1}{\forestOve{#2}{@previous}}% } \def\forest@node@remove{\expandnumberarg\forest@node@Remove{\forest@cn}} \def\forest@node@Append#1#2{\expandtwonumberargs\forest@node@Append@{#1}{#2}} \def\forest@node@Prepend#1#2{\expandtwonumberargs\forest@node@Insertafter{#1}{#2}{0}} \def\forest@node@Insertafter#1#2#3{% #2 is inserted after #3 \expandthreenumberargs\forest@node@Insertafter@{#1}{#2}{#3}% } \def\forest@node@Insertbefore#1#2#3{% #2 is inserted before #3 \expandthreenumberargs\forest@node@Insertafter{#1}{#2}{\forestOve{#3}{@previous}}% } \def\forest@node@Remove#1{\expandnumberarg\forest@node@Remove@{#1}} \def\forest@node@Insertafter@#1#2#3{% \ifnum\forestOve{#2}{@parent}=0 \else \PackageError{forest}{Insertafter(#1,#2,#3): node #2 already has a parent (\forestOve{#2}{@parent})}{}% \fi \ifnum#3=0 \else \ifnum#1=\forestOve{#3}{@parent} \else \PackageError{forest}{Insertafter(#1,#2,#3): node #1 is not the parent of the intended sibling #3 (with parent \forestOve{#3}{@parent})}{}% \fi \fi \forestOeset{#2}{@parent}{#1}% \forestOeset{#2}{@previous}{#3}% \ifnum#3=0 \forestOget{#1}{@first}\forest@node@temp \forestOeset{#1}{@first}{#2}% \else \forestOget{#3}{@next}\forest@node@temp \forestOeset{#3}{@next}{#2}% \fi \forestOeset{#2}{@next}{\forest@node@temp}% \ifnum\forest@node@temp=0 \forestOeset{#1}{@last}{#2}% \else \forestOeset{\forest@node@temp}{@previous}{#2}% \fi } \def\forest@node@Append@#1#2{% \ifnum\forestOve{#2}{@parent}=0 \else \PackageError{forest}{Append(#1,#2): node #2 already has a parent (\forestOve{#2}{@parent})}{}% \fi \forestOeset{#2}{@parent}{#1}% \forestOget{#1}{@last}\forest@node@temp \forestOeset{#1}{@last}{#2}% \forestOeset{#2}{@previous}{\forest@node@temp}% \ifnum\forest@node@temp=0 \forestOeset{#1}{@first}{#2}% \else \forestOeset{\forest@node@temp}{@next}{#2}% \fi } \def\forest@node@Remove@#1{% \forestOget{#1}{@parent}\forest@node@temp@parent \ifnum\forest@node@temp@parent=0 \else \forestOget{#1}{@previous}\forest@node@temp@previous \forestOget{#1}{@next}\forest@node@temp@next \ifnum\forest@node@temp@previous=0 \forestOeset{\forest@node@temp@parent}{@first}{\forest@node@temp@next}% \else \forestOeset{\forest@node@temp@previous}{@next}{\forest@node@temp@next}% \fi \ifnum\forest@node@temp@next=0 \forestOeset{\forest@node@temp@parent}{@last}{\forest@node@temp@previous}% \else \forestOeset{\forest@node@temp@next}{@previous}{\forest@node@temp@previous}% \fi \forestOset{#1}{@parent}{0}% \forestOset{#1}{@previous}{0}% \forestOset{#1}{@next}{0}% \fi } % \end{macrocode} % Looping methods. % \begin{macrocode} \def\forest@forthis#1{% \edef\forest@node@marshal{\unexpanded{#1}\def\noexpand\forest@cn}% \expandafter\forest@node@marshal\expandafter{\forest@cn}% } \def\forest@fornode#1#2{% \edef\forest@node@marshal{\edef\noexpand\forest@cn{#1}\unexpanded{#2}\def\noexpand\forest@cn}% \expandafter\forest@node@marshal\expandafter{\forest@cn}% } \def\forest@fornode@ifexists#1#2{% \edef\forest@node@temp{#1}% \ifnum\forest@node@temp=0 \else \@escapeif{\expandnumberarg\forest@fornode{\forest@node@temp}{#2}}% \fi } \def\forest@node@foreachchild#1{\forest@node@Foreachchild{\forest@cn}{#1}} \def\forest@node@Foreachchild#1#2{% \forest@fornode{\forestOve{#1}{@first}}{\forest@node@@forselfandfollowingsiblings{#2}}% } \def\forest@node@@forselfandfollowingsiblings#1{% \ifnum\forest@cn=0 \else \forest@forthis{#1}% \@escapeif{% \edef\forest@cn{\forestove{@next}}% \forest@node@@forselfandfollowingsiblings{#1}% }% \fi } \def\forest@node@foreach#1{\forest@node@Foreach{\forest@cn}{#1}} \def\forest@node@Foreach#1#2{% \forest@fornode{#1}{\forest@node@@foreach{#2}}% } \def\forest@node@@foreach#1{% \forest@forthis{#1}% \ifnum\forestove{@first}=0 \else\@escapeif{% \edef\forest@cn{\forestove{@first}}% \forest@node@@forselfandfollowingsiblings{\forest@node@@foreach{#1}}% }% \fi } \def\forest@node@foreachdescendant#1{\forest@node@Foreachdescendant{\forest@cn}{#1}} \def\forest@node@Foreachdescendant#1#2{% \forest@node@Foreachchild{#1}{% \forest@node@foreach{#2}% }% } % \end{macrocode} % % Compute |n|, |n'|, |n children| and |level|. % \begin{macrocode} \def\forest@node@Compute@numeric@ts@info@#1{% \forest@node@Foreach{#1}{\forest@node@@compute@numeric@ts@info}% \ifnum\forestOve{#1}{@parent}=0 \else \fornode{#1}{\forest@node@@compute@numeric@ts@info@nbar}% \fi \forest@node@Foreachdescendant{#1}{\forest@node@@compute@numeric@ts@info@nbar}% } \def\forest@node@@compute@numeric@ts@info{% \forestoset{n children}{0}% % \edef\forest@node@temp{\forestove{@previous}}% \ifnum\forest@node@temp=0 \forestoset{n}{1}% \else \forestoeset{n}{\number\numexpr\forestOve{\forest@node@temp}{n}+1}% \fi % \edef\forest@node@temp{\forestove{@parent}}% \ifnum\forest@node@temp=0 \forestoset{n}{0}% \forestoset{n'}{0}% \forestoset{level}{0}% \else \forestOeset{\forest@node@temp}{n children}{% \number\numexpr\forestOve{\forest@node@temp}{n children}+1% }% \forestoeset{level}{% \number\numexpr\forestOve{\forest@node@temp}{level}+1% }% \fi } \def\forest@node@@compute@numeric@ts@info@nbar{% \forestoeset{n'}{\number\numexpr\forestOve{\forestove{@parent}}{n children}-\forestove{n}+1}% } \def\forest@node@compute@numeric@ts@info#1{% \expandnumberarg\forest@node@Compute@numeric@ts@info@{\forest@cn}% } \def\forest@node@Compute@numeric@ts@info#1{% \expandnumberarg\forest@node@Compute@numeric@ts@info@{#1}% } % \end{macrocode} % % Tree structure queries. % \begin{macrocode} \def\forest@node@rootid{% \expandnumberarg\forest@node@Rootid{\forest@cn}% } \def\forest@node@Rootid#1{% #1=node \ifnum\forestOve{#1}{@parent}=0 #1% \else \@escapeif{\expandnumberarg\forest@node@Rootid{\forestOve{#1}{@parent}}}% \fi } \def\forest@node@nthchildid#1{% #1=n \ifnum#1<1 0% \else \expandnumberarg\forest@node@nthchildid@{\number\forestove{@first}}{#1}% \fi } \def\forest@node@nthchildid@#1#2{% \ifnum#1=0 0% \else \ifnum#2>1 \@escapeifif{\expandtwonumberargs \forest@node@nthchildid@{\forestOve{#1}{@next}}{\numexpr#2-1}}% \else #1% \fi \fi } \def\forest@node@nbarthchildid#1{% #1=n \expandnumberarg\forest@node@nbarthchildid@{\number\forestove{@last}}{#1}% } \def\forest@node@nbarthchildid@#1#2{% \ifnum#1=0 0% \else \ifnum#2>1 \@escapeifif{\expandtwonumberargs \forest@node@nbarthchildid@{\forestOve{#1}{@previous}}{\numexpr#2-1}}% \else #1% \fi \fi } \def\forest@node@nornbarthchildid#1{% \ifnum#1>0 \forest@node@nthchildid{#1}% \else \ifnum#1<0 \forest@node@nbarthchildid{-#1}% \else \forest@node@nornbarthchildid@error \fi \fi } \def\forest@node@nornbarthchildid@error{% \PackageError{forest}{In \string\forest@node@nornbarthchildid, n should !=0}{}% } \def\forest@node@previousleafid{% \expandnumberarg\forest@node@Previousleafid{\forest@cn}% } \def\forest@node@Previousleafid#1{% \ifnum\forestOve{#1}{@previous}=0 \@escapeif{\expandnumberarg\forest@node@previousleafid@Goup{#1}}% \else \expandnumberarg\forest@node@previousleafid@Godown{\forestOve{#1}{@previous}}% \fi } \def\forest@node@previousleafid@Goup#1{% \ifnum\forestOve{#1}{@parent}=0 \PackageError{forest}{get previous leaf: this is the first leaf}{}% \else \@escapeif{\expandnumberarg\forest@node@Previousleafid{\forestOve{#1}{@parent}}}% \fi } \def\forest@node@previousleafid@Godown#1{% \ifnum\forestOve{#1}{@last}=0 #1% \else \@escapeif{\expandnumberarg\forest@node@previousleafid@Godown{\forestOve{#1}{@last}}}% \fi } \def\forest@node@nextleafid{% \expandnumberarg\forest@node@Nextleafid{\forest@cn}% } \def\forest@node@Nextleafid#1{% \ifnum\forestOve{#1}{@next}=0 \@escapeif{\expandnumberarg\forest@node@nextleafid@Goup{#1}}% \else \expandnumberarg\forest@node@nextleafid@Godown{\forestOve{#1}{@next}}% \fi } \def\forest@node@nextleafid@Goup#1{% \ifnum\forestOve{#1}{@parent}=0 \PackageError{forest}{get next leaf: this is the last leaf}{}% \else \@escapeif{\expandnumberarg\forest@node@Nextleafid{\forestOve{#1}{@parent}}}% \fi } \def\forest@node@nextleafid@Godown#1{% \ifnum\forestOve{#1}{@first}=0 #1% \else \@escapeif{\expandnumberarg\forest@node@nextleafid@Godown{\forestOve{#1}{@first}}}% \fi } \def\forest@node@linearnextid{% \ifnum\forestove{@first}=0 \expandafter\forest@node@linearnextnotdescendantid \else \forestove{@first}% \fi } \def\forest@node@linearnextnotdescendantid{% \expandnumberarg\forest@node@Linearnextnotdescendantid{\forest@cn}% } \def\forest@node@Linearnextnotdescendantid#1{% \ifnum\forestOve{#1}{@next}=0 \@escapeif{\expandnumberarg\forest@node@Linearnextnotdescendantid{\forestOve{#1}{@parent}}}% \else \forestOve{#1}{@next}% \fi } \def\forest@node@linearpreviousid{% \ifnum\forestove{@previous}=0 \forestove{@parent}% \else \forest@node@previousleafid \fi } \def\forest@ifancestorof#1{% is the current node an ancestor of #1? Yes: #2, no: #3 \expandnumberarg\forest@ifancestorof@{\forestOve{#1}{@parent}}% } \def\forest@ifancestorof@#1#2#3{% \ifnum#1=0 \def\forest@ifancestorof@next{\@secondoftwo}% \else \ifnum\forest@cn=#1 \def\forest@ifancestorof@next{\@firstoftwo}% \else \def\forest@ifancestorof@next{\expandnumberarg\forest@ifancestorof@{\forestOve{#1}{@parent}}}% \fi \fi \forest@ifancestorof@next{#2}{#3}% } % \end{macrocode} % % % \subsection{Node walk} % % \begin{macrocode} \newloop\forest@nodewalk@loop \forestset{ @handlers@save@currentpath/.code={% \edef\pgfkeyscurrentkey{\pgfkeyscurrentpath}% \let\forest@currentkey\pgfkeyscurrentkey \pgfkeys@split@path \edef\forest@currentpath{\pgfkeyscurrentpath}% \let\forest@currentname\pgfkeyscurrentname }, /handlers/.step 0 args/.style={ /forest/@handlers@save@currentpath, \forest@currentkey/.code={#1\forestset{node walk/every step}}, /forest/for \forest@currentname/.style/.expanded={% for={\forest@currentname}{####1}% } }, /handlers/.step 1 arg/.style={% /forest/@handlers@save@currentpath, \forest@currentkey/.code={#1\forestset{node walk/every step}}, /forest/for \forest@currentname/.style 2 args/.expanded={% for={\forest@currentname=####1}{####2}% } }, node walk/.code={% \forestset{% node walk/before walk,% node walk/.cd, #1,% /forest/.cd, node walk/after walk }% }, for/.code 2 args={% \forest@forthis{% \pgfkeysalso{% node walk/before walk/.style={},% node walk/every step/.style={},% node walk/after walk/.style={/forest,if id=0{}{#2}},% %node walk/after walk/.style={#2},% node walk={#1}% }% }% }, node walk/.cd, before walk/.code={}, every step/.code={}, after walk/.code={}, current/.step 0 args={}, current/.default=1, next/.step 0 args={\edef\forest@cn{\forestove{@next}}}, next/.default=1, previous/.step 0 args={\edef\forest@cn{\forestove{@previous}}}, previous/.default=1, parent/.step 0 args={\edef\forest@cn{\forestove{@parent}}}, parent/.default=1, first/.step 0 args={\edef\forest@cn{\forestove{@first}}}, first/.default=1, last/.step 0 args={\edef\forest@cn{\forestove{@last}}}, last/.default=1, n/.step 1 arg={% \def\forest@nodewalk@temp{#1}% \ifx\forest@nodewalk@temp\pgfkeysnovalue@text \edef\forest@cn{\forestove{@next}}% \else \edef\forest@cn{\forest@node@nthchildid{#1}}% \fi }, n'/.step 1 arg={\edef\forest@cn{\forest@node@nbarthchildid{#1}}}, sibling/.step 0 args={% \edef\forest@cn{% \ifnum\forestove{@previous}=0 \forestove{@next}% \else \forestove{@previous}% \fi }% }, previous leaf/.step 0 args={\edef\forest@cn{\forest@node@previousleafid}}, previous leaf/.default=1, next leaf/.step 0 args={\edef\forest@cn{\forest@node@nextleafid}}, next leaf/.default=1, linear next/.step 0 args={\edef\forest@cn{\forest@node@linearnextid}}, linear previous/.step 0 args={\edef\forest@cn{\forest@node@linearpreviousid}}, first leaf/.step 0 args={% \forest@nodewalk@loop \edef\forest@cn{\forestove{@first}}% \unless\ifnum\forestove{@first}=0 \forest@nodewalk@repeat }, last leaf/.step 0 args={% \forest@nodewalk@loop \edef\forest@cn{\forestove{@last}}% \unless\ifnum\forestove{@last}=0 \forest@nodewalk@repeat }, to tier/.step 1 arg={% \def\forest@nodewalk@giventier{#1}% \forest@nodewalk@loop \forestoget{tier}\forest@nodewalk@tier \unless\ifx\forest@nodewalk@tier\forest@nodewalk@giventier \forestoget{@parent}\forest@cn \forest@nodewalk@repeat }, next on tier/.step 0 args={\forest@nodewalk@nextontier}, next on tier/.default=1, previous on tier/.step 0 args={\forest@nodewalk@previousontier}, previous on tier/.default=1, name/.step 1 arg={\edef\forest@cn{\forest@node@Nametoid{#1}}}, root/.step 0 args={\edef\forest@cn{\forest@node@rootid}}, root'/.step 0 args={\edef\forest@cn{\forest@root}}, id/.step 1 arg={\edef\forest@cn{#1}}, % maybe it's not wise to have short-step sequences and names potentially clashing % .unknown/.code={% % \forest@node@Ifnamedefined{\pgfkeyscurrentname}% % {\pgfkeysalso{name=\pgfkeyscurrentname}}% % {\expandafter\forest@nodewalk@shortsteps\pgfkeyscurrentname\forest@nodewalk@endshortsteps}% % }, .unknown/.code={% \expandafter\forest@nodewalk@shortsteps\pgfkeyscurrentname\forest@nodewalk@endshortsteps }, node walk/.style={/forest/node walk={#1}}, trip/.code={\forest@forthis{\pgfkeysalso{#1}}}, group/.code={\forest@go{#1}\forestset{node walk/every step}}, % repeat is taken later from /forest/repeat p/.style={previous=1}, %n/.style={next=1}, % defined in "long" n u/.style={parent=1}, s/.style={sibling}, c/.style={current=1}, r/.style={root}, P/.style={previous leaf=1}, N/.style={next leaf=1}, F/.style={first leaf=1}, L/.style={last leaf=1}, >/.style={next on tier=1}, 1 \pgfmathparse{#2}\let\forest@wrap@arg@ii\pgfmathresult\fi \ifnum#9>2 \pgfmathparse{#3}\let\forest@wrap@arg@iii\pgfmathresult\fi \ifnum#9>3 \pgfmathparse{#4}\let\forest@wrap@arg@iv\pgfmathresult\fi \ifnum#9>4 \pgfmathparse{#5}\let\forest@wrap@arg@v\pgfmathresult\fi \ifnum#9>5 \pgfmathparse{#6}\let\forest@wrap@arg@vi\pgfmathresult\fi \ifnum#9>6 \pgfmathparse{#7}\let\forest@wrap@arg@vii\pgfmathresult\fi \ifnum#9>7 \pgfmathparse{#8}\let\forest@wrap@arg@viii\pgfmathresult\fi \edef\forest@wrap@args{% {\expandonce\forest@wrap@arg@i} \ifnum#9>1 {\expandonce\forest@wrap@arg@ii}\fi \ifnum#9>2 {\expandonce\forest@wrap@arg@iii}\fi \ifnum#9>3 {\expandonce\forest@wrap@arg@iv}\fi \ifnum#9>4 {\expandonce\forest@wrap@arg@v}\fi \ifnum#9>5 {\expandonce\forest@wrap@arg@vi}\fi \ifnum#9>6 {\expandonce\forest@wrap@arg@vii}\fi \ifnum#9>7 {\expandonce\forest@wrap@arg@viii}\fi }% } \def\forest@wrap@n@pgfmath@do#1#2{% \ifcase#2\relax \or\def\forest@wrap@code##1{#1}% \or\def\forest@wrap@code##1##2{#1}% \or\def\forest@wrap@code##1##2##3{#1}% \or\def\forest@wrap@code##1##2##3##4{#1}% \or\def\forest@wrap@code##1##2##3##4##5{#1}% \or\def\forest@wrap@code##1##2##3##4##5##6{#1}% \or\def\forest@wrap@code##1##2##3##4##5##6##7{#1}% \or\def\forest@wrap@code##1##2##3##4##5##6##7##8{#1}% \fi \expandafter\expandafter\expandafter\def\expandafter\expandafter\expandafter\forest@wrapped\expandafter\expandafter\expandafter{\expandafter\forest@wrap@code\forest@wrap@args}% \pgfkeysalso{\pgfkeyscurrentpath/.expand once=\forest@wrapped}% } % \end{macrocode} % % \subsubsection{Declaring options} % % \begin{macrocode} \def\forest@node@setname#1{% \forestoeset{name}{#1}% \csedef{forest@id@of@#1}{\forest@cn}% } \def\forest@node@Nametoid#1{% #1 = name \csname forest@id@of@#1\endcsname } \def\forest@node@Ifnamedefined#1{% #1 = name, #2=true,#3=false \ifcsname forest@id@of@#1\endcsname \expandafter\@firstoftwo \else \expandafter\@secondoftwo \fi } \def\forest@node@setalias#1{% \csedef{forest@id@of@#1}{\forest@cn}% } \def\forest@node@Setalias#1#2{% \csedef{forest@id@of@#2}{#1}% } \forestset{ TeX/.code={#1}, TeX'/.code={\appto\forest@externalize@loadimages{#1}#1}, TeX''/.code={\appto\forest@externalize@loadimages{#1}}, declare toks={name}{}, name/.code={% override the default setter \forest@node@setname{#1}% }, alias/.code={\forest@node@setalias{#1}}, begin draw/.code={\begin{tikzpicture}}, end draw/.code={\end{tikzpicture}}, begin forest/.code={}, end forest/.code={}, declare autowrapped toks={content}{}, declare count={grow}{270}, TeX={% a hack for grow-reversed connection, and compass-based grow specification \pgfkeysgetvalue{/forest/grow/.@cmd}\forest@temp \pgfkeyslet{/forest/grow@@/.@cmd}\forest@temp }, grow/.style={grow@={#1},reversed=0}, grow'/.style={grow@={#1},reversed=1}, grow''/.style={grow@={#1}}, grow@/.is choice, grow@/east/.style={/forest/grow@@=0}, grow@/north east/.style={/forest/grow@@=45}, grow@/north/.style={/forest/grow@@=90}, grow@/north west/.style={/forest/grow@@=135}, grow@/west/.style={/forest/grow@@=180}, grow@/south west/.style={/forest/grow@@=225}, grow@/south/.style={/forest/grow@@=270}, grow@/south east/.style={/forest/grow@@=315}, grow@/.unknown/.code={\let\forest@temp@grow\pgfkeyscurrentname \pgfkeysalso{/forest/grow@@/.expand once=\forest@temp@grow}}, declare boolean={reversed}{0}, declare toks={parent anchor}{}, declare toks={child anchor}{}, declare toks={anchor}{base}, declare toks={calign}{midpoint}, TeX={% \pgfkeysgetvalue{/forest/calign/.@cmd}\forest@temp \pgfkeyslet{/forest/calign'/.@cmd}\forest@temp }, calign/.is choice, calign/child/.style={calign'=child}, calign/first/.style={calign'=child,calign primary child=1}, calign/last/.style={calign'=child,calign primary child=-1}, calign with current/.style={for parent/.wrap pgfmath arg={calign=child,calign primary child=##1}{n}}, calign with current edge/.style={for parent/.wrap pgfmath arg={calign=child edge,calign primary child=##1}{n}}, calign/child edge/.style={calign'=child edge}, calign/midpoint/.style={calign'=midpoint}, calign/center/.style={calign'=midpoint,calign primary child=1,calign secondary child=-1}, calign/edge midpoint/.style={calign'=edge midpoint}, calign/fixed angles/.style={calign'=fixed angles}, calign/fixed edge angles/.style={calign'=fixed edge angles}, calign/.unknown/.code={\PackageError{forest}{unknown calign '\pgfkeyscurrentname'}{}}, declare count={calign primary child}{1}, declare count={calign secondary child}{-1}, declare count={calign primary angle}{-35}, declare count={calign secondary angle}{35}, calign child/.style={calign primary child={#1}}, calign angle/.style={calign primary angle={-#1},calign secondary angle={#1}}, declare toks={tier}{}, declare toks={fit}{tight}, declare boolean={ignore}{0}, declare boolean={ignore edge}{0}, no edge/.style={edge'={},ignore edge}, declare keylist={edge}{draw}, declare toks={edge path}{% \noexpand\path[\forestoption{edge}]% (\forestOve{\forestove{@parent}}{name}.parent anchor)--(\forestove{name}.child anchor)\forestoption{edge label};}, triangle/.style={edge path={% \noexpand\path[\forestoption{edge}]% (\forestove{name}.north east)--(\forestOve{\forestove{@parent}}{name}.south)--(\forestove{name}.north west)--(\forestove{name}.north east)\forestoption{edge label};}}, declare toks={edge label}{}, declare boolean={phantom}{0}, baseline/.style={alias={forest@baseline@node}}, declare readonly count={n}, declare readonly count={n'}, declare readonly count={n children}, declare readonly count={level}, declare dimen=x{}, declare dimen=y{}, declare dimen={s}{0pt}, declare dimen={l}{6ex}, % just in case: should be set by the calibration declare dimen={s sep}{0.6666em}, declare dimen={l sep}{1ex}, % just in case: calibration! declare keylist={node options}{}, declare toks={tikz}{}, afterthought/.style={tikz+={#1}}, label/.style={tikz={\path[late options={% name=\forestoption{name},label={#1}}];}}, pin/.style={tikz={\path[late options={% name=\forestoption{name},pin={#1}}];}}, declare toks={content format}{\forestoption{content}}, math content/.style={content format={\ensuremath{\forestoption{content}}}}, declare toks={node format}{% \noexpand\node [\forestoption{node options},anchor=\forestoption{anchor}]% (\forestoption{name})% {\foresteoption{content format}};% }, tabular@environment/.style={content format={% \noexpand\begin{tabular}[\forestoption{base}]{\forestoption{align}}% \forestoption{content}% \noexpand\end{tabular}% }}, declare toks={align}{}, TeX={\pgfkeysgetvalue{/forest/align/.@cmd}\forest@temp \pgfkeyslet{/forest/align'/.@cmd}\forest@temp}, align/.is choice, align/.unknown/.code={% \edef\forest@marshal{% \noexpand\pgfkeysalso{% align'={\pgfkeyscurrentname},% tabular@environment }% }\forest@marshal }, align/center/.style={align'={@{}c@{}},tabular@environment}, align/left/.style={align'={@{}l@{}},tabular@environment}, align/right/.style={align'={@{}r@{}},tabular@environment}, declare toks={base}{t}, TeX={\pgfkeysgetvalue{/forest/base/.@cmd}\forest@temp \pgfkeyslet{/forest/base'/.@cmd}\forest@temp}, base/.is choice, base/top/.style={base'=t}, base/bottom/.style={base'=b}, base/.unknown/.style={base'/.expand once=\pgfkeyscurrentname}, .unknown/.code={% \expandafter\pgfutil@in@\expandafter.\expandafter{\pgfkeyscurrentname}% \ifpgfutil@in@ \expandafter\forest@relatednode@option@setter\pgfkeyscurrentname=#1\forest@END \else \edef\forest@marshal{% \noexpand\pgfkeysalso{node options={\pgfkeyscurrentname=\unexpanded{#1}}}% }\forest@marshal \fi }, get node boundary/.code={% \forestoget{boundary}\forest@node@boundary \def#1{}% \forest@extendpath#1\forest@node@boundary{\pgfpoint{\forestove{x}}{\forestove{y}}}% }, % get min l tree boundary/.code={% % \forest@get@tree@boundary{negative}{\the\numexpr\forestove{grow}-90\relax}#1}, % get max l tree boundary/.code={% % \forest@get@tree@boundary{positive}{\the\numexpr\forestove{grow}-90\relax}#1}, get min s tree boundary/.code={% \forest@get@tree@boundary{negative}{\forestove{grow}}#1}, get max s tree boundary/.code={% \forest@get@tree@boundary{positive}{\forestove{grow}}#1}, fit to tree/.code={% \pgfkeysalso{% /forest/get min s tree boundary=\forest@temp@negative@boundary, /forest/get max s tree boundary=\forest@temp@positive@boundary }% \edef\forest@temp@boundary{\expandonce{\forest@temp@negative@boundary}\expandonce{\forest@temp@positive@boundary}}% \forest@path@getboundingrectangle@xy\forest@temp@boundary \pgfkeysalso{inner sep=0,fit/.expanded={(\the\pgf@xa,\the\pgf@ya)(\the\pgf@xb,\the\pgf@yb)}}% }, use as bounding box/.style={% before drawing tree={ tikz+/.expanded={% \noexpand\pgfresetboundingbox \noexpand\useasboundingbox ($(.anchor)+(\forestoption{min x},\forestoption{min y})$) rectangle ($(.anchor)+(\forestoption{max x},\forestoption{max y})$) ; } } }, use as bounding box'/.style={% before drawing tree={ tikz+/.expanded={% \noexpand\pgfresetboundingbox \noexpand\useasboundingbox ($(.anchor)+(\forestoption{min x}+\pgfkeysvalueof{/pgf/outer xsep}/2+\pgfkeysvalueof{/pgf/inner xsep},\forestoption{min y}+\pgfkeysvalueof{/pgf/outer ysep}/2+\pgfkeysvalueof{/pgf/inner ysep})$) rectangle ($(.anchor)+(\forestoption{max x}-\pgfkeysvalueof{/pgf/outer xsep}/2-\pgfkeysvalueof{/pgf/inner xsep},\forestoption{max y}-\pgfkeysvalueof{/pgf/outer ysep}/2-\pgfkeysvalueof{/pgf/inner ysep})$) ; } } }, }% \def\forest@get@tree@boundary#1#2#3{%#1=pos/neg,#2=grow,#3=receiving cs \def#3{}% \forest@node@getedge{#1}{#2}\forest@temp@boundary \forest@extendpath#3\forest@temp@boundary{\pgfpoint{\forestove{x}}{\forestove{y}}}% } \def\forest@setter@node{\forest@cn}% \def\forest@relatednode@option@setter#1.#2=#3\forest@END{% \forest@forthis{% \forest@nameandgo{#1}% \let\forest@setter@node\forest@cn }% \pgfkeysalso{#2={#3}}% \def\forest@setter@node{\forest@cn}% }% % \end{macrocode} % % \subsubsection{Option propagation} % % The propagators targeting single nodes are automatically defined by node walk steps definitions. % % \begin{macrocode} \forestset{ for tree/.code={\forest@node@foreach{\pgfkeysalso{#1}}}, if/.code n args={3}{% \pgfmathparse{#1}% \ifnum\pgfmathresult=0 \pgfkeysalso{#3}\else\pgfkeysalso{#2}\fi }, where/.style n args={3}{for tree={if={#1}{#2}{#3}}}, for descendants/.code={\forest@node@foreachdescendant{\pgfkeysalso{#1}}}, for all next/.style={for next={#1,for all next={#1}}}, for all previous/.style={for previous={#1,for all previous={#1}}}, for siblings/.style={for all previous={#1},for all next={#1}}, for ancestors/.style={for parent={#1,for ancestors={#1}}}, for ancestors'/.style={#1,for ancestors={#1}}, for children/.code={\forest@node@foreachchild{\pgfkeysalso{#1}}}, for c-commanded={for sibling={for tree={#1}}}, for c-commanders={for sibling={#1},for parent={for c-commanders={#1}}} } % \end{macrocode} % % A bit of complication to allow for nested \keyname{repeat}s without \TeX\ groups. % \begin{macrocode} \newcount\forest@repeat@key@depth \forestset{% repeat/.code 2 args={% \advance\forest@repeat@key@depth1 \pgfmathparse{int(#1)}% \csedef{forest@repeat@key@\the\forest@repeat@key@depth}{\pgfmathresult}% \expandafter\newloop\csname forest@repeat@key@loop@\the\forest@repeat@key@depth\endcsname \def\forest@marshal{% \csname forest@repeat@key@loop@\the\forest@repeat@key@depth\endcsname \forest@temp@count=\csname forest@repeat@key@\the\forest@repeat@key@depth\endcsname\relax \ifnum\forest@temp@count>0 \advance\forest@temp@count-1 \csedef{forest@repeat@key@\the\forest@repeat@key@depth}{\the\forest@temp@count}% \pgfkeysalso{#2}% }% \expandafter\forest@marshal\csname forest@repeat@key@repeat@\the\forest@repeat@key@depth\endcsname \advance\forest@repeat@key@depth-1 }, } \pgfkeysgetvalue{/forest/repeat/.@cmd}\forest@temp \pgfkeyslet{/forest/node walk/repeat/.@cmd}\forest@temp % % \end{macrocode} % % \subsubsection{\texttt{pgfmath} extensions} % % \begin{macrocode} \pgfmathdeclarefunction{strequal}{2}{% \ifstrequal{#1}{#2}{\def\pgfmathresult{1}}{\def\pgfmathresult{0}}% } \pgfmathdeclarefunction{instr}{2}{% \pgfutil@in@{#1}{#2}% \ifpgfutil@in@\def\pgfmathresult{1}\else\def\pgfmathresult{0}\fi } \pgfmathdeclarefunction{strcat}{...}{% \edef\pgfmathresult{\forest@strip@braces{#1}}% } \def\forest@pgfmathhelper@attribute@toks#1#2{% \forest@forthis{% \forest@nameandgo{#1}% \forestoget{#2}\pgfmathresult }% } \def\forest@pgfmathhelper@attribute@dimen#1#2{% \forest@forthis{% \forest@nameandgo{#1}% \forestoget{#2}\forest@temp \pgfmathparse{+\forest@temp}% }% } \def\forest@pgfmathhelper@attribute@count#1#2{% \forest@forthis{% \forest@nameandgo{#1}% \forestoget{#2}\forest@temp \pgfmathtruncatemacro\pgfmathresult{\forest@temp}% }% } \pgfmathdeclarefunction{id}{1}{% \forest@forthis{% \forest@nameandgo{#1}% \let\pgfmathresult\forest@cn }% } \forestset{% if id/.code n args={3}{% \ifnum#1=\forest@cn\relax \pgfkeysalso{#2}% \else \pgfkeysalso{#3}% \fi }, where id/.style n args={3}{for tree={if id={#1}{#2}{#3}}} } % \end{macrocode} % % % \subsection{Dynamic tree} % \label{sec:impl:dynamic} % % \begin{macrocode} \def\forest@last@node{0} \def\forest@nodehandleby@name@nodewalk@or@bracket#1{% \ifx\pgfkeysnovalue#1% \edef\forest@last@node{\forest@node@Nametoid{forest@last@node}}% \else \forest@nodehandleby@nnb@checkfirst#1\forest@END \fi } \def\forest@nodehandleby@nnb@checkfirst#1#2\forest@END{% \ifx[#1%] \forest@create@node{#1#2}% \else \forest@forthis{% \forest@nameandgo{#1#2}% \let\forest@last@node\forest@cn }% \fi } \def\forest@create@node#1{% #1=bracket representation \bracketParse{\forest@create@collectafterthought}% \forest@last@node=#1\forest@end@create@node } \def\forest@create@collectafterthought#1\forest@end@create@node{% \forestOletO{\forest@last@node}{delay}{\forest@last@node}{given options}% \forestOset{\forest@last@node}{given options}{}% \forestOeappto{\forest@last@node}{delay}{,\unexpanded{#1}}% } \def\forest@create@collectafterthought#1\forest@end@create@node{% \forest@node@Foreach{\forest@last@node}{% \forestoleto{delay}{given options}% \forestoset{given options}{}% }% \forestOeappto{\forest@last@node}{delay}{,\unexpanded{#1}}% } \def\forest@remove@node#1{% \forest@node@Remove{#1}% } \def\forest@append@node#1#2{% \forest@node@Remove{#2}% \forest@node@Append{#1}{#2}% } \def\forest@prepend@node#1#2{% \forest@node@Remove{#2}% \forest@node@Prepend{#1}{#2}% } \def\forest@insertafter@node#1#2{% \forest@node@Remove{#2}% \forest@node@Insertafter{\forestOve{#1}{@parent}}{#2}{#1}% } \def\forest@insertbefore@node#1#2{% \forest@node@Remove{#2}% \forest@node@Insertbefore{\forestOve{#1}{@parent}}{#2}{#1}% } \def\forest@appto@do@dynamics#1#2{% \forest@nodehandleby@name@nodewalk@or@bracket{#2}% \ifcase\forest@dynamics@copyhow\relax\or \forest@tree@copy{\forest@last@node}\forest@last@node \or \forest@node@copy{\forest@last@node}\forest@last@node \fi \forest@node@Ifnamedefined{forest@last@node}{% \forestOepreto{\forest@last@node}{delay} {for id={\forest@node@Nametoid{forest@last@node}}{alias=forest@last@node},}% }{}% \forest@havedelayedoptionstrue \edef\forest@marshal{% \noexpand\apptotoks\noexpand\forest@do@dynamics{% \noexpand#1{\forest@cn}{\forest@last@node}}% }\forest@marshal } \forestset{% create/.code={\forest@create@node{#1}}, append/.code={\def\forest@dynamics@copyhow{0}\forest@appto@do@dynamics\forest@append@node{#1}}, prepend/.code={\def\forest@dynamics@copyhow{0}\forest@appto@do@dynamics\forest@prepend@node{#1}}, insert after/.code={\def\forest@dynamics@copyhow{0}\forest@appto@do@dynamics\forest@insertafter@node{#1}}, insert before/.code={\def\forest@dynamics@copyhow{0}\forest@appto@do@dynamics\forest@insertbefore@node{#1}}, append'/.code={\def\forest@dynamics@copyhow{1}\forest@appto@do@dynamics\forest@append@node{#1}}, prepend'/.code={\def\forest@dynamics@copyhow{1}\forest@appto@do@dynamics\forest@prepend@node{#1}}, insert after'/.code={\def\forest@dynamics@copyhow{1}\forest@appto@do@dynamics\forest@insertafter@node{#1}}, insert before'/.code={\def\forest@dynamics@copyhow{1}\forest@appto@do@dynamics\forest@insertbefore@node{#1}}, append''/.code={\def\forest@dynamics@copyhow{2}\forest@appto@do@dynamics\forest@append@node{#1}}, prepend''/.code={\def\forest@dynamics@copyhow{2}\forest@appto@do@dynamics\forest@prepend@node{#1}}, insert after''/.code={\def\forest@dynamics@copyhow{2}\forest@appto@do@dynamics\forest@insertafter@node{#1}}, insert before''/.code={\def\forest@dynamics@copyhow{2}\forest@appto@do@dynamics\forest@insertbefore@node{#1}}, remove/.code={% \pgfkeysalso{alias=forest@last@node}% \expandafter\apptotoks\expandafter\forest@do@dynamics\expandafter{% \expandafter\forest@remove@node\expandafter{\forest@cn}}% }, set root/.code={% \forest@nodehandleby@name@nodewalk@or@bracket{#1}% \edef\forest@marshal{% \noexpand\apptotoks\noexpand\forest@do@dynamics{% \def\noexpand\forest@root{\forest@last@node}% }% }\forest@marshal }, replace by/.code={\forest@replaceby@code{#1}{insert after}}, replace by'/.code={\forest@replaceby@code{#1}{insert after'}}, replace by''/.code={\forest@replaceby@code{#1}{insert after''}}, } \def\forest@replaceby@code#1#2{%#1=node spec,#2=insert after[']['] \ifnum\forestove{@parent}=0 \pgfkeysalso{set root={#1}}% \else \pgfkeysalso{alias=forest@last@node,#2={#1}}% \eapptotoks\forest@do@dynamics{% \noexpand\ifnum\noexpand\forestOve{\forest@cn}{@parent}=\forestove{@parent} \noexpand\forest@remove@node{\forest@cn}% \noexpand\fi }% \fi } % \end{macrocode} % % \section{Stages} % % \begin{macrocode} \forestset{ stages/.style={ process keylist=before typesetting nodes, typeset nodes stage, process keylist=before packing, pack stage, process keylist=before computing xy, compute xy stage, process keylist=before drawing tree, draw tree stage, }, typeset nodes stage/.style={for root'=typeset nodes}, pack stage/.style={for root'=pack}, compute xy stage/.style={for root'=compute xy}, draw tree stage/.style={for root'=draw tree}, process keylist/.code={\forest@process@hook@keylist{#1}}, declare keylist={given options}{}, declare keylist={before typesetting nodes}{}, declare keylist={before packing}{}, declare keylist={before computing xy}{}, declare keylist={before drawing tree}{}, declare keylist={delay}{}, delay/.append code={\forest@havedelayedoptionstrue}, delay n/.style 2 args={if={#1==0}{#2}{delay@n={#1}{#2}}}, delay@n/.style 2 args={ if={#1==1}{delay={#2}}{delay={delay@n/.wrap pgfmath arg={{##1}{#2}}{#1-1}}} }, if have delayed/.code 2 args={% \ifforest@havedelayedoptions\pgfkeysalso{#1}\else\pgfkeysalso{#2}\fi }, typeset nodes/.code={% \forest@drawtree@preservenodeboxes@false \forest@node@foreach{\forest@node@typeset}}, typeset nodes'/.code={% \forest@drawtree@preservenodeboxes@true \forest@node@foreach{\forest@node@typeset}}, typeset node/.code={% \forest@drawtree@preservenodeboxes@false \forest@node@typeset }, pack/.code={\forest@pack}, pack'/.code={\forest@pack@onlythisnode}, compute xy/.code={\forest@node@computeabsolutepositions}, draw tree box/.store in=\forest@drawtreebox, draw tree box, draw tree/.code={% \forest@drawtree@preservenodeboxes@false \forest@node@drawtree }, draw tree'/.code={% \forest@drawtree@preservenodeboxes@true \forest@node@drawtree }, } \newtoks\forest@do@dynamics \newif\ifforest@havedelayedoptions \def\forest@process@hook@keylist#1{% \forest@loopa \forest@havedelayedoptionsfalse \forest@do@dynamics={}% \forest@fornode{\forest@root}{\forest@process@hook@keylist@{#1}}% \expandafter\ifstrempty\expandafter{\the\forest@do@dynamics}{}{% \the\forest@do@dynamics \forest@node@Compute@numeric@ts@info{\forest@root}% \forest@havedelayedoptionstrue }% \ifforest@havedelayedoptions \forest@node@Foreach{\forest@root}{% \forestoget{delay}\forest@temp@delayed \forestolet{#1}\forest@temp@delayed \forestoset{delay}{}% }% \forest@repeata } \def\forest@process@hook@keylist@#1{% \forest@node@foreach{% \forestoget{#1}\forest@temp@keys \ifdefvoid\forest@temp@keys{}{% \forestoset{#1}{}% \expandafter\forestset\expandafter{\forest@temp@keys}% }% }% } % \end{macrocode} % % % \subsection{Typesetting nodes} % % \begin{macrocode} \def\forest@node@typeset{% \let\forest@next\forest@node@typeset@ \forestoifdefined{box}{% \ifforest@drawtree@preservenodeboxes@ \let\forest@next\relax \fi }{% \locbox\forest@temp@box \forestolet{box}\forest@temp@box }% \def\forest@node@typeset@restore{}% \ifdefined\ifsa@tikz\forest@standalone@hack\fi \forest@next \forest@node@typeset@restore } \def\forest@standalone@hack{% \ifsa@tikz \let\forest@standalone@tikzpicture\tikzpicture \let\forest@standalone@endtikzpicture\endtikzpicture \let\tikzpicture\sa@orig@tikzpicture \let\endtikzpicture\sa@orig@endtikzpicture \def\forest@node@typeset@restore{% \let\tikzpicture\forest@standalone@tikzpicture \let\endtikzpicture\forest@standalone@endtikzpicture }% \fi } \newbox\forest@box \def\forest@node@typeset@{% \forestoget{name}\forest@nodename \edef\forest@temp@nodeformat{\forestove{node format}}% \gdef\forest@smuggle{}% \setbox0=\hbox{% \begin{tikzpicture}% \pgfpositionnodelater{\forest@positionnodelater@save}% \forest@temp@nodeformat \pgfinterruptpath \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{forestcomputenodeboundary}% \endpgfinterruptpath %\forest@compute@node@boundary\forest@temp %\xappto\forest@smuggle{\noexpand\forestoset{boundary}{\expandonce\forest@temp}}% \if\relax\forestove{parent anchor}\relax \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{center}% \else \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{\forestove{parent anchor}}% \fi \xappto\forest@smuggle{% \noexpand\forestoset{parent@anchor}{% \noexpand\noexpand\noexpand\pgf@x=\the\pgf@x\relax \noexpand\noexpand\noexpand\pgf@y=\the\pgf@y\relax}}% \if\relax\forestove{child anchor}\relax \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{center}% \else \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{\forestove{child anchor}}% \fi \xappto\forest@smuggle{% \noexpand\forestoeset{child@anchor}{% \noexpand\noexpand\noexpand\pgf@x=\the\pgf@x\relax \noexpand\noexpand\noexpand\pgf@y=\the\pgf@y\relax}}% \if\relax\forestove{anchor}\relax \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{center}% \else \pgfpointanchor{\forest@pgf@notyetpositioned\forest@nodename}{\forestove{anchor}}% \fi \xappto\forest@smuggle{% \noexpand\forestoeset{@anchor}{% \noexpand\noexpand\noexpand\pgf@x=\the\pgf@x\relax \noexpand\noexpand\noexpand\pgf@y=\the\pgf@y\relax}}% \end{tikzpicture}% }% \setbox\forestove{box}=\box\forest@box % smuggle the box \forestolet{boundary}\forest@global@boundary \forest@smuggle % ... and the rest } \forestset{ declare readonly dimen={min x}, declare readonly dimen={min y}, declare readonly dimen={max x}, declare readonly dimen={max y}, } \def\forest@patch@enormouscoordinateboxbounds@plus#1{% \expandafter\ifstrequal\expandafter{#1}{16000.0pt}{\def#1{0.0pt}}{}% } \def\forest@patch@enormouscoordinateboxbounds@minus#1{% \expandafter\ifstrequal\expandafter{#1}{-16000.0pt}{\def#1{0.0pt}}{}% } \def\forest@positionnodelater@save{% \global\setbox\forest@box=\box\pgfpositionnodelaterbox \xappto\forest@smuggle{\noexpand\forestoset{later@name}{\pgfpositionnodelatername}}% % a bug in pgf? ---well, here's a patch \forest@patch@enormouscoordinateboxbounds@plus\pgfpositionnodelaterminx \forest@patch@enormouscoordinateboxbounds@plus\pgfpositionnodelaterminy \forest@patch@enormouscoordinateboxbounds@minus\pgfpositionnodelatermaxx \forest@patch@enormouscoordinateboxbounds@minus\pgfpositionnodelatermaxy % end of patch \xappto\forest@smuggle{\noexpand\forestoset{min x}{\pgfpositionnodelaterminx}}% \xappto\forest@smuggle{\noexpand\forestoset{min y}{\pgfpositionnodelaterminy}}% \xappto\forest@smuggle{\noexpand\forestoset{max x}{\pgfpositionnodelatermaxx}}% \xappto\forest@smuggle{\noexpand\forestoset{max y}{\pgfpositionnodelatermaxy}}% } \def\forest@node@forest@positionnodelater@restore{% \ifforest@drawtree@preservenodeboxes@ \let\forest@boxorcopy\copy \else \let\forest@boxorcopy\box \fi \forestoget{box}\forest@temp \setbox\pgfpositionnodelaterbox=\forest@boxorcopy\forest@temp \edef\pgfpositionnodelatername{\forestove{later@name}}% \edef\pgfpositionnodelaterminx{\forestove{min x}}% \edef\pgfpositionnodelaterminy{\forestove{min y}}% \edef\pgfpositionnodelatermaxx{\forestove{max x}}% \edef\pgfpositionnodelatermaxy{\forestove{max y}}% } % \end{macrocode} % % \subsection{Packing} % \label{imp:packing} % % Method |pack| should be called to calculate the positions of % descendant nodes; the positions are stored in attributes |l| and |s| % of these nodes, in a level/sibling coordinate system with origin at % the parent's anchor. % \begin{macrocode} \def\forest@pack{% \forest@pack@computetiers \forest@pack@computegrowthuniformity \forest@@pack } \def\forest@@pack{% \ifnum\forestove{n children}>0 \ifnum\forestove{uniform growth}>0 \forest@pack@level@uniform \forest@pack@aligntiers@ofsubtree \forest@pack@sibling@uniform@recursive \else \forest@node@foreachchild{\forest@@pack}% \forest@pack@level@nonuniform \forest@pack@aligntiers \forest@pack@sibling@uniform@applyreversed \fi \fi } \def\forest@pack@onlythisnode{% \ifnum\forestove{n children}>0 \forest@pack@computetiers \forest@pack@level@nonuniform \forest@pack@aligntiers \forest@pack@sibling@uniform@applyreversed \fi } % \end{macrocode} % % Compute growth uniformity for the subtree. A tree grows uniformly is all its branching nodes have % the same |grow|. % \begin{macrocode} \def\forest@pack@computegrowthuniformity{% \forest@node@foreachchild{\forest@pack@computegrowthuniformity}% \edef\forest@pack@cgu@uniformity{% \ifnum\forestove{n children}=0 2\else 1\fi }% \forestoget{grow}\forest@pack@cgu@parentgrow \forest@node@foreachchild{% \ifnum\forestove{uniform growth}=0 \def\forest@pack@cgu@uniformity{0}% \else \ifnum\forestove{uniform growth}=1 \ifnum\forestove{grow}=\forest@pack@cgu@parentgrow\relax\else \def\forest@pack@cgu@uniformity{0}% \fi \fi \fi }% \forestolet{uniform growth}\forest@pack@cgu@uniformity } % \end{macrocode} % % Pack children in the level dimension in a uniform tree. % \begin{macrocode} \def\forest@pack@level@uniform{% \let\forest@plu@minchildl\relax \forestoget{grow}\forest@plu@grow \forest@node@foreachchild{% \forest@node@getboundingrectangle@ls{\forest@plu@grow}% \advance\pgf@xa\forestove{l}\relax \ifx\forest@plu@minchildl\relax \edef\forest@plu@minchildl{\the\pgf@xa}% \else \ifdim\pgf@xa<\forest@plu@minchildl\relax \edef\forest@plu@minchildl{\the\pgf@xa}% \fi \fi }% \forest@node@getboundingrectangle@ls{\forest@plu@grow}% \pgfutil@tempdima=\pgf@xb\relax \advance\pgfutil@tempdima -\forest@plu@minchildl\relax \advance\pgfutil@tempdima \forestove{l sep}\relax \ifdim\pgfutil@tempdima>0pt \forest@node@foreachchild{% \forestoeset{l}{\the\dimexpr\forestove{l}+\the\pgfutil@tempdima}% }% \fi \forest@node@foreachchild{% \ifnum\forestove{n children}>0 \forest@pack@level@uniform \fi }% } % \end{macrocode} % % Pack children in the level dimension in a non-uniform tree. (Expects % the children to be fully packed.) % \begin{macrocode} \def\forest@pack@level@nonuniform{% \let\forest@plu@minchildl\relax \forestoget{grow}\forest@plu@grow \forest@node@foreachchild{% \forest@node@getedge{negative}{\forest@plu@grow}{\forest@plnu@negativechildedge}% \forest@node@getedge{positive}{\forest@plu@grow}{\forest@plnu@positivechildedge}% \def\forest@plnu@childedge{\forest@plnu@negativechildedge\forest@plnu@positivechildedge}% \forest@path@getboundingrectangle@ls\forest@plnu@childedge{\forest@plu@grow}% \advance\pgf@xa\forestove{l}\relax \ifx\forest@plu@minchildl\relax \edef\forest@plu@minchildl{\the\pgf@xa}% \else \ifdim\pgf@xa<\forest@plu@minchildl\relax \edef\forest@plu@minchildl{\the\pgf@xa}% \fi \fi }% \forest@node@getboundingrectangle@ls{\forest@plu@grow}% \pgfutil@tempdima=\pgf@xb\relax \advance\pgfutil@tempdima -\forest@plu@minchildl\relax \advance\pgfutil@tempdima \forestove{l sep}\relax \ifdim\pgfutil@tempdima>0pt \forest@node@foreachchild{% \forestoeset{l}{\the\dimexpr\the\pgfutil@tempdima+\forestove{l}}% }% \fi } % \end{macrocode} % % Align tiers. % \begin{macrocode} \def\forest@pack@aligntiers{% \forestoget{grow}\forest@temp@parentgrow \forestoget{@tiers}\forest@temp@tiers \forlistloop\forest@pack@aligntier@\forest@temp@tiers } \def\forest@pack@aligntiers@ofsubtree{% \forest@node@foreach{\forest@pack@aligntiers}% } \def\forest@pack@aligntiers@computeabsl{% \forestoleto{abs@l}{l}% \forest@node@foreachdescendant{\forest@pack@aligntiers@computeabsl@}% } \def\forest@pack@aligntiers@computeabsl@{% \forestoeset{abs@l}{\the\dimexpr\forestove{l}+\forestOve{\forestove{@parent}}{abs@l}}% } \def\forest@pack@aligntier@#1{% \forest@pack@aligntiers@computeabsl \pgfutil@tempdima=-\maxdimen\relax \def\forest@temp@currenttier{#1}% \forest@node@foreach{% \forestoget{tier}\forest@temp@tier \ifx\forest@temp@currenttier\forest@temp@tier \ifdim\pgfutil@tempdima<\forestove{abs@l}\relax \pgfutil@tempdima=\forestove{abs@l}\relax \fi \fi }% \ifdim\pgfutil@tempdima=-\maxdimen\relax\else \forest@node@foreach{% \forestoget{tier}\forest@temp@tier \ifx\forest@temp@currenttier\forest@temp@tier \forestoeset{l}{\the\dimexpr\pgfutil@tempdima-\forestove{abs@l}+\forestove{l}}% \fi }% \fi } % \end{macrocode} % Pack children in the sibling dimension in a uniform tree: % recursion. % \begin{macrocode} \def\forest@pack@sibling@uniform@recursive{% \forest@node@foreachchild{\forest@pack@sibling@uniform@recursive}% \forest@pack@sibling@uniform@applyreversed } % \end{macrocode} % Pack children in the sibling dimension in a uniform tree: applyreversed. % \begin{macrocode} \def\forest@pack@sibling@uniform@applyreversed{% \ifnum\forestove{n children}>1 \ifnum\forestove{reversed}=0 \pack@sibling@uniform@main{first}{last}{next}{previous}% \else \pack@sibling@uniform@main{last}{first}{previous}{next}% \fi \fi } % \end{macrocode} % Pack children in the sibling dimension in a uniform tree: the main % routine. % \begin{macrocode} \def\pack@sibling@uniform@main#1#2#3#4{% % \end{macrocode} % Loop through the children. At each iteration, we compute the % distance between the negative edge of the current child and the % positive edge of the block of the previous children, and then set % the |s| attribute of the current child accordingly. % % We start the loop with the second (to last) child, having % initialized the positive edge of the previous children to the % positive edge of the first child. % \begin{macrocode} \forestoget{@#1}\forest@child \edef\forest@temp{% \noexpand\forest@fornode{\forestove{@#1}}{% \noexpand\forest@node@getedge {positive} {\forestove{grow}} \noexpand\forest@temp@edge }% }\forest@temp \forest@pack@pgfpoint@childsposition\forest@child \let\forest@previous@positive@edge\pgfutil@empty \forest@extendpath\forest@previous@positive@edge\forest@temp@edge{}% \forestOget{\forest@child}{@#3}\forest@child % \end{macrocode} % Loop until the current child is the null node. % \begin{macrocode} \edef\forest@previous@child@s{0pt}% \forest@loopb \unless\ifnum\forest@child=0 % \end{macrocode} % Get the negative edge of the child. % \begin{macrocode} \edef\forest@temp{% \noexpand\forest@fornode{\forest@child}{% \noexpand\forest@node@getedge {negative} {\forestove{grow}} \noexpand\forest@temp@edge }% }\forest@temp % \end{macrocode} % Set |\pgf@x| and |\pgf@y| to the position of the child (in the % coordinate system of this node). % \begin{macrocode} \forest@pack@pgfpoint@childsposition\forest@child % \end{macrocode} % Translate the edge of the child by the child's position. % \begin{macrocode} \let\forest@child@negative@edge\pgfutil@empty \forest@extendpath\forest@child@negative@edge\forest@temp@edge{}% % \end{macrocode} % Setup the grow line: the angle is given by this node's |grow| % attribute. % \begin{macrocode} \forest@setupgrowline{\forestove{grow}}% % \end{macrocode} % Get the distance (wrt the grow line) between the positive edge of % the previous children and the negative edge of the current % child. (The distance can be negative!) % \begin{macrocode} \forest@distance@between@edge@paths\forest@previous@positive@edge\forest@child@negative@edge\forest@csdistance % \end{macrocode} % If the distance is |\relax|, the projections of the edges onto the % grow line don't overlap: do nothing. Otherwise, shift the current child so that its distance to the block % of previous children is |s_sep|. % \begin{macrocode} \ifx\forest@csdistance\relax %\forestOeset{\forest@child}{s}{\forest@previous@child@s}% \else \advance\pgfutil@tempdimb-\forest@csdistance\relax \advance\pgfutil@tempdimb\forestove{s sep}\relax \forestOeset{\forest@child}{s}{\the\dimexpr\forestove{s}-\forest@csdistance+\forestove{s sep}}% \fi % \end{macrocode} % Retain monotonicity (is this ok?). (This problem arises when the adjacent children's |l| are too % far apart.) % \begin{macrocode} \ifdim\forestOve{\forest@child}{s}<\forest@previous@child@s\relax \forestOeset{\forest@child}{s}{\forest@previous@child@s}% \fi % \end{macrocode} % Prepare for the next iteration: add the current child's positive % edge to the positive edge of the previous children, and set up the % next current child. % \begin{macrocode} \forestOget{\forest@child}{s}\forest@child@s \edef\forest@previous@child@s{\forest@child@s}% \edef\forest@temp{% \noexpand\forest@fornode{\forest@child}{% \noexpand\forest@node@getedge {positive} {\forestove{grow}} \noexpand\forest@temp@edge }% }\forest@temp \forest@pack@pgfpoint@childsposition\forest@child \forest@extendpath\forest@previous@positive@edge\forest@temp@edge{}% \forest@getpositivetightedgeofpath\forest@previous@positive@edge\forest@previous@positive@edge \forestOget{\forest@child}{@#3}\forest@child \forest@repeatb % \end{macrocode} % Shift the position of all children to achieve the desired alignment % of the parent and its children. % \begin{macrocode} \csname forest@calign@\forestove{calign}\endcsname } % \end{macrocode} % Get the position of child |#1| in the current node, in node's l-s % coordinate system. % \begin{macrocode} \def\forest@pack@pgfpoint@childsposition#1{% {% \pgftransformreset \pgftransformrotate{\forestove{grow}}% \forest@fornode{#1}{% \pgfpointtransformed{\pgfqpoint{\forestove{l}}{\forestove{s}}}% }% }% } % \end{macrocode} % Get the position of the node in the grow (|#1|)-rotated coordinate % system. % \begin{macrocode} \def\forest@pack@pgfpoint@positioningrow#1{% {% \pgftransformreset \pgftransformrotate{#1}% \pgfpointtransformed{\pgfqpoint{\forestove{l}}{\forestove{s}}}% }% } % \end{macrocode} % % Child alignment. % \begin{macrocode} \def\forest@calign@s@shift#1{% \pgfutil@tempdima=#1\relax \forest@node@foreachchild{% \forestoeset{s}{\the\dimexpr\forestove{s}+\pgfutil@tempdima}% }% } \def\forest@calign@child{% \forest@calign@s@shift{-\forestOve{\forest@node@nornbarthchildid{\forestove{calign primary child}}}{s}}% } \csdef{forest@calign@child edge}{% {% \edef\forest@temp@child{\forest@node@nornbarthchildid{\forestove{calign primary child}}}% \pgftransformreset \pgftransformrotate{\forestove{grow}}% \pgfpointtransformed{\pgfqpoint{\forestOve{\forest@temp@child}{l}}{\forestOve{\forest@temp@child}{s}}}% \pgf@xa=\pgf@x\relax\pgf@ya=\pgf@y\relax \forestOve{\forest@temp@child}{child@anchor}% \advance\pgf@xa\pgf@x\relax\advance\pgf@ya\pgf@y\relax \forestove{parent@anchor}% \advance\pgf@xa-\pgf@x\relax\advance\pgf@ya-\pgf@y\relax \edef\forest@marshal{% \noexpand\pgftransformreset \noexpand\pgftransformrotate{-\forestove{grow}}% \noexpand\pgfpointtransformed{\noexpand\pgfqpoint{\the\pgf@xa}{\the\pgf@ya}}% }\forest@marshal }% \forest@calign@s@shift{\the\dimexpr-\the\pgf@y}% } \csdef{forest@calign@midpoint}{% \forest@calign@s@shift{\the\dimexpr 0pt -% (\forestOve{\forest@node@nornbarthchildid{\forestove{calign primary child}}}{s}% +\forestOve{\forest@node@nornbarthchildid{\forestove{calign secondary child}}}{s}% )/2\relax }% } \csdef{forest@calign@edge midpoint}{% {% \edef\forest@temp@firstchild{\forest@node@nornbarthchildid{\forestove{calign primary child}}}% \edef\forest@temp@secondchild{\forest@node@nornbarthchildid{\forestove{calign secondary child}}}% \pgftransformreset \pgftransformrotate{\forestove{grow}}% \pgfpointtransformed{\pgfqpoint{\forestOve{\forest@temp@firstchild}{l}}{\forestOve{\forest@temp@firstchild}{s}}}% \pgf@xa=\pgf@x\relax\pgf@ya=\pgf@y\relax \forestOve{\forest@temp@firstchild}{child@anchor}% \advance\pgf@xa\pgf@x\relax\advance\pgf@ya\pgf@y\relax \edef\forest@marshal{% \noexpand\pgfpointtransformed{\noexpand\pgfqpoint{\forestOve{\forest@temp@secondchild}{l}}{\forestOve{\forest@temp@secondchild}{s}}}% }\forest@marshal \advance\pgf@xa\pgf@x\relax\advance\pgf@ya\pgf@y\relax \forestOve{\forest@temp@secondchild}{child@anchor}% \advance\pgf@xa\pgf@x\relax\advance\pgf@ya\pgf@y\relax \divide\pgf@xa2 \divide\pgf@ya2 \edef\forest@marshal{% \noexpand\pgftransformreset \noexpand\pgftransformrotate{-\forestove{grow}}% \noexpand\pgfpointtransformed{\noexpand\pgfqpoint{\the\pgf@xa}{\the\pgf@ya}}% }\forest@marshal }% \forest@calign@s@shift{\the\dimexpr-\the\pgf@y}% } % \end{macrocode} % Aligns the children to the center of the angles given by the options % |calign_first_angle| and |calign_second_angle| and spreads them additionally if needed to fill the % whole % space determined by the option. The version |fixed_angles| calculates the % angles between node anchors; the version |fixes_edge_angles| calculates the angles between the % node edges. % \begin{macrocode} \csdef{forest@calign@fixed angles}{% \edef\forest@ca@first@child{\forest@node@nornbarthchildid{\forestove{calign primary child}}}% \edef\forest@ca@second@child{\forest@node@nornbarthchildid{\forestove{calign secondary child}}}% \ifnum\forestove{reversed}=1 \let\forest@temp\forest@ca@first@child \let\forest@ca@first@child\forest@ca@second@child \let\forest@ca@second@child\forest@temp \fi \forestOget{\forest@ca@first@child}{l}\forest@ca@first@l \forestOget{\forest@ca@second@child}{l}\forest@ca@second@l \pgfmathsetlengthmacro\forest@ca@desired@s@distance{% tan(\forestove{calign secondary angle})*\forest@ca@second@l -tan(\forestove{calign primary angle})*\forest@ca@first@l }% \forestOget{\forest@ca@first@child}{s}\forest@ca@first@s \forestOget{\forest@ca@second@child}{s}\forest@ca@second@s \pgfmathsetlengthmacro\forest@ca@actual@s@distance{% \forest@ca@second@s-\forest@ca@first@s}% \ifdim\forest@ca@desired@s@distance>\forest@ca@actual@s@distance\relax \ifdim\forest@ca@actual@s@distance=0pt \pgfmathsetlength\pgfutil@tempdima{tan(\forestove{calign primary angle})*\forest@ca@second@l}% \pgfmathsetlength\pgfutil@tempdimb{\forest@ca@desired@s@distance/(\forestove{n children}-1)}% \forest@node@foreachchild{% \forestoeset{s}{\the\pgfutil@tempdima}% \advance\pgfutil@tempdima\pgfutil@tempdimb }% \def\forest@calign@anchor{0pt}% \else \pgfmathsetmacro\forest@ca@ratio{% \forest@ca@desired@s@distance/\forest@ca@actual@s@distance}% \forest@node@foreachchild{% \pgfmathsetlengthmacro\forest@temp{\forest@ca@ratio*\forestove{s}}% \forestolet{s}\forest@temp }% \pgfmathsetlengthmacro\forest@calign@anchor{% -tan(\forestove{calign primary angle})*\forest@ca@first@l}% \fi \else \ifdim\forest@ca@desired@s@distance<\forest@ca@actual@s@distance\relax \pgfmathsetlengthmacro\forest@ca@ratio{% \forest@ca@actual@s@distance/\forest@ca@desired@s@distance}% \forest@node@foreachchild{% \pgfmathsetlengthmacro\forest@temp{\forest@ca@ratio*\forestove{l}}% \forestolet{l}\forest@temp }% \forestOget{\forest@ca@first@child}{l}\forest@ca@first@l \pgfmathsetlengthmacro\forest@calign@anchor{% -tan(\forestove{calign primary angle})*\forest@ca@first@l}% \fi \fi \forest@calign@s@shift{-\forest@calign@anchor}% } \csdef{forest@calign@fixed edge angles}{% \edef\forest@ca@first@child{\forest@node@nornbarthchildid{\forestove{calign primary child}}}% \edef\forest@ca@second@child{\forest@node@nornbarthchildid{\forestove{calign secondary child}}}% \ifnum\forestove{reversed}=1 \let\forest@temp\forest@ca@first@child \let\forest@ca@first@child\forest@ca@second@child \let\forest@ca@second@child\forest@temp \fi \forestOget{\forest@ca@first@child}{l}\forest@ca@first@l \forestOget{\forest@ca@second@child}{l}\forest@ca@second@l \forestoget{parent@anchor}\forest@ca@parent@anchor \forest@ca@parent@anchor \edef\forest@ca@parent@anchor@s{\the\pgf@x}% \edef\forest@ca@parent@anchor@l{\the\pgf@y}% \forestOget{\forest@ca@first@child}{child@anchor}\forest@ca@first@child@anchor \forest@ca@first@child@anchor \edef\forest@ca@first@child@anchor@s{\the\pgf@x}% \edef\forest@ca@first@child@anchor@l{\the\pgf@y}% \forestOget{\forest@ca@second@child}{child@anchor}\forest@ca@second@child@anchor \forest@ca@second@child@anchor \edef\forest@ca@second@child@anchor@s{\the\pgf@x}% \edef\forest@ca@second@child@anchor@l{\the\pgf@y}% \pgfmathsetlengthmacro\forest@ca@desired@second@edge@s{tan(\forestove{calign secondary angle})*% (\forest@ca@second@l-\forest@ca@second@child@anchor@l+\forest@ca@parent@anchor@l)}% \pgfmathsetlengthmacro\forest@ca@desired@first@edge@s{tan(\forestove{calign primary angle})*% (\forest@ca@first@l-\forest@ca@first@child@anchor@l+\forest@ca@parent@anchor@l)} \pgfmathsetlengthmacro\forest@ca@desired@s@distance{\forest@ca@desired@second@edge@s-\forest@ca@desired@first@edge@s}% \forestOget{\forest@ca@first@child}{s}\forest@ca@first@s \forestOget{\forest@ca@second@child}{s}\forest@ca@second@s \pgfmathsetlengthmacro\forest@ca@actual@s@distance{% \forest@ca@second@s+\forest@ca@second@child@anchor@s -\forest@ca@first@s-\forest@ca@first@child@anchor@s}% \ifdim\forest@ca@desired@s@distance>\forest@ca@actual@s@distance\relax \ifdim\forest@ca@actual@s@distance=0pt \forestoget{n children}\forest@temp@n@children \forest@node@foreachchild{% \forestoget{child@anchor}\forest@temp@child@anchor \forest@temp@child@anchor \edef\forest@temp@child@anchor@s{\the\pgf@x}% \pgfmathsetlengthmacro\forest@temp{% \forest@ca@desired@first@edge@s+(\forestove{n}-1)*\forest@ca@desired@s@distance/(\forest@temp@n@children-1)+\forest@ca@first@child@anchor@s-\forest@temp@child@anchor@s}% \forestolet{s}\forest@temp }% \def\forest@calign@anchor{0pt}% \else \pgfmathsetmacro\forest@ca@ratio{% \forest@ca@desired@s@distance/\forest@ca@actual@s@distance}% \forest@node@foreachchild{% \forestoget{child@anchor}\forest@temp@child@anchor \forest@temp@child@anchor \edef\forest@temp@child@anchor@s{\the\pgf@x}% \pgfmathsetlengthmacro\forest@temp{% \forest@ca@ratio*(% \forestove{s}-\forest@ca@first@s +\forest@temp@child@anchor@s-\forest@ca@first@child@anchor@s)% +\forest@ca@first@s +\forest@ca@first@child@anchor@s-\forest@temp@child@anchor@s}% \forestolet{s}\forest@temp }% \pgfmathsetlengthmacro\forest@calign@anchor{% -tan(\forestove{calign primary angle})*(\forest@ca@first@l-\forest@ca@first@child@anchor@l+\forest@ca@parent@anchor@l)% +\forest@ca@first@child@anchor@s-\forest@ca@parent@anchor@s }% \fi \else \ifdim\forest@ca@desired@s@distance<\forest@ca@actual@s@distance\relax \pgfmathsetlengthmacro\forest@ca@ratio{% \forest@ca@actual@s@distance/\forest@ca@desired@s@distance}% \forest@node@foreachchild{% \forestoget{child@anchor}\forest@temp@child@anchor \forest@temp@child@anchor \edef\forest@temp@child@anchor@l{\the\pgf@y}% \pgfmathsetlengthmacro\forest@temp{% \forest@ca@ratio*(% \forestove{l}+\forest@ca@parent@anchor@l-\forest@temp@child@anchor@l) -\forest@ca@parent@anchor@l+\forest@temp@child@anchor@l}% \forestolet{l}\forest@temp }% \forestOget{\forest@ca@first@child}{l}\forest@ca@first@l \pgfmathsetlengthmacro\forest@calign@anchor{% -tan(\forestove{calign primary angle})*(\forest@ca@first@l+\forest@ca@parent@anchor@l-\forest@temp@child@anchor@l)% +\forest@ca@first@child@anchor@s-\forest@ca@parent@anchor@s }% \fi \fi \forest@calign@s@shift{-\forest@calign@anchor}% } % \end{macrocode} % % Get edge: |#1| = |positive|/|negative|, |#2| = grow (in degrees), |#3| = the control % sequence receiving the resulting path. The edge is taken from the % cache (attribute |#1@edge@#2|) if possible; otherwise, both % positive and negative edge are computed and stored in the cache. % \begin{macrocode} \def\forest@node@getedge#1#2#3{% \forestoget{#1@edge@#2}#3% \ifx#3\relax \forest@node@foreachchild{% \forest@node@getedge{#1}{#2}{\forest@temp@edge}% }% \forest@forthis{\forest@node@getedges{#2}}% \forestoget{#1@edge@#2}#3% \fi } % \end{macrocode} % Get edges. |#1| = grow (in degrees). The result is stored in % attributes |negative@edge@#1| and |positive@edge@#1|. This method % expects that the children's edges are already cached. % \begin{macrocode} \def\forest@node@getedges#1{% % \end{macrocode} % Run the computation in a \TeX\ group. % \begin{macrocode} %{% % \end{macrocode} % Setup the grow line. % \begin{macrocode} \forest@setupgrowline{#1}% % \end{macrocode} % Get the edge of the node itself. % \begin{macrocode} \ifnum\forestove{ignore}=0 \forestoget{boundary}\forest@node@boundary \else \def\forest@node@boundary{}% \fi \csname forest@getboth\forestove{fit}edgesofpath\endcsname \forest@node@boundary\forest@negative@node@edge\forest@positive@node@edge \forestolet{negative@edge@#1}\forest@negative@node@edge \forestolet{positive@edge@#1}\forest@positive@node@edge % \end{macrocode} % Add the edges of the children. % \begin{macrocode} \get@edges@merge{negative}{#1}% \get@edges@merge{positive}{#1}% %}% } % \end{macrocode} % Merge the |#1| (=|negative| or |positive|) edge of the node with % |#1| edges of the children. |#2| = grow angle. % \begin{macrocode} \def\get@edges@merge#1#2{% \ifnum\forestove{n children}>0 \forestoget{#1@edge@#2}\forest@node@edge % \end{macrocode} % Remember the node's |parent anchor| and add it to the path (for breaking). % \begin{macrocode} \forestove{parent@anchor}% \edef\forest@getedge@pa@l{\the\pgf@x}% \edef\forest@getedge@pa@s{\the\pgf@y}% \eappto\forest@node@edge{\noexpand\pgfsyssoftpath@movetotoken{\forest@getedge@pa@l}{\forest@getedge@pa@s}}% % \end{macrocode} % Switch to this node's |(l,s)| coordinate system (origin at the % node's anchor). % \begin{macrocode} \pgftransformreset \pgftransformrotate{\forestove{grow}}% % \end{macrocode} % Get the child's (cached) edge, translate it by the child's position, % and add it to the path holding all edges. Also add the edge from parent to the child to the path. % This gets complicated when the child and/or parent anchor is empty, i.e.\ automatic border: we can % get self-intersecting paths. So we store all the parent--child edges to a safe place first, % compute all the possible breaking points (i.e.\ all the points in node@edge path), and break the % parent--child edges on these points. % \begin{macrocode} \def\forest@all@edges{}% \forest@node@foreachchild{% \forestoget{#1@edge@#2}\forest@temp@edge \pgfpointtransformed{\pgfqpoint{\forestove{l}}{\forestove{s}}}% \forest@extendpath\forest@node@edge\forest@temp@edge{}% \ifnum\forestove{ignore edge}=0 \pgfpointadd {\pgfpointtransformed{\pgfqpoint{\forestove{l}}{\forestove{s}}}}% {\forestove{child@anchor}}% \pgfgetlastxy{\forest@getedge@ca@l}{\forest@getedge@ca@s}% \eappto\forest@all@edges{% \noexpand\pgfsyssoftpath@movetotoken{\forest@getedge@pa@l}{\forest@getedge@pa@s}% \noexpand\pgfsyssoftpath@linetotoken{\forest@getedge@ca@l}{\forest@getedge@ca@s}% }% % this deals with potential overlap of the edges: \eappto\forest@node@edge{\noexpand\pgfsyssoftpath@movetotoken{\forest@getedge@ca@l}{\forest@getedge@ca@s}}% \fi }% \ifdefempty{\forest@all@edges}{}{% \pgfintersectionofpaths{\pgfsetpath\forest@all@edges}{\pgfsetpath\forest@node@edge}% \def\forest@edgenode@intersections{}% \forest@merge@intersectionloop \eappto\forest@node@edge{\expandonce{\forest@all@edges}\expandonce{\forest@edgenode@intersections}}% }% % \end{macrocode} % Process the path into an edge and store the edge. % \begin{macrocode} \csname forest@get#1\forestove{fit}edgeofpath\endcsname\forest@node@edge\forest@node@edge \forestolet{#1@edge@#2}\forest@node@edge \fi } \newloop\forest@merge@loop \def\forest@merge@intersectionloop{% \c@pgf@counta=0 \forest@merge@loop \ifnum\c@pgf@counta<\pgfintersectionsolutions\relax \advance\c@pgf@counta1 \pgfpointintersectionsolution{\the\c@pgf@counta}% \eappto\forest@edgenode@intersections{\noexpand\pgfsyssoftpath@movetotoken {\the\pgf@x}{\the\pgf@y}}% \forest@merge@repeat } % \end{macrocode} % % Get the bounding rectangle of the node (without descendants). |#1| = % grow. % \begin{macrocode} \def\forest@node@getboundingrectangle@ls#1{% \forestoget{boundary}\forest@node@boundary \forest@path@getboundingrectangle@ls\forest@node@boundary{#1}% } % \end{macrocode} % % Applies the current coordinate transformation to the points in the % path |#1|. Returns via the current path (so that the coordinate % transformation can be set up as local). % \begin{macrocode} \def\forest@pgfpathtransformed#1{% \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@pgfpathtransformed@moveto \let\pgfsyssoftpath@linetotoken\forest@pgfpathtransformed@lineto \pgfsyssoftpath@setcurrentpath\pgfutil@empty #1% \forest@restore@pgfsyssoftpath@tokendefs } \def\forest@pgfpathtransformed@moveto#1#2{% \forest@pgfpathtransformed@op\pgfsyssoftpath@moveto{#1}{#2}% } \def\forest@pgfpathtransformed@lineto#1#2{% \forest@pgfpathtransformed@op\pgfsyssoftpath@lineto{#1}{#2}% } \def\forest@pgfpathtransformed@op#1#2#3{% \pgfpointtransformed{\pgfqpoint{#2}{#3}}% \edef\forest@temp{% \noexpand#1{\the\pgf@x}{\the\pgf@y}% }% \forest@temp } % \end{macrocode} % % \subsubsection{Tiers} % % Compute tiers to be aligned at a node. The result in saved in % attribute |@tiers|. % \begin{macrocode} \def\forest@pack@computetiers{% {% \forest@pack@tiers@getalltiersinsubtree \forest@pack@tiers@computetierhierarchy \forest@pack@tiers@findcontainers \forest@pack@tiers@raisecontainers \forest@pack@tiers@computeprocessingorder \gdef\forest@smuggle{}% \forest@pack@tiers@write }% \forest@node@foreach{\forestoset{@tiers}{}}% \forest@smuggle } % \end{macrocode} % Puts all tiers contained in the subtree into attribute % |tiers|. % \begin{macrocode} \def\forest@pack@tiers@getalltiersinsubtree{% \ifnum\forestove{n children}>0 \forest@node@foreachchild{\forest@pack@tiers@getalltiersinsubtree}% \fi \forestoget{tier}\forest@temp@mytier \def\forest@temp@mytiers{}% \ifdefempty\forest@temp@mytier{}{% \listeadd\forest@temp@mytiers\forest@temp@mytier }% \ifnum\forestove{n children}>0 \forest@node@foreachchild{% \forestoget{tiers}\forest@temp@tiers \forlistloop\forest@pack@tiers@forhandlerA\forest@temp@tiers }% \fi \forestolet{tiers}\forest@temp@mytiers } \def\forest@pack@tiers@forhandlerA#1{% \ifinlist{#1}\forest@temp@mytiers{}{% \listeadd\forest@temp@mytiers{#1}% }% } % \end{macrocode} % Compute a set of higher and lower tiers for each tier. Tier A is % higher than tier B iff a node on tier A is an ancestor of a % node on tier B. % \begin{macrocode} \def\forest@pack@tiers@computetierhierarchy{% \def\forest@tiers@ancestors{}% \forestoget{tiers}\forest@temp@mytiers \forlistloop\forest@pack@tiers@cth@init\forest@temp@mytiers \forest@pack@tiers@computetierhierarchy@ } \def\forest@pack@tiers@cth@init#1{% \csdef{forest@tiers@higher@#1}{}% \csdef{forest@tiers@lower@#1}{}% } \def\forest@pack@tiers@computetierhierarchy@{% \forestoget{tier}\forest@temp@mytier \ifdefempty\forest@temp@mytier{}{% \forlistloop\forest@pack@tiers@forhandlerB\forest@tiers@ancestors \listeadd\forest@tiers@ancestors\forest@temp@mytier }% \forest@node@foreachchild{% \forest@pack@tiers@computetierhierarchy@ }% \forestoget{tier}\forest@temp@mytier \ifdefempty\forest@temp@mytier{}{% \forest@listedel\forest@tiers@ancestors\forest@temp@mytier }% } \def\forest@pack@tiers@forhandlerB#1{% \def\forest@temp@tier{#1}% \ifx\forest@temp@tier\forest@temp@mytier \PackageError{forest}{Circular tier hierarchy (tier \forest@temp@mytier)}{}% \fi \ifinlistcs{#1}{forest@tiers@higher@\forest@temp@mytier}{}{% \listcsadd{forest@tiers@higher@\forest@temp@mytier}{#1}}% \xifinlistcs\forest@temp@mytier{forest@tiers@lower@#1}{}{% \listcseadd{forest@tiers@lower@#1}{\forest@temp@mytier}}% } \def\forest@pack@tiers@findcontainers{% \forestoget{tiers}\forest@temp@tiers \forlistloop\forest@pack@tiers@findcontainer\forest@temp@tiers } \def\forest@pack@tiers@findcontainer#1{% \def\forest@temp@tier{#1}% \forestoget{tier}\forest@temp@mytier \ifx\forest@temp@tier\forest@temp@mytier \csedef{forest@tiers@container@#1}{\forest@cn}% \else\@escapeif{% \forest@pack@tiers@findcontainerA{#1}% }\fi% } \def\forest@pack@tiers@findcontainerA#1{% \c@pgf@counta=0 \forest@node@foreachchild{% \forestoget{tiers}\forest@temp@tiers \ifinlist{#1}\forest@temp@tiers{% \advance\c@pgf@counta 1 \let\forest@temp@child\forest@cn }{}% }% \ifnum\c@pgf@counta>1 \csedef{forest@tiers@container@#1}{\forest@cn}% \else\@escapeif{% surely =1 \forest@fornode{\forest@temp@child}{% \forest@pack@tiers@findcontainer{#1}% }% }\fi } \def\forest@pack@tiers@raisecontainers{% \forestoget{tiers}\forest@temp@mytiers \forlistloop\forest@pack@tiers@rc@forhandlerA\forest@temp@mytiers } \def\forest@pack@tiers@rc@forhandlerA#1{% \edef\forest@tiers@temptier{#1}% \letcs\forest@tiers@containernodeoftier{forest@tiers@container@#1}% \letcs\forest@temp@lowertiers{forest@tiers@lower@#1}% \forlistloop\forest@pack@tiers@rc@forhandlerB\forest@temp@lowertiers } \def\forest@pack@tiers@rc@forhandlerB#1{% \letcs\forest@tiers@containernodeoflowertier{forest@tiers@container@#1}% \forestOget{\forest@tiers@containernodeoflowertier}{content}\lowercontent \forestOget{\forest@tiers@containernodeoftier}{content}\uppercontent \forest@fornode{\forest@tiers@containernodeoflowertier}{% \forest@ifancestorof {\forest@tiers@containernodeoftier} {\csletcs{forest@tiers@container@\forest@tiers@temptier}{forest@tiers@container@#1}}% {}% }% } \def\forest@pack@tiers@computeprocessingorder{% \def\forest@tiers@processingorder{}% \forestoget{tiers}\forest@tiers@cpo@tierstodo \forest@loopa \ifdefempty\forest@tiers@cpo@tierstodo{\forest@tempfalse}{\forest@temptrue}% \ifforest@temp \def\forest@tiers@cpo@tiersremaining{}% \def\forest@tiers@cpo@tiersindependent{}% \forlistloop\forest@pack@tiers@cpo@forhandlerA\forest@tiers@cpo@tierstodo \ifdefempty\forest@tiers@cpo@tiersindependent{% \PackageError{forest}{Circular tiers!}{}}{}% \forlistloop\forest@pack@tiers@cpo@forhandlerB\forest@tiers@cpo@tiersremaining \let\forest@tiers@cpo@tierstodo\forest@tiers@cpo@tiersremaining \forest@repeata } \def\forest@pack@tiers@cpo@forhandlerA#1{% \ifcsempty{forest@tiers@higher@#1}{% \listadd\forest@tiers@cpo@tiersindependent{#1}% \listadd\forest@tiers@processingorder{#1}% }{% \listadd\forest@tiers@cpo@tiersremaining{#1}% }% } \def\forest@pack@tiers@cpo@forhandlerB#1{% \def\forest@pack@tiers@cpo@aremainingtier{#1}% \forlistloop\forest@pack@tiers@cpo@forhandlerC\forest@tiers@cpo@tiersindependent } \def\forest@pack@tiers@cpo@forhandlerC#1{% \ifinlistcs{#1}{forest@tiers@higher@\forest@pack@tiers@cpo@aremainingtier}{% \forest@listcsdel{forest@tiers@higher@\forest@pack@tiers@cpo@aremainingtier}{#1}% }{}% } \def\forest@pack@tiers@write{% \forlistloop\forest@pack@tiers@write@forhandler\forest@tiers@processingorder } \def\forest@pack@tiers@write@forhandler#1{% \forest@fornode{\csname forest@tiers@container@#1\endcsname}{% \forest@pack@tiers@check{#1}% }% \xappto\forest@smuggle{% \noexpand\listadd \forestOm{\csname forest@tiers@container@#1\endcsname}{@tiers}% {#1}% }% } % checks if the tier is compatible with growth changes and calign=node/edge angle \def\forest@pack@tiers@check#1{% \def\forest@temp@currenttier{#1}% \forest@node@foreachdescendant{% \ifnum\forestove{grow}=\forestOve{\forestove{@parent}}{grow} \else \forest@pack@tiers@check@grow \fi \ifnum\forestove{n children}>1 \forestoget{calign}\forest@temp \ifx\forest@temp\forest@pack@tiers@check@nodeangle \forest@pack@tiers@check@calign \fi \ifx\forest@temp\forest@pack@tiers@check@edgeangle \forest@pack@tiers@check@calign \fi \fi }% } \def\forest@pack@tiers@check@nodeangle{node angle}% \def\forest@pack@tiers@check@edgeangle{edge angle}% \def\forest@pack@tiers@check@grow{% \forestoget{content}\forest@temp@content \let\forest@temp@currentnode\forest@cn \forest@node@foreachdescendant{% \forestoget{tier}\forest@temp \ifx\forest@temp@currenttier\forest@temp \forest@pack@tiers@check@grow@error \fi }% } \def\forest@pack@tiers@check@grow@error{% \PackageError{forest}{Tree growth direction changes in node \forest@temp@currentnode\space (content: \forest@temp@content), while tier '\forest@temp' is specified for nodes both out- and inside the subtree rooted in node \forest@temp@currentnode. This will not work.}{}% } \def\forest@pack@tiers@check@calign{% \forest@node@foreachchild{% \forestoget{tier}\forest@temp \ifx\forest@temp@currenttier\forest@temp \forest@pack@tiers@check@calign@warning \fi }% } \def\forest@pack@tiers@check@calign@warning{% \PackageWarning{forest}{Potential option conflict: node \forestove{@parent} (content: '\forestOve{\forestove{@parent}}{content}') was given 'calign=\forestove{calign}', while its child \forest@cn\space (content: '\forestove{content}') was given 'tier=\forestove{tier}'. The parent's 'calign' will only work if the child was the lowest node on its tier before the alignment.}{} } % \end{macrocode} % % % \subsubsection{Node boundary} % % Compute the node boundary: it will be put in the pgf's current path. The computation is done % within a generic anchor so that the shape's saved anchors and macros are available. % \begin{macrocode} \pgfdeclaregenericanchor{forestcomputenodeboundary}{% \letcs\forest@temp@boundary@macro{forest@compute@node@boundary@#1}% \ifcsname forest@compute@node@boundary@#1\endcsname \csname forest@compute@node@boundary@#1\endcsname \else \forest@compute@node@boundary@rectangle \fi \pgfsyssoftpath@getcurrentpath\forest@temp \global\let\forest@global@boundary\forest@temp } \def\forest@mt#1{% \expandafter\pgfpointanchor\expandafter{\pgfreferencednodename}{#1}% \pgfsyssoftpath@moveto{\the\pgf@x}{\the\pgf@y}% }% \def\forest@lt#1{% \expandafter\pgfpointanchor\expandafter{\pgfreferencednodename}{#1}% \pgfsyssoftpath@lineto{\the\pgf@x}{\the\pgf@y}% }% \def\forest@compute@node@boundary@coordinate{% \forest@mt{center}% } \def\forest@compute@node@boundary@circle{% \forest@mt{east}% \forest@lt{north east}% \forest@lt{north}% \forest@lt{north west}% \forest@lt{west}% \forest@lt{south west}% \forest@lt{south}% \forest@lt{south east}% \forest@lt{east}% } \def\forest@compute@node@boundary@rectangle{% \forest@mt{south west}% \forest@lt{south east}% \forest@lt{north east}% \forest@lt{north west}% \forest@lt{south west}% } \def\forest@compute@node@boundary@diamond{% \forest@mt{east}% \forest@lt{north}% \forest@lt{west}% \forest@lt{south}% \forest@lt{east}% } \let\forest@compute@node@boundary@ellipse\forest@compute@node@boundary@circle \def\forest@compute@node@boundary@trapezium{% \forest@mt{top right corner}% \forest@lt{top left corner}% \forest@lt{bottom left corner}% \forest@lt{bottom right corner}% \forest@lt{top right corner}% } \def\forest@compute@node@boundary@semicircle{% \forest@mt{arc start}% \forest@lt{north}% \forest@lt{east}% \forest@lt{north east}% \forest@lt{apex}% \forest@lt{north west}% \forest@lt{west}% \forest@lt{arc end}% \forest@lt{arc start}% } \newloop\forest@computenodeboundary@loop \csdef{forest@compute@node@boundary@regular polygon}{% \forest@mt{corner 1}% \c@pgf@counta=\sides\relax \forest@computenodeboundary@loop \ifnum\c@pgf@counta>0 \forest@lt{corner \the\c@pgf@counta}% \advance\c@pgf@counta-1 \forest@computenodeboundary@repeat }% \def\forest@compute@node@boundary@star{% \forest@mt{outer point 1}% \c@pgf@counta=\totalstarpoints\relax \divide\c@pgf@counta2 \forest@computenodeboundary@loop \ifnum\c@pgf@counta>0 \forest@lt{inner point \the\c@pgf@counta}% \forest@lt{outer point \the\c@pgf@counta}% \advance\c@pgf@counta-1 \forest@computenodeboundary@repeat }% \csdef{forest@compute@node@boundary@isosceles triangle}{% \forest@mt{apex}% \forest@lt{left corner}% \forest@lt{right corner}% \forest@lt{apex}% } \def\forest@compute@node@boundary@kite{% \forest@mt{upper vertex}% \forest@lt{left vertex}% \forest@lt{lower vertex}% \forest@lt{right vertex}% \forest@lt{upper vertex}% } \def\forest@compute@node@boundary@dart{% \forest@mt{tip}% \forest@lt{left tail}% \forest@lt{tail center}% \forest@lt{right tail}% \forest@lt{tip}% } \csdef{forest@compute@node@boundary@circular sector}{% \forest@mt{sector center}% \forest@lt{arc start}% \forest@lt{arc center}% \forest@lt{arc end}% \forest@lt{sector center}% } \def\forest@compute@node@boundary@cylinder{% \forest@mt{top}% \forest@lt{after top}% \forest@lt{before bottom}% \forest@lt{bottom}% \forest@lt{after bottom}% \forest@lt{before top}% \forest@lt{top}% } \cslet{forest@compute@node@boundary@forbidden sign}\forest@compute@node@boundary@circle \cslet{forest@compute@node@boundary@magnifying glass}\forest@compute@node@boundary@circle \def\forest@compute@node@boundary@cloud{% \getradii \forest@mt{puff 1}% \c@pgf@counta=\puffs\relax \forest@computenodeboundary@loop \ifnum\c@pgf@counta>0 \forest@lt{puff \the\c@pgf@counta}% \advance\c@pgf@counta-1 \forest@computenodeboundary@repeat } \def\forest@compute@node@boundary@starburst{ \calculatestarburstpoints \forest@mt{outer point 1}% \c@pgf@counta=\totalpoints\relax \divide\c@pgf@counta2 \forest@computenodeboundary@loop \ifnum\c@pgf@counta>0 \forest@lt{inner point \the\c@pgf@counta}% \forest@lt{outer point \the\c@pgf@counta}% \advance\c@pgf@counta-1 \forest@computenodeboundary@repeat }% \def\forest@compute@node@boundary@signal{% \forest@mt{east}% \forest@lt{south east}% \forest@lt{south west}% \forest@lt{west}% \forest@lt{north west}% \forest@lt{north east}% \forest@lt{east}% } \def\forest@compute@node@boundary@tape{% \forest@mt{north east}% \forest@lt{60}% \forest@lt{north}% \forest@lt{120}% \forest@lt{north west}% \forest@lt{south west}% \forest@lt{240}% \forest@lt{south}% \forest@lt{310}% \forest@lt{south east}% \forest@lt{north east}% } \csdef{forest@compute@node@boundary@single arrow}{% \forest@mt{tip}% \forest@lt{after tip}% \forest@lt{after head}% \forest@lt{before tail}% \forest@lt{after tail}% \forest@lt{before head}% \forest@lt{before tip}% \forest@lt{tip}% } \csdef{forest@compute@node@boundary@double arrow}{% \forest@mt{tip 1}% \forest@lt{after tip 1}% \forest@lt{after head 1}% \forest@lt{before head 2}% \forest@lt{before tip 2}% \forest@mt{tip 2}% \forest@lt{after tip 2}% \forest@lt{after head 2}% \forest@lt{before head 1}% \forest@lt{before tip 1}% \forest@lt{tip 1}% } \csdef{forest@compute@node@boundary@arrow box}{% \forest@mt{before north arrow}% \forest@lt{before north arrow head}% \forest@lt{before north arrow tip}% \forest@lt{north arrow tip}% \forest@lt{after north arrow tip}% \forest@lt{after north arrow head}% \forest@lt{after north arrow}% \forest@lt{north east}% \forest@lt{before east arrow}% \forest@lt{before east arrow head}% \forest@lt{before east arrow tip}% \forest@lt{east arrow tip}% \forest@lt{after east arrow tip}% \forest@lt{after east arrow head}% \forest@lt{after east arrow}% \forest@lt{south east}% \forest@lt{before south arrow}% \forest@lt{before south arrow head}% \forest@lt{before south arrow tip}% \forest@lt{south arrow tip}% \forest@lt{after south arrow tip}% \forest@lt{after south arrow head}% \forest@lt{after south arrow}% \forest@lt{south west}% \forest@lt{before west arrow}% \forest@lt{before west arrow head}% \forest@lt{before west arrow tip}% \forest@lt{west arrow tip}% \forest@lt{after west arrow tip}% \forest@lt{after west arrow head}% \forest@lt{after west arrow}% \forest@lt{north west}% \forest@lt{before north arrow}% } \cslet{forest@compute@node@boundary@circle split}\forest@compute@node@boundary@circle \cslet{forest@compute@node@boundary@circle solidus}\forest@compute@node@boundary@circle \cslet{forest@compute@node@boundary@ellipse split}\forest@compute@node@boundary@ellipse \cslet{forest@compute@node@boundary@rectangle split}\forest@compute@node@boundary@rectangle \def\forest@compute@node@boundary@@callout{% \beforecalloutpointer \pgfsyssoftpath@moveto{\the\pgf@x}{\the\pgf@y}% \calloutpointeranchor \pgfsyssoftpath@lineto{\the\pgf@x}{\the\pgf@y}% \aftercalloutpointer \pgfsyssoftpath@lineto{\the\pgf@x}{\the\pgf@y}% } \csdef{forest@compute@node@boundary@rectangle callout}{% \forest@compute@node@boundary@rectangle \rectanglecalloutpoints \forest@compute@node@boundary@@callout } \csdef{forest@compute@node@boundary@ellipse callout}{% \forest@compute@node@boundary@ellipse \ellipsecalloutpoints \forest@compute@node@boundary@@callout } \csdef{forest@compute@node@boundary@cloud callout}{% \forest@compute@node@boundary@cloud % at least a first approx... \forest@mt{center}% \forest@lt{pointer}% }% \csdef{forest@compute@node@boundary@cross out}{% \forest@mt{south east}% \forest@lt{north west}% \forest@mt{south west}% \forest@lt{north east}% }% \csdef{forest@compute@node@boundary@strike out}{% \forest@mt{north east}% \forest@lt{south west}% }% \csdef{forest@compute@node@boundary@rounded rectangle}{% \forest@mt{east}% \forest@lt{north east}% \forest@lt{north}% \forest@lt{north west}% \forest@lt{west}% \forest@lt{south west}% \forest@lt{south}% \forest@lt{south east}% \forest@lt{east}% }% \csdef{forest@compute@node@boundary@chamfered rectangle}{% \forest@mt{before south west}% \forest@mt{after south west}% \forest@lt{before south east}% \forest@lt{after south east}% \forest@lt{before north east}% \forest@lt{after north east}% \forest@lt{before north west}% \forest@lt{after north west}% \forest@lt{before south west}% }% % \end{macrocode} % % % % % \subsection{Compute absolute positions} % % Computes absolute positions of descendants relative to this node. % Stores the results in attributes |x| and |y|. % \begin{macrocode} \def\forest@node@computeabsolutepositions{% \forestoset{x}{0pt}% \forestoset{y}{0pt}% \edef\forest@marshal{% \noexpand\forest@node@foreachchild{% \noexpand\forest@node@computeabsolutepositions@{0pt}{0pt}{\forestove{grow}}% }% }\forest@marshal } \def\forest@node@computeabsolutepositions@#1#2#3{% \pgfpointadd{\pgfpoint{#1}{#2}}{% \pgfpointadd{\pgfpolar{#3}{\forestove{l}}}{\pgfpolar{90 + #3}{\forestove{s}}}}% \pgfgetlastxy\forest@temp@x\forest@temp@y \forestolet{x}\forest@temp@x \forestolet{y}\forest@temp@y \edef\forest@marshal{% \noexpand\forest@node@foreachchild{% \noexpand\forest@node@computeabsolutepositions@{\forest@temp@x}{\forest@temp@y}{\forestove{grow}}% }% }\forest@marshal } % \end{macrocode} % % % \subsection{Drawing the tree} % \label{imp:drawing-the-tree} % \begin{macrocode} \newif\ifforest@drawtree@preservenodeboxes@ \def\forest@node@drawtree{% \expandafter\ifstrequal\expandafter{\forest@drawtreebox}{\pgfkeysnovalue}{% \let\forest@drawtree@beginbox\relax \let\forest@drawtree@endbox\relax }{% \edef\forest@drawtree@beginbox{\global\setbox\forest@drawtreebox=\hbox\bgroup}% \let\forest@drawtree@endbox\egroup }% \ifforest@external@ \ifforest@externalize@tree@ \forest@temptrue \else \tikzifexternalizing{% \ifforest@was@tikzexternalwasenable \forest@temptrue \pgfkeys{/tikz/external/optimize=false}% \let\forest@drawtree@beginbox\relax \let\forest@drawtree@endbox\relax \else \forest@tempfalse \fi }{% \forest@tempfalse }% \fi \ifforest@temp \advance\forest@externalize@inner@n 1 \edef\forest@externalize@filename{% \tikzexternalrealjob-forest-\forest@externalize@outer@n \ifnum\forest@externalize@inner@n=0 \else.\the\forest@externalize@inner@n\fi}% \expandafter\tikzsetnextfilename\expandafter{\forest@externalize@filename}% \tikzexternalenable \pgfkeysalso{/tikz/external/remake next,/tikz/external/export next}% \fi \ifforest@externalize@tree@ \typeout{forest: Invoking a recursive call to generate the external picture '\forest@externalize@filename' for the following context+code: '\expandafter\detokenize\expandafter{\forest@externalize@id}'}% \fi \fi % \ifforesttikzcshack \let\forest@original@tikz@parse@node\tikz@parse@node \let\tikz@parse@node\forest@tikz@parse@node \fi \pgfkeysgetvalue{/forest/begin draw/.@cmd}\forest@temp@begindraw \pgfkeysgetvalue{/forest/end draw/.@cmd}\forest@temp@enddraw \edef\forest@marshal{% \noexpand\forest@drawtree@beginbox \expandonce{\forest@temp@begindraw\pgfkeysnovalue\pgfeov}% \noexpand\forest@node@drawtree@ \expandonce{\forest@temp@enddraw\pgfkeysnovalue\pgfeov}% \noexpand\forest@drawtree@endbox }\forest@marshal \ifforesttikzcshack \let\tikz@parse@node\forest@original@tikz@parse@node \fi % \ifforest@external@ \ifforest@externalize@tree@ \tikzexternaldisable \eappto\forest@externalize@checkimages{% \noexpand\forest@includeexternal@check{\forest@externalize@filename}% }% \expandafter\ifstrequal\expandafter{\forest@drawtreebox}{\pgfkeysnovalue}{% \eappto\forest@externalize@loadimages{% \noexpand\forest@includeexternal{\forest@externalize@filename}% }% }{% \eappto\forest@externalize@loadimages{% \noexpand\forest@includeexternal@box\forest@drawtreebox{\forest@externalize@filename}% }% }% \fi \fi } \def\forest@node@drawtree@{% \forest@node@foreach{\forest@draw@node}% \forest@node@Ifnamedefined{forest@baseline@node}{% \edef\forest@temp{% \noexpand\pgfsetbaselinepointlater{% \noexpand\pgfpointanchor {\forestOve{\forest@node@Nametoid{forest@baseline@node}}{name}} {\forestOve{\forest@node@Nametoid{forest@baseline@node}}{anchor}} }% }\forest@temp }{}% \forest@node@foreachdescendant{\forest@draw@edge}% \forest@node@foreach{\forest@draw@tikz}% } \def\forest@draw@node{% \ifnum\forestove{phantom}=0 \forest@node@forest@positionnodelater@restore \ifforest@drawtree@preservenodeboxes@ \pgfnodealias{forest@temp}{\forestove{later@name}}% \fi \pgfpositionnodenow{\pgfqpoint{\forestove{x}}{\forestove{y}}}% \ifforest@drawtree@preservenodeboxes@ \pgfnodealias{\forestove{later@name}}{forest@temp}% \fi \fi } \def\forest@draw@edge{% \ifnum\forestove{phantom}=0 \ifnum\forestOve{\forestove{@parent}}{phantom}=0 \edef\forest@temp{\forestove{edge path}}% \forest@temp \fi \fi } \def\forest@draw@tikz{% \forestove{tikz}% } % \end{macrocode} % A hack into \TikZ;'s coordinate parser: implements relative node names! % \begin{macrocode} \def\forest@tikz@parse@node#1(#2){% \pgfutil@in@.{#2}% \ifpgfutil@in@ \expandafter\forest@tikz@parse@node@checkiftikzname@withdot \else% \expandafter\forest@tikz@parse@node@checkiftikzname@withoutdot \fi% #1(#2)\forest@end } \def\forest@tikz@parse@node@checkiftikzname@withdot#1(#2.#3)\forest@end{% \forest@tikz@parse@node@checkiftikzname#1{#2}{.#3}} \def\forest@tikz@parse@node@checkiftikzname@withoutdot#1(#2)\forest@end{% \forest@tikz@parse@node@checkiftikzname#1{#2}{}} \def\forest@tikz@parse@node@checkiftikzname#1#2#3{% \expandafter\ifx\csname pgf@sh@ns@#2\endcsname\relax \forest@forthis{% \forest@nameandgo{#2}% \edef\forest@temp@relativenodename{\forestove{name}}% }% \else \def\forest@temp@relativenodename{#2}% \fi \expandafter\forest@original@tikz@parse@node\expandafter#1\expandafter(\forest@temp@relativenodename#3)% } \def\forest@nameandgo#1{% \pgfutil@in@!{#1}% \ifpgfutil@in@ \forest@nameandgo@(#1)% \else \ifstrempty{#1}{}{\edef\forest@cn{\forest@node@Nametoid{#1}}}% \fi } \def\forest@nameandgo@(#1!#2){% \ifstrempty{#1}{}{\edef\forest@cn{\forest@node@Nametoid{#1}}}% \forest@go{#2}% } % \end{macrocode} % |parent/child anchor| are generic anchors which forward to the real one. There's a hack in there % to deal with link pointing to the ``border'' anchor. % \begin{macrocode} \pgfdeclaregenericanchor{parent anchor}{% \forest@generic@parent@child@anchor{parent }{#1}} \pgfdeclaregenericanchor{child anchor}{% \forest@generic@parent@child@anchor{child }{#1}} \pgfdeclaregenericanchor{anchor}{% \forest@generic@parent@child@anchor{}{#1}} \def\forest@generic@parent@child@anchor#1#2{% \forestOget{\forest@node@Nametoid{\pgfreferencednodename}}{#1anchor}\forest@temp@parent@anchor \ifdefempty\forest@temp@parent@anchor{% \pgf@sh@reanchor{#2}{center}% \xdef\forest@hack@tikzshapeborder{% \noexpand\tikz@shapebordertrue \def\noexpand\tikz@shapeborder@name{\pgfreferencednodename}% }\aftergroup\forest@hack@tikzshapeborder }{% \pgf@sh@reanchor{#2}{\forest@temp@parent@anchor}% }% } % \end{macrocode} % % % \section{Geometry} % \label{imp:geometry} % % A \emph{$\alpha$ grow line} is a line through the origin at angle % $\alpha$. The following macro sets up the grow line, which can then % be used by other code (the change is local to the \TeX\ group). More % precisely, two normalized vectors are set up: one $(x_g,y_g)$ on the % grow line, and one $(x_s,y_s)$ orthogonal to it---to get % $(x_s,y_s$), rotate $(x_g,y_g)$ 90$^\circ$ counter-clockwise. % \begin{macrocode} \newdimen\forest@xg \newdimen\forest@yg \newdimen\forest@xs \newdimen\forest@ys \def\forest@setupgrowline#1{% \edef\forest@grow{#1}% \pgfpointpolar\forest@grow{1pt}% \forest@xg=\pgf@x \forest@yg=\pgf@y \forest@xs=-\pgf@y \forest@ys=\pgf@x } % \end{macrocode} % % \subsection{Projections} % \label{imp:projections} % % The following macro belongs to the |\pgfpoint...| family: it % projects point |#1| on the grow line. (The result is returned via % |\pgf@x| and |\pgf@y|.) The implementation is based on code from % |tikzlibrarycalc|, but optimized for projecting on grow lines, and % split to optimize serial usage in |\forest@projectpath|. % \begin{macrocode} \def\forest@pgfpointprojectiontogrowline#1{{% \pgf@process{#1}% % \end{macrocode} % Calculate the scalar product of $(x,y)$ and $(x_g,y_g)$: that's the % distance of $(x,y)$ to the grow line. % \begin{macrocode} \pgfutil@tempdima=\pgf@sys@tonumber{\pgf@x}\forest@xg% \advance\pgfutil@tempdima by\pgf@sys@tonumber{\pgf@y}\forest@yg% % \end{macrocode} % The projection is $(x_g,y_g)$ scaled by the distance. % \begin{macrocode} \global\pgf@x=\pgf@sys@tonumber{\pgfutil@tempdima}\forest@xg% \global\pgf@y=\pgf@sys@tonumber{\pgfutil@tempdima}\forest@yg% }} % \end{macrocode} % % The following macro calculates the distance of point |#2| to the % grow line and stores the result in \TeX-dimension |#1|. The distance % is the scalar product of the point vector and the normalized vector % orthogonal to the grow line. % \begin{macrocode} \def\forest@distancetogrowline#1#2{% \pgf@process{#2}% #1=\pgf@sys@tonumber{\pgf@x}\forest@xs\relax \advance#1 by\pgf@sys@tonumber{\pgf@y}\forest@ys\relax } % \end{macrocode} % Note that the distance to the grow line is positive for points on % one of its sides and negative for points on the other side. (It is % positive on the side which $(x_s,y_s)$ points to.) We thus say that % the grow line partitions the plane into a \emph{positive} and a % \emph{negative} side. % % The following macro projects all segment edges (``points'') of a % simple\footnote{A path is \emph{simple} if it consists of only % move-to and line-to operations.} path |#1| onto the grow line. % The result is an array of tuples (|xo|, |yo|, |xp|, |yp|), where % |xo| and |yo| stand for the \emph{o}riginal point, and |xp| and |yp| % stand for its \emph{p}rojection. The prefix of the array is given by % |#2|. If the array already exists, the new items are appended to % it. The array is not sorted: the order of original points in the % array is their order in the path. The computation does not destroy % the current path. All result-macros have local scope. % % The macro is just a wrapper for |\forest@projectpath@process|. % \begin{macrocode} \let\forest@pp@n\relax \def\forest@projectpathtogrowline#1#2{% \edef\forest@pp@prefix{#2}% \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@projectpath@processpoint \let\pgfsyssoftpath@linetotoken\forest@projectpath@processpoint \c@pgf@counta=0 #1% \csedef{#2n}{\the\c@pgf@counta}% \forest@restore@pgfsyssoftpath@tokendefs } % \end{macrocode} % For each point, remember the point and its projection to grow line. % \begin{macrocode} \def\forest@projectpath@processpoint#1#2{% \pgfqpoint{#1}{#2}% \expandafter\edef\csname\forest@pp@prefix\the\c@pgf@counta xo\endcsname{\the\pgf@x}% \expandafter\edef\csname\forest@pp@prefix\the\c@pgf@counta yo\endcsname{\the\pgf@y}% \forest@pgfpointprojectiontogrowline{}% \expandafter\edef\csname\forest@pp@prefix\the\c@pgf@counta xp\endcsname{\the\pgf@x}% \expandafter\edef\csname\forest@pp@prefix\the\c@pgf@counta yp\endcsname{\the\pgf@y}% \advance\c@pgf@counta 1\relax } % \end{macrocode} % Sort the array (prefix |#1|) produced by % |\forest@projectpathtogrowline| by |(xp,yp)|, in the ascending order. % \begin{macrocode} \def\forest@sortprojections#1{% % todo: optimize in cases when we know that the array is actually a % merger of sorted arrays; when does this happen? in % distance_between_paths, and when merging the edges of the parent % and its children in a uniform growth tree \edef\forest@ppi@inputprefix{#1}% \c@pgf@counta=\csname#1n\endcsname\relax \advance\c@pgf@counta -1 \forest@sort\forest@ppiraw@cmp\forest@ppiraw@let\forest@sort@ascending{0}{\the\c@pgf@counta}% } % \end{macrocode} % % The following macro processes the data gathered by (possibly more % than one invocation of) |\forest@projectpathtogrowline| into array % with prefix |#1|. The resulting data is the following. % \begin{itemize} % \item Array of projections (prefix |#2|) % \begin{itemize} % \item its items are tuples |(x,y)| (the array is sorted by |x| % and |y|), and % \item an inner array of original points (prefix |#2N@|, where $N$ % is the index of the item in array |#2|. The items of |#2N@| % are |x|, |y| and |d|: |x| and |y| are the coordinates of the % original point; |d| is its distance to the grow line. The inner % array is not sorted. % \end{itemize} % \item A dictionary |#2|: keys are the coordinates |(x,y)| of % the original points; a value is the index of the original point's % projection in array |#2|.\footnote{At first sight, this % information could be cached ``at the source'': by % forest@pgfpointprojectiontogrowline. However, due to imprecise % intersecting (in breakpath), we cheat and merge very adjacent % projection points, expecting that the points to project to the % merged projection point. All this depends on the given path, so a % generic cache is not feasible.} % \end{itemize} % \begin{macrocode} \def\forest@processprojectioninfo#1#2{% \edef\forest@ppi@inputprefix{#1}% % \end{macrocode} % Loop (counter |\c@pgf@counta|) through the sorted array of raw data. % \begin{macrocode} \c@pgf@counta=0 \c@pgf@countb=-1 \loop \ifnum\c@pgf@counta<\csname#1n\endcsname\relax % \end{macrocode} % Check if the projection tuple in the current raw item equals the % current projection. % \begin{macrocode} \letcs\forest@xo{#1\the\c@pgf@counta xo}% \letcs\forest@yo{#1\the\c@pgf@counta yo}% \letcs\forest@xp{#1\the\c@pgf@counta xp}% \letcs\forest@yp{#1\the\c@pgf@counta yp}% \ifnum\c@pgf@countb<0 \forest@equaltotolerancefalse \else \forest@equaltotolerance {\pgfqpoint\forest@xp\forest@yp}% {\pgfqpoint {\csname#2\the\c@pgf@countb x\endcsname}% {\csname#2\the\c@pgf@countb y\endcsname}% }% \fi \ifforest@equaltotolerance\else % \end{macrocode} % It not, we will append a new item to the outer result array. % \begin{macrocode} \advance\c@pgf@countb 1 \cslet{#2\the\c@pgf@countb x}\forest@xp \cslet{#2\the\c@pgf@countb y}\forest@yp \csdef{#2\the\c@pgf@countb @n}{0}% \fi % \end{macrocode} % If the projection is actually a projection of one a point in our path: % \begin{macrocode} % todo: this is ugly! \ifdefined\forest@xo\ifx\forest@xo\relax\else \ifdefined\forest@yo\ifx\forest@yo\relax\else % \end{macrocode} % Append the point of the current raw item to the inner array of % points projecting to the current projection. % \begin{macrocode} \forest@append@point@to@inner@array \forest@xo\forest@yo {#2\the\c@pgf@countb @}% % \end{macrocode} % Put a new item in the dictionary: key = the original point, value = % the projection index. % \begin{macrocode} \csedef{#2(\forest@xo,\forest@yo)}{\the\c@pgf@countb}% \fi\fi \fi\fi % \end{macrocode} % Clean-up the raw array item. % \begin{macrocode} \cslet{#1\the\c@pgf@counta xo}\relax \cslet{#1\the\c@pgf@counta yo}\relax \cslet{#1\the\c@pgf@counta xp}\relax \cslet{#1\the\c@pgf@counta yp}\relax \advance\c@pgf@counta 1 \repeat % \end{macrocode} % Clean up the raw array length. % \begin{macrocode} \cslet{#1n}\relax % \end{macrocode} % Store the length of the outer result array. % \begin{macrocode} \advance\c@pgf@countb 1 \csedef{#2n}{\the\c@pgf@countb}% } % \end{macrocode} % % Item-exchange macro for quicksorting the raw projection data. (|#1| % is copied into |#2|.) % \begin{macrocode} \def\forest@ppiraw@let#1#2{% \csletcs{\forest@ppi@inputprefix#1xo}{\forest@ppi@inputprefix#2xo}% \csletcs{\forest@ppi@inputprefix#1yo}{\forest@ppi@inputprefix#2yo}% \csletcs{\forest@ppi@inputprefix#1xp}{\forest@ppi@inputprefix#2xp}% \csletcs{\forest@ppi@inputprefix#1yp}{\forest@ppi@inputprefix#2yp}% } % \end{macrocode} % Item comparision macro for quicksorting the raw projection data. % \begin{macrocode} \def\forest@ppiraw@cmp#1#2{% \forest@sort@cmptwodimcs {\forest@ppi@inputprefix#1xp}{\forest@ppi@inputprefix#1yp}% {\forest@ppi@inputprefix#2xp}{\forest@ppi@inputprefix#2yp}% } % \end{macrocode} % % Append the point |(#1,#2)| to the (inner) array of points % (prefix |#3|). % \begin{macrocode} \def\forest@append@point@to@inner@array#1#2#3{% \c@pgf@countc=\csname#3n\endcsname\relax \csedef{#3\the\c@pgf@countc x}{#1}% \csedef{#3\the\c@pgf@countc y}{#2}% \forest@distancetogrowline\pgfutil@tempdima{\pgfqpoint#1#2}% \csedef{#3\the\c@pgf@countc d}{\the\pgfutil@tempdima}% \advance\c@pgf@countc 1 \csedef{#3n}{\the\c@pgf@countc}% } % \end{macrocode} % % \subsection{Break path} % % The following macro computes from the given path (|#1|) a ``broken'' % path (|#3|) that contains the same points of the plane, but has % potentially more segments, so that, for every point from a given set % of points on the grow line, a line through this point perpendicular % to the grow line intersects the broken path only at its edge % segments (i.e.\ not between them). % % The macro works only for \emph{simple} paths, i.e.\ paths built % using only move-to and line-to operations. Furthermore, % |\forest@processprojectioninfo| must be called before calling % |\forest@breakpath|: we expect information with prefix |#2|. The % macro updates the information compiled by % |\forest@processprojectioninfo| with information about points added % by path-breaking. % \begin{macrocode} \def\forest@breakpath#1#2#3{% % \end{macrocode} % Store the current path in a macro and empty it, then process the % stored path. The processing creates a new current path. % \begin{macrocode} \edef\forest@bp@prefix{#2}% \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@breakpath@processfirstpoint \let\pgfsyssoftpath@linetotoken\forest@breakpath@processfirstpoint %\pgfusepath{}% empty the current path. ok? #1% \forest@restore@pgfsyssoftpath@tokendefs \pgfsyssoftpath@getcurrentpath#3% } % \end{macrocode} % The original and the broken path start in the same way. (This code % implicitely ``repairs'' a path that starts illegally, with a line-to % operation.) % \begin{macrocode} \def\forest@breakpath@processfirstpoint#1#2{% \forest@breakpath@processmoveto{#1}{#2}% \let\pgfsyssoftpath@movetotoken\forest@breakpath@processmoveto \let\pgfsyssoftpath@linetotoken\forest@breakpath@processlineto } % \end{macrocode} % When a move-to operation is encountered, it is simply copied to the % broken path, starting a new subpath. Then we remember the last % point, its projection's index (the point dictionary is used here) % and the actual projection point. % \begin{macrocode} \def\forest@breakpath@processmoveto#1#2{% \pgfsyssoftpath@moveto{#1}{#2}% \def\forest@previous@x{#1}% \def\forest@previous@y{#2}% \expandafter\let\expandafter\forest@previous@i \csname\forest@bp@prefix(#1,#2)\endcsname \expandafter\let\expandafter\forest@previous@px \csname\forest@bp@prefix\forest@previous@i x\endcsname \expandafter\let\expandafter\forest@previous@py \csname\forest@bp@prefix\forest@previous@i y\endcsname } % \end{macrocode} % % This is the heart of the path-breaking procedure. % \begin{macrocode} \def\forest@breakpath@processlineto#1#2{% % \end{macrocode} % Usually, the broken path will continue with a line-to operation (to % the current point |(#1,#2)|). % \begin{macrocode} \let\forest@breakpath@op\pgfsyssoftpath@lineto % \end{macrocode} % Get the index of the current point's projection and the projection % itself. (The point dictionary is used here.) % \begin{macrocode} \expandafter\let\expandafter\forest@i \csname\forest@bp@prefix(#1,#2)\endcsname \expandafter\let\expandafter\forest@px \csname\forest@bp@prefix\forest@i x\endcsname \expandafter\let\expandafter\forest@py \csname\forest@bp@prefix\forest@i y\endcsname % \end{macrocode} % Test whether the projections of the previous and the current point % are the same. % \begin{macrocode} \forest@equaltotolerance {\pgfqpoint{\forest@previous@px}{\forest@previous@py}}% {\pgfqpoint{\forest@px}{\forest@py}}% \ifforest@equaltotolerance % \end{macrocode} % If so, we are dealing with a segment, perpendicular to the grow % line. This segment must be removed, so we change the operation to % move-to. % \begin{macrocode} \let\forest@breakpath@op\pgfsyssoftpath@moveto \else % \end{macrocode} % Figure out the ``direction'' of the segment: in the order of the % array of projections, or in the reversed order? Setup the loop step % and the test condition. % \begin{macrocode} \forest@temp@count=\forest@previous@i\relax \ifnum\forest@previous@i<\forest@i\relax \def\forest@breakpath@step{1}% \def\forest@breakpath@test{\forest@temp@count<\forest@i\relax}% \else \def\forest@breakpath@step{-1}% \def\forest@breakpath@test{\forest@temp@count>\forest@i\relax}% \fi % \end{macrocode} % Loop through all the projections between (in the (possibly reversed) % array order) the projections of the previous and the current point % (both exclusive). % \begin{macrocode} \loop \advance\forest@temp@count\forest@breakpath@step\relax \expandafter\ifnum\forest@breakpath@test % \end{macrocode} % Intersect the current segment with the line through the current (in % the loop!) projection perpendicular to the grow line. (There % \emph{will} be an intersection.) % \begin{macrocode} \pgfpointintersectionoflines {\pgfqpoint {\csname\forest@bp@prefix\the\forest@temp@count x\endcsname}% {\csname\forest@bp@prefix\the\forest@temp@count y\endcsname}% }% {\pgfpointadd {\pgfqpoint {\csname\forest@bp@prefix\the\forest@temp@count x\endcsname}% {\csname\forest@bp@prefix\the\forest@temp@count y\endcsname}% }% {\pgfqpoint{\forest@xs}{\forest@ys}}% }% {\pgfqpoint{\forest@previous@x}{\forest@previous@y}}% {\pgfqpoint{#1}{#2}}% % \end{macrocode} % Break the segment at the intersection. % \begin{macrocode} \pgfgetlastxy\forest@last@x\forest@last@y \pgfsyssoftpath@lineto\forest@last@x\forest@last@y % \end{macrocode} % Append the breaking point to the inner array for the projection. % \begin{macrocode} \forest@append@point@to@inner@array \forest@last@x\forest@last@y {\forest@bp@prefix\the\forest@temp@count @}% % \end{macrocode} % Cache the projection of the new segment edge. % \begin{macrocode} \csedef{\forest@bp@prefix(\the\pgf@x,\the\pgf@y)}{\the\forest@temp@count}% \repeat \fi % \end{macrocode} % Add the current point. % \begin{macrocode} \forest@breakpath@op{#1}{#2}% % \end{macrocode} % Setup new ``previous'' info: the segment edge, its projection's % index, and the projection. % \begin{macrocode} \def\forest@previous@x{#1}% \def\forest@previous@y{#2}% \let\forest@previous@i\forest@i \let\forest@previous@px\forest@px \let\forest@previous@py\forest@py } % \end{macrocode} % % \subsection{Get tight edge of path} % % This is one of the central algorithms of the package. Given a simple % path and a grow line, this method computes its (negative and % positive) ``tight edge'', which we (informally) define as follows. % % Imagine an infinitely long light source parallel to the grow line, % on the grow line's negative/positive side.\footnote{For the % definition of negative/positive side, see forest@distancetogrowline % in \S\ref{imp:projections}} Furthermore imagine that the path is % opaque. Then the negative/positive tight edge of the path is the % part of the path that is illuminated. % % This macro takes three arguments: |#1| is the path; |#2| and |#3| % are macros which will receive the negative and the positive edge, % respectively. The edges are returned in the softpath format. Grow % line should be set before calling this macro. % % Enclose the computation in a \TeX\ group. This is actually quite % crucial: if there was no enclosure, the temporary data (the segment % dictionary, to be precise) computed by the prior invocations of the % macro could corrupt the computation in the current invocation. % \begin{macrocode} \def\forest@getnegativetightedgeofpath#1#2{% \forest@get@onetightedgeofpath#1\forest@sort@ascending#2} \def\forest@getpositivetightedgeofpath#1#2{% \forest@get@onetightedgeofpath#1\forest@sort@descending#2} \def\forest@get@onetightedgeofpath#1#2#3{% {% \forest@get@one@tightedgeofpath#1#2\forest@gep@edge \global\let\forest@gep@global@edge\forest@gep@edge }% \let#3\forest@gep@global@edge } \def\forest@get@one@tightedgeofpath#1#2#3{% % \end{macrocode} % Project the path to the grow line and compile some useful information. % \begin{macrocode} \forest@projectpathtogrowline#1{forest@pp@}% \forest@sortprojections{forest@pp@}% \forest@processprojectioninfo{forest@pp@}{forest@pi@}% % \end{macrocode} % Break the path. % \begin{macrocode} \forest@breakpath#1{forest@pi@}\forest@brokenpath % \end{macrocode} % Compile some more useful information. % \begin{macrocode} \forest@sort@inner@arrays{forest@pi@}#2% \forest@pathtodict\forest@brokenpath{forest@pi@}% % \end{macrocode} % The auxiliary data is set up: do the work! % \begin{macrocode} \forest@gettightedgeofpath@getedge \pgfsyssoftpath@getcurrentpath\forest@edge % \end{macrocode} % Where possible, merge line segments of the path into a single line % segment. This is an important optimization, since the edges of the % subtrees are computed recursively. Not simplifying the edge could % result in a wild growth of the length of the edge (in the sense of % the number of segments). % \begin{macrocode} \forest@simplifypath\forest@edge#3% } % \end{macrocode} % Get both negative (stored in |#2|) and positive (stored in |#3|) % edge of the path |#1|. % \begin{macrocode} \def\forest@getbothtightedgesofpath#1#2#3{% {% \forest@get@one@tightedgeofpath#1\forest@sort@ascending\forest@gep@firstedge % \end{macrocode} % Reverse the order of items in the inner arrays. % \begin{macrocode} \c@pgf@counta=0 \loop \ifnum\c@pgf@counta<\forest@pi@n\relax \forest@ppi@deflet{forest@pi@\the\c@pgf@counta @}% \forest@reversearray\forest@ppi@let {0}% {\csname forest@pi@\the\c@pgf@counta @n\endcsname}% \advance\c@pgf@counta 1 \repeat % \end{macrocode} % Calling |\forest@gettightedgeofpath@getedge| now will result in the % positive edge. % \begin{macrocode} \forest@gettightedgeofpath@getedge \pgfsyssoftpath@getcurrentpath\forest@edge \forest@simplifypath\forest@edge\forest@gep@secondedge % \end{macrocode} % Smuggle the results out of the enclosing \TeX\ group. % \begin{macrocode} \global\let\forest@gep@global@firstedge\forest@gep@firstedge \global\let\forest@gep@global@secondedge\forest@gep@secondedge }% \let#2\forest@gep@global@firstedge \let#3\forest@gep@global@secondedge } % \end{macrocode} % % Sort the inner arrays of original points wrt the distance to the % grow line. |#2| = % |\forest@sort@ascending|/|\forest@sort@descending|. (|\forest@loopa| is % used here because quicksort uses |\loop|.) % \begin{macrocode} \def\forest@sort@inner@arrays#1#2{% \c@pgf@counta=0 \forest@loopa \ifnum\c@pgf@counta<\csname#1n\endcsname \c@pgf@countb=\csname#1\the\c@pgf@counta @n\endcsname\relax \ifnum\c@pgf@countb>1 \advance\c@pgf@countb -1 \forest@ppi@deflet{#1\the\c@pgf@counta @}% \forest@ppi@defcmp{#1\the\c@pgf@counta @}% \forest@sort\forest@ppi@cmp\forest@ppi@let#2{0}{\the\c@pgf@countb}% \fi \advance\c@pgf@counta 1 \forest@repeata } % \end{macrocode} % % A macro that will define the item exchange macro for quicksorting % the inner arrays of original points. It takes one argument: the % prefix of the inner array. % \begin{macrocode} \def\forest@ppi@deflet#1{% \edef\forest@ppi@let##1##2{% \noexpand\csletcs{#1##1x}{#1##2x}% \noexpand\csletcs{#1##1y}{#1##2y}% \noexpand\csletcs{#1##1d}{#1##2d}% }% } % \end{macrocode} % A macro that will define the item-compare macro for quicksorting the % embedded arrays of original points. It takes one argument: the % prefix of the inner array. % \begin{macrocode} \def\forest@ppi@defcmp#1{% \edef\forest@ppi@cmp##1##2{% \noexpand\forest@sort@cmpdimcs{#1##1d}{#1##2d}% }% } % \end{macrocode} % % Put path segments into a ``segment dictionary'': for each segment of % the path from $(x_1,y_1)$ to $(x_2,y_2)$ let % |\forest@(x1,y1)--(x2,y2)| be |\forest@inpath| (which can be % anything but |\relax|). % \begin{macrocode} \let\forest@inpath\advance % \end{macrocode} % This macro is just a wrapper to process the path. % \begin{macrocode} \def\forest@pathtodict#1#2{% \edef\forest@pathtodict@prefix{#2}% \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@pathtodict@movetoop \let\pgfsyssoftpath@linetotoken\forest@pathtodict@linetoop \def\forest@pathtodict@subpathstart{}% #1% \forest@restore@pgfsyssoftpath@tokendefs } % \end{macrocode} % When a move-to operation is encountered: % \begin{macrocode} \def\forest@pathtodict@movetoop#1#2{% % \end{macrocode} % If a subpath had just started, it was a degenerate one (a point). No % need to store that (i.e.\ no code would use this information). So, % just remember that a new subpath has started. % \begin{macrocode} \def\forest@pathtodict@subpathstart{(#1,#2)-}% } % \end{macrocode} % When a line-to operation is encountered: % \begin{macrocode} \def\forest@pathtodict@linetoop#1#2{% % \end{macrocode} % If the subpath has just started, its start is also the start of the % current segment. % \begin{macrocode} \if\relax\forest@pathtodict@subpathstart\relax\else \let\forest@pathtodict@from\forest@pathtodict@subpathstart \fi % \end{macrocode} % Mark the segment as existing. % \begin{macrocode} \expandafter\let\csname\forest@pathtodict@prefix\forest@pathtodict@from-(#1,#2)\endcsname\forest@inpath % \end{macrocode} % Set the start of the next segment to the current point, and mark % that we are in the middle of a subpath. % \begin{macrocode} \def\forest@pathtodict@from{(#1,#2)-}% \def\forest@pathtodict@subpathstart{}% } % \end{macrocode} % % In this macro, the edge is actually computed. % \begin{macrocode} \def\forest@gettightedgeofpath@getedge{% % \end{macrocode} % Clear the path and the last projection. % \begin{macrocode} \pgfsyssoftpath@setcurrentpath\pgfutil@empty \let\forest@last@x\relax \let\forest@last@y\relax % \end{macrocode} % Loop through the (ordered) array of projections. (Since we will be % dealing with the current and the next projection in each iteration % of the loop, we loop the counter from the first to the % second-to-last projection.) % \begin{macrocode} \c@pgf@counta=0 \forest@temp@count=\forest@pi@n\relax \advance\forest@temp@count -1 \edef\forest@nminusone{\the\forest@temp@count}% \forest@loopa \ifnum\c@pgf@counta<\forest@nminusone\relax \forest@gettightedgeofpath@getedge@loopa \forest@repeata % \end{macrocode} % A special case: the edge ends with a degenerate subpath (a % point). % \begin{macrocode} \ifnum\forest@nminusone<\forest@n\relax\else \ifnum\csname forest@pi@\forest@nminusone @n\endcsname>0 \forest@gettightedgeofpath@maybemoveto{\forest@nminusone}{0}% \fi \fi } % \end{macrocode} % The body of a loop containing an embedded loop must be put in a % separate macro because it contains the |\if...| of the embedded % |\loop...| without the matching |\fi|: |\fi| is ``hiding'' in the % embedded |\loop|, which has not been expanded yet. % \begin{macrocode} \def\forest@gettightedgeofpath@getedge@loopa{% \ifnum\csname forest@pi@\the\c@pgf@counta @n\endcsname>0 % \end{macrocode} % Degenerate case: a subpath of the edge is a point. % \begin{macrocode} \forest@gettightedgeofpath@maybemoveto{\the\c@pgf@counta}{0}% % \end{macrocode} % Loop through points projecting to the current projection. The % preparations above guarantee that the points are ordered (either in % the ascending or the descending order) with respect to their % distance to the grow line. % \begin{macrocode} \c@pgf@countb=0 \forest@loopb \ifnum\c@pgf@countb<\csname forest@pi@\the\c@pgf@counta @n\endcsname\relax \forest@gettightedgeofpath@getedge@loopb \forest@repeatb \fi \advance\c@pgf@counta 1 } % \end{macrocode} % Loop through points projecting to the next projection. Again, the % points are ordered. % \begin{macrocode} \def\forest@gettightedgeofpath@getedge@loopb{% \c@pgf@countc=0 \advance\c@pgf@counta 1 \edef\forest@aplusone{\the\c@pgf@counta}% \advance\c@pgf@counta -1 \forest@loopc \ifnum\c@pgf@countc<\csname forest@pi@\forest@aplusone @n\endcsname\relax % \end{macrocode} % Test whether [the current point]--[the next point] or [the next % point]--[the current point] is a segment in the (broken) path. The % first segment found is the one with the minimal/maximal distance % (depending on the sort order of arrays of points projecting to the % same projection) to the grow line. % % Note that for this to work in all cases, the original path should % have been broken on its self-intersections. However, a careful % reader will probably remember that |\forest@breakpath| does % \emph{not} break the path at its self-intersections. This is % omitted for performance reasons. Given the intended use of the % algorithm (calculating edges of subtrees), self-intersecting paths % cannot arise anyway, if only the node boundaries are % non-self-intersecting. So, a warning: if you develop a new shape and % write a macro computing its boundary, make sure that the computed % boundary path is non-self-intersecting! % \begin{macrocode} \forest@tempfalse \expandafter\ifx\csname forest@pi@(% \csname forest@pi@\the\c@pgf@counta @\the\c@pgf@countb x\endcsname,% \csname forest@pi@\the\c@pgf@counta @\the\c@pgf@countb y\endcsname)--(% \csname forest@pi@\forest@aplusone @\the\c@pgf@countc x\endcsname,% \csname forest@pi@\forest@aplusone @\the\c@pgf@countc y\endcsname)% \endcsname\forest@inpath \forest@temptrue \else \expandafter\ifx\csname forest@pi@(% \csname forest@pi@\forest@aplusone @\the\c@pgf@countc x\endcsname,% \csname forest@pi@\forest@aplusone @\the\c@pgf@countc y\endcsname)--(% \csname forest@pi@\the\c@pgf@counta @\the\c@pgf@countb x\endcsname,% \csname forest@pi@\the\c@pgf@counta @\the\c@pgf@countb y\endcsname)% \endcsname\forest@inpath \forest@temptrue \fi \fi \ifforest@temp % \end{macrocode} % We have found the segment with the minimal/maximal distance to the % grow line. So let's add it to the edge path. % % First, deal with the % start point of the edge: check if the current point is the last % point. If that is the case (this happens if the current point was % the end point of the last segment added to the edge), nothing needs % to be done; otherwise (this happens if the current point will start % a new subpath of the edge), move to the current point, and update % the last-point macros. % \begin{macrocode} \forest@gettightedgeofpath@maybemoveto{\the\c@pgf@counta}{\the\c@pgf@countb}% % \end{macrocode} % Second, create a line to the end point. % \begin{macrocode} \edef\forest@last@x{% \csname forest@pi@\forest@aplusone @\the\c@pgf@countc x\endcsname}% \edef\forest@last@y{% \csname forest@pi@\forest@aplusone @\the\c@pgf@countc y\endcsname}% \pgfsyssoftpath@lineto\forest@last@x\forest@last@y % \end{macrocode} % Finally, ``break'' out of the |\forest@loopc| and |\forest@loopb|. % \begin{macrocode} \c@pgf@countc=\csname forest@pi@\forest@aplusone @n\endcsname \c@pgf@countb=\csname forest@pi@\the\c@pgf@counta @n\endcsname \fi \advance\c@pgf@countc 1 \forest@repeatc \advance\c@pgf@countb 1 } % \end{macrocode} % |\forest@#1@| is an (ordered) array of points projecting to % projection with index |#1|. Check if |#2|th point of that array % equals the last point added to the edge: if not, add it. % \begin{macrocode} \def\forest@gettightedgeofpath@maybemoveto#1#2{% \forest@temptrue \ifx\forest@last@x\relax\else \ifdim\forest@last@x=\csname forest@pi@#1@#2x\endcsname\relax \ifdim\forest@last@y=\csname forest@pi@#1@#2y\endcsname\relax \forest@tempfalse \fi \fi \fi \ifforest@temp \edef\forest@last@x{\csname forest@pi@#1@#2x\endcsname}% \edef\forest@last@y{\csname forest@pi@#1@#2y\endcsname}% \pgfsyssoftpath@moveto\forest@last@x\forest@last@y \fi } % \end{macrocode} % % Simplify the resulting path by ``unbreaking'' segments where % possible. (The macro itself is just a wrapper for path processing % macros below.) % \begin{macrocode} \def\forest@simplifypath#1#2{% \pgfsyssoftpath@setcurrentpath\pgfutil@empty \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@simplifypath@moveto \let\pgfsyssoftpath@linetotoken\forest@simplifypath@lineto \let\forest@last@x\relax \let\forest@last@y\relax \let\forest@last@atan\relax #1% \ifx\forest@last@x\relax\else \ifx\forest@last@atan\relax\else \pgfsyssoftpath@lineto\forest@last@x\forest@last@y \fi \fi \forest@restore@pgfsyssoftpath@tokendefs \pgfsyssoftpath@getcurrentpath#2% } % \end{macrocode} % When a move-to is encountered, we flush whatever segment we were % building, make the move, remember the last position, and set the % slope to unknown. % \begin{macrocode} \def\forest@simplifypath@moveto#1#2{% \ifx\forest@last@x\relax\else \pgfsyssoftpath@lineto\forest@last@x\forest@last@y \fi \pgfsyssoftpath@moveto{#1}{#2}% \def\forest@last@x{#1}% \def\forest@last@y{#2}% \let\forest@last@atan\relax } % \end{macrocode} % How much may the segment slopes differ that we can still merge them? % (Ignore |pt|, these are degrees.) Also, how good is this number? % \begin{macrocode} \def\forest@getedgeofpath@precision{1pt} % \end{macrocode} % When a line-to is encountered\dots % \begin{macrocode} \def\forest@simplifypath@lineto#1#2{% \ifx\forest@last@x\relax % \end{macrocode} % If we're not in the middle of a merger, we need to nothing but start % it. % \begin{macrocode} \def\forest@last@x{#1}% \def\forest@last@y{#2}% \let\forest@last@atan\relax \else % \end{macrocode} % Otherwise, we calculate the slope of the current segment (i.e.\ the % segment between the last and the current point), \dots % \begin{macrocode} \pgfpointdiff{\pgfqpoint{#1}{#2}}{\pgfqpoint{\forest@last@x}{\forest@last@y}}% \ifdim\pgf@x<\pgfintersectiontolerance \ifdim-\pgf@x<\pgfintersectiontolerance \pgf@x=0pt \fi \fi \csname pgfmathatan2\endcsname{\pgf@x}{\pgf@y}% \let\forest@current@atan\pgfmathresult \ifx\forest@last@atan\relax % \end{macrocode} % If this is the first segment in the current merger, simply remember % the slope and the last point. % \begin{macrocode} \def\forest@last@x{#1}% \def\forest@last@y{#2}% \let\forest@last@atan\forest@current@atan \else % \end{macrocode} % Otherwise, compare the first and the current slope. % \begin{macrocode} \pgfutil@tempdima=\forest@current@atan pt \advance\pgfutil@tempdima -\forest@last@atan pt \ifdim\pgfutil@tempdima<0pt\relax \multiply\pgfutil@tempdima -1 \fi \ifdim\pgfutil@tempdima<\forest@getedgeofpath@precision\relax \else % \end{macrocode} % If the slopes differ too much, flush the path up to the previous % segment, and set up a new first slope. % \begin{macrocode} \pgfsyssoftpath@lineto\forest@last@x\forest@last@y \let\forest@last@atan\forest@current@atan \fi % \end{macrocode} % In any event, update the last point. % \begin{macrocode} \def\forest@last@x{#1}% \def\forest@last@y{#2}% \fi \fi } % \end{macrocode} % % % \subsection{Get rectangle/band edge} % % \begin{macrocode} \def\forest@getnegativerectangleedgeofpath#1#2{% \forest@getnegativerectangleorbandedgeofpath{#1}{#2}{\the\pgf@xb}} \def\forest@getpositiverectangleedgeofpath#1#2{% \forest@getpositiverectangleorbandedgeofpath{#1}{#2}{\the\pgf@xb}} \def\forest@getbothrectangleedgesofpath#1#2#3{% \forest@getbothrectangleorbandedgesofpath{#1}{#2}{#3}{\the\pgf@xb}} \def\forest@bandlength{5000pt} % something large (ca. 180cm), but still manageable for TeX without producing `too large' errors \def\forest@getnegativebandedgeofpath#1#2{% \forest@getnegativerectangleorbandedgeofpath{#1}{#2}{\forest@bandlength}} \def\forest@getpositivebandedgeofpath#1#2{% \forest@getpositiverectangleorbandedgeofpath{#1}{#2}{\forest@bandlength}} \def\forest@getbothbandedgesofpath#1#2#3{% \forest@getbothrectangleorbandedgesofpath{#1}{#2}{#3}{\forest@bandlength}} \def\forest@getnegativerectangleorbandedgeofpath#1#2#3{% \forest@path@getboundingrectangle@ls#1{\forest@grow}% \edef\forest@gre@path{% \noexpand\pgfsyssoftpath@movetotoken{\the\pgf@xa}{\the\pgf@ya}% \noexpand\pgfsyssoftpath@linetotoken{#3}{\the\pgf@ya}% }% {% \pgftransformreset \pgftransformrotate{\forest@grow}% \forest@pgfpathtransformed\forest@gre@path }% \pgfsyssoftpath@getcurrentpath#2% } \def\forest@getpositiverectangleorbandedgeofpath#1#2#3{% \forest@path@getboundingrectangle@ls#1{\forest@grow}% \edef\forest@gre@path{% \noexpand\pgfsyssoftpath@movetotoken{\the\pgf@xa}{\the\pgf@yb}% \noexpand\pgfsyssoftpath@linetotoken{#3}{\the\pgf@yb}% }% {% \pgftransformreset \pgftransformrotate{\forest@grow}% \forest@pgfpathtransformed\forest@gre@path }% \pgfsyssoftpath@getcurrentpath#2% } \def\forest@getbothrectangleorbandedgesofpath#1#2#3#4{% \forest@path@getboundingrectangle@ls#1{\forest@grow}% \edef\forest@gre@negpath{% \noexpand\pgfsyssoftpath@movetotoken{\the\pgf@xa}{\the\pgf@ya}% \noexpand\pgfsyssoftpath@linetotoken{#4}{\the\pgf@ya}% }% \edef\forest@gre@pospath{% \noexpand\pgfsyssoftpath@movetotoken{\the\pgf@xa}{\the\pgf@yb}% \noexpand\pgfsyssoftpath@linetotoken{#4}{\the\pgf@yb}% }% {% \pgftransformreset \pgftransformrotate{\forest@grow}% \forest@pgfpathtransformed\forest@gre@negpath }% \pgfsyssoftpath@getcurrentpath#2% {% \pgftransformreset \pgftransformrotate{\forest@grow}% \forest@pgfpathtransformed\forest@gre@pospath }% \pgfsyssoftpath@getcurrentpath#3% } % \end{macrocode} % % \subsection{Distance between paths} % \label{imp:distance} % % Another crucial part of the package. % % \begin{macrocode} \def\forest@distance@between@edge@paths#1#2#3{% % #1, #2 = (edge) paths % % project paths \forest@projectpathtogrowline#1{forest@p1@}% \forest@projectpathtogrowline#2{forest@p2@}% % merge projections (the lists are sorted already, because edge % paths are |sorted|) \forest@dbep@mergeprojections {forest@p1@}{forest@p2@}% {forest@P1@}{forest@P2@}% % process projections \forest@processprojectioninfo{forest@P1@}{forest@PI1@}% \forest@processprojectioninfo{forest@P2@}{forest@PI2@}% % break paths \forest@breakpath#1{forest@PI1@}\forest@broken@one \forest@breakpath#2{forest@PI2@}\forest@broken@two % sort inner arrays ---optimize: it's enough to find max and min \forest@sort@inner@arrays{forest@PI1@}\forest@sort@descending \forest@sort@inner@arrays{forest@PI2@}\forest@sort@ascending % compute the distance \let\forest@distance\relax \c@pgf@countc=0 \loop \ifnum\c@pgf@countc<\csname forest@PI1@n\endcsname\relax \ifnum\csname forest@PI1@\the\c@pgf@countc @n\endcsname=0 \else \ifnum\csname forest@PI2@\the\c@pgf@countc @n\endcsname=0 \else \pgfutil@tempdima=\csname forest@PI2@\the\c@pgf@countc @0d\endcsname\relax \advance\pgfutil@tempdima -\csname forest@PI1@\the\c@pgf@countc @0d\endcsname\relax \ifx\forest@distance\relax \edef\forest@distance{\the\pgfutil@tempdima}% \else \ifdim\pgfutil@tempdima<\forest@distance\relax \edef\forest@distance{\the\pgfutil@tempdima}% \fi \fi \fi \fi \advance\c@pgf@countc 1 \repeat \let#3\forest@distance } % merge projections: we need two projection arrays, both containing % projection points from both paths, but each with the original % points from only one path \def\forest@dbep@mergeprojections#1#2#3#4{% % TODO: optimize: v bistvu ni treba sortirat, ker je edge path že sortiran \forest@sortprojections{#1}% \forest@sortprojections{#2}% \c@pgf@counta=0 \c@pgf@countb=0 \c@pgf@countc=0 \edef\forest@input@prefix@one{#1}% \edef\forest@input@prefix@two{#2}% \edef\forest@output@prefix@one{#3}% \edef\forest@output@prefix@two{#4}% \forest@dbep@mp@iterate \csedef{#3n}{\the\c@pgf@countc}% \csedef{#4n}{\the\c@pgf@countc}% } \def\forest@dbep@mp@iterate{% \let\forest@dbep@mp@next\forest@dbep@mp@iterate \ifnum\c@pgf@counta<\csname\forest@input@prefix@one n\endcsname\relax \ifnum\c@pgf@countb<\csname\forest@input@prefix@two n\endcsname\relax \let\forest@dbep@mp@next\forest@dbep@mp@do \else \let\forest@dbep@mp@next\forest@dbep@mp@iteratefirst \fi \else \ifnum\c@pgf@countb<\csname\forest@input@prefix@two n\endcsname\relax \let\forest@dbep@mp@next\forest@dbep@mp@iteratesecond \else \let\forest@dbep@mp@next\relax \fi \fi \forest@dbep@mp@next } \def\forest@dbep@mp@do{% \forest@sort@cmptwodimcs% {\forest@input@prefix@one\the\c@pgf@counta xp}% {\forest@input@prefix@one\the\c@pgf@counta yp}% {\forest@input@prefix@two\the\c@pgf@countb xp}% {\forest@input@prefix@two\the\c@pgf@countb yp}% \if\forest@sort@cmp@result=% \forest@dbep@mp@@store@p\forest@input@prefix@one\c@pgf@counta \forest@dbep@mp@@store@o\forest@input@prefix@one \c@pgf@counta\forest@output@prefix@one \forest@dbep@mp@@store@o\forest@input@prefix@two \c@pgf@countb\forest@output@prefix@two \advance\c@pgf@counta 1 \advance\c@pgf@countb 1 \else \if\forest@sort@cmp@result>% \forest@dbep@mp@@store@p\forest@input@prefix@two\c@pgf@countb \forest@dbep@mp@@store@o\forest@input@prefix@two \c@pgf@countb\forest@output@prefix@two \advance\c@pgf@countb 1 \else%< \forest@dbep@mp@@store@p\forest@input@prefix@one\c@pgf@counta \forest@dbep@mp@@store@o\forest@input@prefix@one \c@pgf@counta\forest@output@prefix@one \advance\c@pgf@counta 1 \fi \fi \advance\c@pgf@countc 1 \forest@dbep@mp@iterate } \def\forest@dbep@mp@@store@p#1#2{% \csletcs {\forest@output@prefix@one\the\c@pgf@countc xp}% {#1\the#2xp}% \csletcs {\forest@output@prefix@one\the\c@pgf@countc yp}% {#1\the#2yp}% \csletcs {\forest@output@prefix@two\the\c@pgf@countc xp}% {#1\the#2xp}% \csletcs {\forest@output@prefix@two\the\c@pgf@countc yp}% {#1\the#2yp}% } \def\forest@dbep@mp@@store@o#1#2#3{% \csletcs{#3\the\c@pgf@countc xo}{#1\the#2xo}% \csletcs{#3\the\c@pgf@countc yo}{#1\the#2yo}% } \def\forest@dbep@mp@iteratefirst{% \forest@dbep@mp@iterateone\forest@input@prefix@one\c@pgf@counta\forest@output@prefix@one } \def\forest@dbep@mp@iteratesecond{% \forest@dbep@mp@iterateone\forest@input@prefix@two\c@pgf@countb\forest@output@prefix@two } \def\forest@dbep@mp@iterateone#1#2#3{% \loop \ifnum#2<\csname#1n\endcsname\relax \forest@dbep@mp@@store@p#1#2% \forest@dbep@mp@@store@o#1#2#3% \advance\c@pgf@countc 1 \advance#21 \repeat } % \end{macrocode} % % \subsection{Utilities} % % Equality test: points are considered equal if they differ less than % |\pgfintersectiontolerance| in each coordinate. % \begin{macrocode} \newif\ifforest@equaltotolerance \def\forest@equaltotolerance#1#2{{% \pgfpointdiff{#1}{#2}% \ifdim\pgf@x<0pt \multiply\pgf@x -1 \fi \ifdim\pgf@y<0pt \multiply\pgf@y -1 \fi \global\forest@equaltotolerancefalse \ifdim\pgf@x<\pgfintersectiontolerance\relax \ifdim\pgf@y<\pgfintersectiontolerance\relax \global\forest@equaltotolerancetrue \fi \fi }} % \end{macrocode} % % Save/restore |pgf|s |\pgfsyssoftpath@...token| definitions. % \begin{macrocode} \def\forest@save@pgfsyssoftpath@tokendefs{% \let\forest@origmovetotoken\pgfsyssoftpath@movetotoken \let\forest@origlinetotoken\pgfsyssoftpath@linetotoken \let\forest@origcurvetosupportatoken\pgfsyssoftpath@curvetosupportatoken \let\forest@origcurvetosupportbtoken\pgfsyssoftpath@curvetosupportbtoken \let\forest@origcurvetotoken\pgfsyssoftpath@curvetototoken \let\forest@origrectcornertoken\pgfsyssoftpath@rectcornertoken \let\forest@origrectsizetoken\pgfsyssoftpath@rectsizetoken \let\forest@origclosepathtoken\pgfsyssoftpath@closepathtoken \let\pgfsyssoftpath@movetotoken\forest@badtoken \let\pgfsyssoftpath@linetotoken\forest@badtoken \let\pgfsyssoftpath@curvetosupportatoken\forest@badtoken \let\pgfsyssoftpath@curvetosupportbtoken\forest@badtoken \let\pgfsyssoftpath@curvetototoken\forest@badtoken \let\pgfsyssoftpath@rectcornertoken\forest@badtoken \let\pgfsyssoftpath@rectsizetoken\forest@badtoken \let\pgfsyssoftpath@closepathtoken\forest@badtoken } \def\forest@badtoken{% \PackageError{forest}{This token should not be in this path}{}% } \def\forest@restore@pgfsyssoftpath@tokendefs{% \let\pgfsyssoftpath@movetotoken\forest@origmovetotoken \let\pgfsyssoftpath@linetotoken\forest@origlinetotoken \let\pgfsyssoftpath@curvetosupportatoken\forest@origcurvetosupportatoken \let\pgfsyssoftpath@curvetosupportbtoken\forest@origcurvetosupportbtoken \let\pgfsyssoftpath@curvetototoken\forest@origcurvetotoken \let\pgfsyssoftpath@rectcornertoken\forest@origrectcornertoken \let\pgfsyssoftpath@rectsizetoken\forest@origrectsizetoken \let\pgfsyssoftpath@closepathtoken\forest@origclosepathtoken } % \end{macrocode} % % Extend path |#1| with path |#2| translated by point |#3|. % \begin{macrocode} \def\forest@extendpath#1#2#3{% \pgf@process{#3}% \pgfsyssoftpath@setcurrentpath#1% \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@extendpath@moveto \let\pgfsyssoftpath@linetotoken\forest@extendpath@lineto #2% \forest@restore@pgfsyssoftpath@tokendefs \pgfsyssoftpath@getcurrentpath#1% } \def\forest@extendpath@moveto#1#2{% \forest@extendpath@do{#1}{#2}\pgfsyssoftpath@moveto } \def\forest@extendpath@lineto#1#2{% \forest@extendpath@do{#1}{#2}\pgfsyssoftpath@lineto } \def\forest@extendpath@do#1#2#3{% {% \advance\pgf@x #1 \advance\pgf@y #2 #3{\the\pgf@x}{\the\pgf@y}% }% } % \end{macrocode} % % Get bounding rectangle of the path. |#1| = the path, |#2| = grow. % Returns (|\pgf@xa|=min x/l, |\pgf@ya|=max y/s, |\pgf@xb|=min x/l, |\pgf@yb|=max y/s). (If path |#1| % is empty, the result is undefined.) % \begin{macrocode} \def\forest@path@getboundingrectangle@ls#1#2{% {% \pgftransformreset \pgftransformrotate{-(#2)}% \forest@pgfpathtransformed#1% }% \pgfsyssoftpath@getcurrentpath\forest@gbr@rotatedpath \forest@path@getboundingrectangle@xy\forest@gbr@rotatedpath } \def\forest@path@getboundingrectangle@xy#1{% \forest@save@pgfsyssoftpath@tokendefs \let\pgfsyssoftpath@movetotoken\forest@gbr@firstpoint \let\pgfsyssoftpath@linetotoken\forest@gbr@firstpoint #1% \forest@restore@pgfsyssoftpath@tokendefs } \def\forest@gbr@firstpoint#1#2{% \pgf@xa=#1 \pgf@xb=#1 \pgf@ya=#2 \pgf@yb=#2 \let\pgfsyssoftpath@movetotoken\forest@gbr@point \let\pgfsyssoftpath@linetotoken\forest@gbr@point } \def\forest@gbr@point#1#2{% \ifdim#1<\pgf@xa\relax\pgf@xa=#1 \fi \ifdim#1>\pgf@xb\relax\pgf@xb=#1 \fi \ifdim#2<\pgf@ya\relax\pgf@ya=#2 \fi \ifdim#2>\pgf@yb\relax\pgf@yb=#2 \fi } % \end{macrocode} % % \section{The outer UI} % % \subsection{Package options} % % \begin{macrocode} \newif\ifforesttikzcshack \foresttikzcshacktrue \newif\ifforest@install@keys@to@tikz@path@ \forest@install@keys@to@tikz@path@true \forestset{package@options/.cd, external/.is if=forest@external@, tikzcshack/.is if=foresttikzcshack, tikzinstallkeys/.is if=forest@install@keys@to@tikz@path@, } % \end{macrocode} % \subsection{Externalization} % \begin{macrocode} \pgfkeys{/forest/external/.cd, copy command/.initial={cp "\source" "\target"}, optimize/.is if=forest@external@optimize@, context/.initial={% \forestOve{\csname forest@id@of@standard node\endcsname}{environment@formula}}, depends on macro/.style={context/.append/.expanded={% \expandafter\detokenize\expandafter{#1}}}, } \def\forest@external@copy#1#2{% \pgfkeysgetvalue{/forest/external/copy command}\forest@copy@command \ifx\forest@copy@command\pgfkeysnovalue\else \IfFileExists{#1}{% {% \def\source{#1}% \def\target{#2}% \immediate\write18{\forest@copy@command}% }% }{}% \fi } \newif\ifforest@external@ \newif\ifforest@external@optimize@ \forest@external@optimize@true \ProcessPgfPackageOptions{/forest/package@options} \ifforest@install@keys@to@tikz@path@ \tikzset{fit to tree/.style={/forest/fit to tree}} \fi \ifforest@external@ \ifdefined\tikzexternal@tikz@replacement\else \usetikzlibrary{external}% \fi \pgfkeys{% /tikz/external/failed ref warnings for={}, /pgf/images/aux in dpth=false, }% \tikzifexternalizing{}{% \forest@external@copy{\jobname.aux}{\jobname.aux.copy}% }% \AtBeginDocument{% \tikzifexternalizing{% \IfFileExists{\tikzexternalrealjob.aux.copy}{% \makeatletter \input \tikzexternalrealjob.aux.copy \makeatother }{}% }{% \newwrite\forest@auxout \immediate\openout\forest@auxout=\tikzexternalrealjob.for.tmp }% \IfFileExists{\tikzexternalrealjob.for}{% {% \makehashother\makeatletter \input \tikzexternalrealjob.for }% }{}% }% \AtEndDocument{% \tikzifexternalizing{}{% \immediate\closeout\forest@auxout \forest@external@copy{\jobname.for.tmp}{\jobname.for}% }% }% \fi % \end{macrocode} % % \subsection{The \texttt{forest} environment} % \label{imp:forest-environment} % % There are three ways to invoke \foRest;: the environent and the starless and the starred version % of the macro. The latter creates no group. % % Most of the code in this section deals with externalization. % % \begin{macrocode} \newenvironment{forest}{\pgfkeysalso{/forest/begin forest}\Collect@Body\forest@env}{} \long\def\Forest{\pgfkeysalso{/forest/begin forest}\@ifnextchar*{\forest@nogroup}{\forest@group}} \def\forest@group#1{{\forest@env{#1}}} \def\forest@nogroup*#1{\forest@env{#1}} \newif\ifforest@externalize@tree@ \newif\ifforest@was@tikzexternalwasenable \long\def\forest@env#1{% \let\forest@external@next\forest@begin \forest@was@tikzexternalwasenablefalse \ifdefined\tikzexternal@tikz@replacement \ifx\tikz\tikzexternal@tikz@replacement \forest@was@tikzexternalwasenabletrue \tikzexternaldisable \fi \fi \forest@externalize@tree@false \ifforest@external@ \ifforest@was@tikzexternalwasenable \tikzifexternalizing{% \let\forest@external@next\forest@begin@externalizing }{% \let\forest@external@next\forest@begin@externalize }% \fi \fi \forest@standardnode@calibrate \forest@external@next{#1}% } % \end{macrocode} % We're externalizing, i.e.\ this code gets executed in the embedded call. % \begin{macrocode} \long\def\forest@begin@externalizing#1{% \forest@external@setup{#1}% \let\forest@external@next\forest@begin \forest@externalize@inner@n=-1 \ifforest@external@optimize@\forest@externalizing@maybeoptimize\fi \forest@external@next{#1}% \tikzexternalenable } \def\forest@externalizing@maybeoptimize{% \edef\forest@temp{\tikzexternalrealjob-forest-\forest@externalize@outer@n}% \edef\forest@marshal{% \noexpand\pgfutil@in@ {\expandafter\detokenize\expandafter{\forest@temp}.} {\expandafter\detokenize\expandafter{\pgfactualjobname}.}% }\forest@marshal \ifpgfutil@in@ \else \let\forest@external@next\@gobble \fi } % \end{macrocode} % Externalization is enabled, we're in the outer process, deciding if the picture is up-to-date. % \begin{macrocode} \long\def\forest@begin@externalize#1{% \forest@external@setup{#1}% \iftikzexternal@file@isuptodate \setbox0=\hbox{% \csname forest@externalcheck@\forest@externalize@outer@n\endcsname }% \fi \iftikzexternal@file@isuptodate \csname forest@externalload@\forest@externalize@outer@n\endcsname \else \forest@externalize@tree@true \forest@externalize@inner@n=-1 \forest@begin{#1}% \ifcsdef{forest@externalize@@\forest@externalize@id}{}{% \immediate\write\forest@auxout{% \noexpand\forest@external {\forest@externalize@outer@n}% {\expandafter\detokenize\expandafter{\forest@externalize@id}}% {\expandonce\forest@externalize@checkimages}% {\expandonce\forest@externalize@loadimages}% }% }% \fi \tikzexternalenable } \def\forest@includeexternal@check#1{% \tikzsetnextfilename{#1}% \tikzexternal@externalizefig@systemcall@uptodatecheck } \def\makehashother{\catcode`\#=12}% \long\def\forest@external@setup#1{% % set up \forest@externalize@id and \forest@externalize@outer@n % we need to deal with #s correctly (\write doubles them) \setbox0=\hbox{\makehashother\makeatletter \scantokens{\forest@temp@toks{#1}}\expandafter }% \expandafter\forest@temp@toks\expandafter{\the\forest@temp@toks}% \edef\forest@temp{\pgfkeysvalueof{/forest/external/context}}% \edef\forest@externalize@id{% \expandafter\detokenize\expandafter{\forest@temp}% @@% \expandafter\detokenize\expandafter{\the\forest@temp@toks}% }% \letcs\forest@externalize@outer@n{forest@externalize@@\forest@externalize@id}% \ifdefined\forest@externalize@outer@n \global\tikzexternal@file@isuptodatetrue \else \global\advance\forest@externalize@max@outer@n 1 \edef\forest@externalize@outer@n{\the\forest@externalize@max@outer@n}% \global\tikzexternal@file@isuptodatefalse \fi \def\forest@externalize@loadimages{}% \def\forest@externalize@checkimages{}% } \newcount\forest@externalize@max@outer@n \global\forest@externalize@max@outer@n=0 \newcount\forest@externalize@inner@n % \end{macrocode} % The \texttt{.for} file is a string of calls of this macro. % \begin{macrocode} \long\def\forest@external#1#2#3#4{% #1=n,#2=context+source code,#3=update check code, #4=load code \ifnum\forest@externalize@max@outer@n<#1 \global\forest@externalize@max@outer@n=#1 \fi \global\csdef{forest@externalize@@\detokenize{#2}}{#1}% \global\csdef{forest@externalcheck@#1}{#3}% \global\csdef{forest@externalload@#1}{#4}% \tikzifexternalizing{}{% \immediate\write\forest@auxout{% \noexpand\forest@external{#1}% {\expandafter\detokenize\expandafter{#2}}% {\unexpanded{#3}}% {\unexpanded{#4}}% }% }% } % \end{macrocode} % These two macros include the external picture. % \begin{macrocode} \def\forest@includeexternal#1{% \edef\forest@temp{\pgfkeysvalueof{/forest/external/context}}% \typeout{forest: Including external picture '#1' for forest context+code: '\expandafter\detokenize\expandafter{\forest@externalize@id}'}% {% %\def\pgf@declaredraftimage##1##2{\def\pgf@image{\hbox{}}}% \tikzsetnextfilename{#1}% \tikzexternalenable \tikz{}% }% } \def\forest@includeexternal@box#1#2{% \global\setbox#1=\hbox{\forest@includeexternal{#2}}% } % \end{macrocode} % This code runs the bracket parser and stage processing. % \begin{macrocode} \long\def\forest@begin#1{% \iffalse{\fi\forest@parsebracket#1}% } \def\forest@parsebracket{% \bracketParse{\forest@get@root@afterthought}\forest@root=% } \def\forest@get@root@afterthought{% \expandafter\forest@get@root@afterthought@\expandafter{\iffalse}\fi } \long\def\forest@get@root@afterthought@#1{% \ifblank{#1}{}{% \forestOeappto{\forest@root}{given options}{,afterthought={\unexpanded{#1}}}% }% \forest@do } \def\forest@do{% \forest@node@Compute@numeric@ts@info{\forest@root}% \forestset{process keylist=given options}% \forestset{stages}% \pgfkeysalso{/forest/end forest}% \ifforest@was@tikzexternalwasenable \tikzexternalenable \fi } % \end{macrocode} % % \subsection{Standard node} % \label{impl:standard-node} % % The standard node should be calibrated when entering the forest env: ^^AAAAAAAAAAAAAAAAAAAAAAAA % ^^A|\forestNodeHandle{standard node}.calibrate()|. What the calibration does is defined in a call to % ^^A|\forestStandardNode|. % The standard node init does \emph{not} initialize options from a(nother) standard node! % \begin{macrocode} \def\forest@standardnode@new{% \advance\forest@node@maxid1 \forest@fornode{\the\forest@node@maxid}{% \forest@node@init \forest@node@setname{standard node}% }% } \def\forest@standardnode@calibrate{% \forest@fornode{\forest@node@Nametoid{standard node}}{% \edef\forest@environment{\forestove{environment@formula}}% \forestoget{previous@environment}\forest@previous@environment \ifx\forest@environment\forest@previous@environment\else \forestolet{previous@environment}\forest@environment \forest@node@typeset \forestoget{calibration@procedure}\forest@temp \expandafter\forestset\expandafter{\forest@temp}% \fi }% } % \end{macrocode} % Usage: |\forestStandardNode[#1]{#2}{#3}{#4}|. |#1| = standard node specification --- specify it % as any other node content (but without children, of course). |#2| = the environment fingerprint: % list the values of parameters that influence the standard node's height and depth; the standard % will be adjusted whenever any of these parameters changes. |#3| = the calibration procedure: a % list of usual forest options which should calculating the values of exported options. |#4| = a % comma-separated list of exported options: every newly created node receives the initial values of % exported options from the standard node. (The standard node definition is local to the \TeX\ % group.) % \begin{macrocode} \def\forestStandardNode[#1]#2#3#4{% \let\forest@standardnode@restoretikzexternal\relax \ifdefined\tikzexternaldisable \ifx\tikz\tikzexternal@tikz@replacement \tikzexternaldisable \let\forest@standardnode@restoretikzexternal\tikzexternalenable \fi \fi \forest@standardnode@new \forest@fornode{\forest@node@Nametoid{standard node}}{% \forestset{content=#1}% \forestoset{environment@formula}{#2}% \edef\forest@temp{\unexpanded{#3}}% \forestolet{calibration@procedure}\forest@temp \def\forest@calibration@initializing@code{}% \pgfqkeys{/forest/initializing@code}{#4}% \forestolet{initializing@code}\forest@calibration@initializing@code \forest@standardnode@restoretikzexternal } } \forestset{initializing@code/.unknown/.code={% \eappto\forest@calibration@initializing@code{% \noexpand\forestOget{\forest@node@Nametoid{standard node}}{\pgfkeyscurrentname}\noexpand\forest@temp \noexpand\forestolet{\pgfkeyscurrentname}\noexpand\forest@temp }% } } % \end{macrocode} % This macro is called from a new (non-standard) node's init. % \begin{macrocode} \def\forest@initializefromstandardnode{% \forestOve{\forest@node@Nametoid{standard node}}{initializing@code}% } % \end{macrocode} % Define the default standard node. Standard content: dj --- in Computer Modern font, d is the % highest and j the deepest letter (not character!). Environment fingerprint: the height of the % strut and the values of inner and outer seps. Calibration procedure: (i) \keyname{l sep} % equals the height of the strut plus the value of \keyname{inner ysep}, implementing both font-size and % inner sep dependency; (ii) The effect of \keyname{l} on the standard node should be the same as the % effect of \keyname{l sep}, thus, we derive \keyname{l} from \keyname{l sep} by adding % to the latter the total height of the standard node (plus the double outer sep, one for the parent % and one for the child). (iii) s sep is straightforward: a double inner xsep. Exported options: % options, calculated in the calibration. (Tricks: to change the default anchor, set it in |#1| and % export it; to set a non-forest node option (such as \keyname{draw} or \keyname{blue}) as default, set it % in |#1| and export the (internal) option \keyname{node options}.) % \begin{macrocode} \forestStandardNode[dj] {% \forestOve{\forest@node@Nametoid{standard node}}{content},% \the\ht\strutbox,\the\pgflinewidth,% \pgfkeysvalueof{/pgf/inner ysep},\pgfkeysvalueof{/pgf/outer ysep},% \pgfkeysvalueof{/pgf/inner xsep},\pgfkeysvalueof{/pgf/outer xsep}% } { l sep={\the\ht\strutbox+\pgfkeysvalueof{/pgf/inner ysep}}, l={l_sep()+abs(max_y()-min_y())+2*\pgfkeysvalueof{/pgf/outer ysep}}, s sep={2*\pgfkeysvalueof{/pgf/inner xsep}} } {l sep,l,s sep} % \end{macrocode} % % % \subsection{\texttt{ls} coordinate system} % \label{imp:ls-coordinates} % % \begin{macrocode} \pgfqkeys{/forest/@cs}{% name/.code={% \edef\forest@cn{\forest@node@Nametoid{#1}}% \forest@forestcs@resetxy}, id/.code={% \edef\forest@cn{#1}% \forest@forestcs@resetxy}, go/.code={% \forest@go{#1}% \forest@forestcs@resetxy}, anchor/.code={\forest@forestcs@anchor{#1}}, l/.code={% \pgfmathsetlengthmacro\forest@forestcs@l{#1}% \forest@forestcs@ls }, s/.code={% \pgfmathsetlengthmacro\forest@forestcs@s{#1}% \forest@forestcs@ls }, .unknown/.code={% \expandafter\pgfutil@in@\expandafter.\expandafter{\pgfkeyscurrentname}% \ifpgfutil@in@ \expandafter\forest@forestcs@namegoanchor\pgfkeyscurrentname\forest@end \else \expandafter\forest@nameandgo\expandafter{\pgfkeyscurrentname}% \forest@forestcs@resetxy \fi } } \def\forest@forestcs@resetxy{% \ifnum\forest@cn=0 \else \global\pgf@x\forestove{x}% \global\pgf@y\forestove{y}% \fi } \def\forest@forestcs@ls{% \ifdefined\forest@forestcs@l \ifdefined\forest@forestcs@s {% \pgftransformreset \pgftransformrotate{\forestove{grow}}% \pgfpointtransformed{\pgfpoint{\forest@forestcs@l}{\forest@forestcs@s}}% }% \global\advance\pgf@x\forestove{x}% \global\advance\pgf@y\forestove{y}% \fi \fi } \def\forest@forestcs@anchor#1{% \edef\forest@marshal{% \noexpand\forest@original@tikz@parse@node\relax (\forestove{name}\ifx\relax#1\relax\else.\fi#1)% }\forest@marshal } \def\forest@forestcs@namegoanchor#1.#2\forest@end{% \forest@nameandgo{#1}% \forest@forestcs@anchor{#2}% } \tikzdeclarecoordinatesystem{forest}{% \forest@forthis{% \forest@forestcs@resetxy \ifdefined\forest@forestcs@l\undef\forest@forestcs@l\fi \ifdefined\forest@forestcs@s\undef\forest@forestcs@s\fi \pgfqkeys{/forest/@cs}{#1}% }% } % \end{macrocode} % % \addcontentsline{toc}{section}{References} % \bibliography{tex} % \bibliographystyle{plain} % % \newpage % \addcontentsline{toc}{section}{Index} % \makeatletter\c@IndexColumns=2 \makeatother % \IndexPrologue{\section*{Index}} % \PrintIndex % % \endinput % % Local Variables: % mode: doctex % fill-column: 100 % LaTeX-command: "forestlatex -shell-escape" % End: