[Tex/LaTex] How to execute a macro for every node in TikZ

tikz-pgf

EDIT: I have started WhizzyTikZ with the goal of having WhizzyEdit work with (fairly) arbitrary TikZ code. It's good enough now that I have used it on one project.

Background:

WhizzyTeX is a system for showing live updates of a dvi (or pdf). When used with the Active-dvi viewer it also has the ability (called WhizzyEdit) to move or resize elements with the mouse. The elements must have special markup indicating their position and size via source specials. In advi changes are made with the mouse and then brought back into emacs where the position is changed in the code (based on a line number and command name). When it is recompiled the element is in the new position.

For this to work you use the \adviedit macro. You can wrap it in another macro–just tell it the name of the new macro so that WhizzyTeX knows what to change in the source. Also the macro must have a first argument something like {x=1.2,y=3.4} so that it knows how to edit the source.

My Question:

Is there some way to add the source specials to PGF/TikZ primitives so that advi would know where all TikZ nodes are and thus be able to move them? After that there might need to be some heuristics involved with how to edit the source, but I think I can handle that part. Since I know nothing about PGF/TikZ internals I don't know if it would even be possible to write source specials for "every node".

I know there is an every node style, but it doesn't seem to execute code. There is also the execute at begin scope, which can probably be used to ensure that \adviedit and TikZ use the same units, but it won't help with adding specials. In a path, execute at begin to and execute at end to might be useful, but for isolated nodes it seems useless.

Eventually I would like a package that would override (well, hopefully just append to) some internal TikZ macros allowing me to move any TikZ node and perhaps even play with Bezier curves etc.

Right now I have the first step, namely a macro that draws a node and inserts the \adviedit. It uses tkz-graph so that I don't have to parse the x=#,y=# myself.

\documentclass[12pt]{article}
\usepackage{advi}

\usepackage{tikz}
\usepackage{tkz-graph}

\begin{document}

 \begin{tikzpicture}[x=1cm,y=1cm]
   \SetVertexNoLabel
   % For reference
   \draw (0,0) rectangle (15,15);
   % My attempt to
   \def\mynode#1{%
     \setedit{unit=1cm}
     \adviedit{comm=\mynode,w=1,h=1,#1}{}
     \Vertex[#1]{}
   }
   % "Turn off" WhizzyEdit
   % \def\mynode#1{\Vertex[#1]{}}%
   \mynode{x=8.9921,y=8.6836}
   \mynode{x=7.2178,y=9.1965}
   \mynode{x=6.464,y=6.6085}
   \mynode{x=7.2497,y=7.8264}
   \mynode{x=3.7562,y=6.9931}
   \mynode{x=3.5366,y=10.3264}
   \mynode{x=9.3650,y=7.0893}
   \mynode{x=10.1343,y=5.4871}
   \mynode{x=7.3460,y=12.1536}
   \mynode{x=2.2179,y=1.5769}
\end{tikzpicture}

\end{document}

Note that labels aren't placed correctly which is why I turned them off. That's not my fault (I don't think).

Best Answer

I've done a little experimenting, and have some code that I hope will help you. It's not a complete solution by any means.

It appears that an advieditable macro has to be of the form \macro{x=<value>,y=<value>} for whizzytex to be able to feed the numbers back in. My first idea was simply to add a style to a \node so it looked something like \node[advi={x=<value,y=<value>}] but that didn't seem to work (maybe more experimenting would reveal a way to make this work). So I defined a wrapper around the \node command which took the coordinates at the start and then handed control over to the original \node. Because of the way that \node executes the options it is given (as in \node[draw]), there's no problem with this.

Here's the code. I'll comment on it in the code.

\documentclass[12pt]{article}
%\url{http://tex.stackexchange.com/q/50468/86}
\usepackage{advi}
\usepackage{tikz}

% We need to use some internal commands with `@`s in them for getting
% the widths of the nodes
\makeatletter
\tikzset{
% This is the workhorse style
  advi/.style={
% We do the advi stuff after the node has been placed so that we can
% get access to its width and height.  What this means is that our
% node ends up being equivalent to
%  \node[at=(x-value,y-value)] {node text} [advi/set advi={x=,y=}];
    append after command={[advi/set advi={#1}]},
% As the advi boxes are specified by lower-left corner, we anchor our
% node at the lower-left so that the given coordinate is the node
% coordinate
    anchor=south west,
% The parameter #1 is of the form "x=<value>,y=<value>".  We trick
% TikZ into taking that as defining some keys in the "/tikz/advi"
% directory
    advi/.cd,
    #1,
% We use the values that have just been set, namely `/tikz/advi/x`
% and `/tikz/advi/y` to specify the location of the node via the
% `at` key.  We need to give the full path as we're currently in at
% `/tikz/advi`
    /tikz/at={(\pgfkeysvalueof{/tikz/advi/x},\pgfkeysvalueof{/tikz/advi/y})}
  },
% This next bit ensures that the `/tikz/advi/x` and `y` keys can be
% used to store values.
  advi/.cd,
  x/.initial=0,
  y/.initial=0,
% This is the part that specifies the boxes in the dvi.  This is
% actually executed after the node has been processed
  set advi/.code={
% As the node has been processed, we can get its width and height by
% looking at a couple of anchors.
    \tikz@scan@one@point\pgfutil@firstofone(\tikzlastnode.north east)
    \pgf@xa=\pgf@x
    \pgf@ya=\pgf@y
    \tikz@scan@one@point\pgfutil@firstofone(\tikzlastnode.south west)
% We adjust the values to be multiples of `em`s as that's the default
% for advi/whizzytex
    \pgfmathsetmacro{\advi@node@w}{(\pgf@xa - \pgf@x)/1em}%
    \pgfmathsetmacro{\advi@node@h}{(\pgf@ya - \pgf@y)/1em}%
% Finally, we call the `\adviedit` command
    \adviedit{comm=\advinode,w=\advi@node@w,h=\advi@node@h,#1}{}%}
  }
}
\makeatother

% This is the command that whizzytex will look for.
\newcommand{\advinode}[1]{%
  \node[advi={#1}]
}

\begin{document}

hello world, how are you?

% We use `em` units as those are the defaults for advi/whizzytex.
% Presumably this could be made configurable or some wizardry used
% to ensure that the tikz coordinates and the advi coordinates
% matched.
\begin{tikzpicture}[x=1em,y=1em]
% We can even pass ordinary styles to the node:
   \advinode{x=13.6805,y=7.3048}[red,draw] {A};
   \advinode{x=5.7699,y=10.5065}[circle,fill=blue!50] {B};
   \advinode{x=6.464,y=6.6085} {C};
   \advinode{x=7.2497,y=7.8264} {D};
   \advinode{x=3.7562,y=6.9931} {E};
   \advinode{x=1.8567,y=12.5472} {F};
   \advinode{x=9.3650,y=7.0893} {G};
   \advinode{x=13.9264,y=4.4529} {H};
   \advinode{x=11.4138,y=11.5331} {I};
   \advinode{x=3.3900,y=2.6800} {J};
\end{tikzpicture}

\end{document}

I don't trust trying this with the standalone class, so here's a screenshot instead.

advi with draggable nodes

The blue boxes and green lines are those drawn by advi. Note that they are drawn under the drawing, so are overwritten by the border of the A node and the filled region of the B node. They are draggable.

The green lines show that the coordinates are relative to something. Experimenting shows that they are relative to the (0,0) inside the picture - which is what it should be. (A quick look at the code for advi.sty shows that there is some interaction with PGF builtin which probably takes care of this bit).

(Lastly, this looks very intriguing and definitely worth learning about.)

Related Solutions

[Tex/LaTex] AucTeX extension for TikZ

UPDATE, 11/10/11: I've posted the code at https://github.com/blerner/auc-tikz -- the most recent version is auc-tikz-struct.el (the other files are older experimental versions). I haven't had time to update the code in a while, so if people want to tinker with the code, have at it! It's still rough, but it should sorta work if you'd like to try it out.

Original answer

Per @egreg's request, a comment-turned-answer, and some elaboration on what's tricky about this prospect: I tried writing an AUCTeX TikZ highlighting plugin to address the first bullet point in your question, though I haven't had much time since my comment to work on it. The challenge in writing a syntax-highlighting mode (aka "font-lock" mode or "fontifying") for any part of emacs is that emacs uses regular expressions to match text. TikZ's grammar ... is not regular. In particular, the key=value portions are recursive, since you might have key={key=value,key=value}, as in

\tikzset{foo/.style={draw,circle,etc...},
         bar/.style={blue,etc...}}

While elisp's regular expressions do let you have backreferences (and therefore aren't true regular expressions), font-lock doesn't let you refer to the recursively matched subgroups, so you can't get the font-lock behavior you need. I've tried several possible approaches:

So I started (ab)using a more powerful approach, with Toby Cubitt's auto-overlays package (also the author of the cleveref package). An overlay, in the parlance of this package, is similar to marking up a stretch of text with <span> in HTML, so you can hook styles onto it. I don't fully understand how auto-overlays does its magic, but it allows you to dynamically create overlays based on matcher functions, and it will take care of deleting them when the text no longer matches. At least in theory it would, if I were using it properly :) After emailing the author, he recommended that I avoid this approach because emacs' performance suffers with too many overlays.

There is a very contorted way to trigger an arbitrary function during font-locking, which can then be used to manually assign the 'font properties to stretches of text. The trick is to use what's called an "anchored match", which lets you define some functions that get called in lieu of the default font-highlighting. But this leads to infinite loops for me, because font-lock is very brittle with multi-line matches.
The approach that seems to be working is to hijack AUCTeX's hijacking of the font-lock mechanism, and after AUCTeX finishes, double-back and check whether there's a tikzpicture environment and if so, manually assign font-lock highlighting to it. There's still a subtle bug in that emacs re-highlights only chunks of the buffer at a time, so my code can correctly highlight the TikZ code but the colors won't be shown until the page is fully refreshed.

The upshot is I have a new package in the works, called auc-tikz.el, that builds some highlighting functions that properly match the grammar of the key=value part of TikZ, including the recursive parts, and a hard-coded recognition of the \tikzset command as a trigger to create an auto-overlay. It looks like this, in my current color scheme:

auctikz

/Key/paths are recognized separately from the final /.command (as in iface/.style), so that you can see which settings are simple names (draw,fill=blue!20) and which are somewhat meta (iface/.style). Braces are purple when they delimit a TikZ option group (iface/.style={...}), but are light blue when they're part of a value (mark=at position...{...}). Comments are mostly supported, though they may still have some unintuitive behavior. Unknown commands are red, from the first parsing error up through the next uncommented semicolon.

The \node, \path and \draw (and any other) commands are not parsed properly, particularly not all the locations [options] can be interspersed in such commands. All the various coordinate forms are not parsed properly; I currently have (coord), ++(coord) and (coord)+(coord) support. Other forms, like ($(coord)!calc!(coord)$), are not yet supported. (They kinda sorta work, because the parser just looks for a balanced paren group; if you left out a closing $, it would mistakenly highlight as correct...)

"All" that remains to do is recognize the generic TikZ \macro ... ; syntax, and get the highlighting to refresh properly. And support nested environments, like pgfonlayer and scope and such. And speed the code up considerably; it's slow to parse even a smallish tikzpicture.

[Tex/LaTex] Using execute at begin node with \phantom and \pgfuseimage in TikZ

There's a lot of information buried in the comments so I'm going to try to extract my contributions into some form of answer. My recommended solution is to use pgfkeys. The key lengths can be short - single letter if really wanted - so the number of key strokes needed to use them is not really that much more than putting the picture name in the node text. Indeed, if you are going to use names that match some pattern (as in the example), there's no need to specify the picture name at all whereupon it isn't necessary to use any key in the actual node commands. Or you could patch into the unknown key handler so that an unknown key is taken to the the name of a picture. The pgfkeys method is the most robust, I think, and the most flexible. For example, it will work with matrix of nodes.

Second in my list of solutions would be Jake's solution of defining an entirely new macro. The only downside to this is that it doesn't work transparently with matrix of nodes (that is, you can always put the new macro into the cells but you can't take advantage of the automatically inserted nodes).

Way, way down at the bottom of my list is a hack that allows you to actually do what you originally asked: use the node text as the argument to a macro. This is a Very Bad Idea for lots of reasons. Firstly, it involves modifying the TikZ node processing commands directly rather than via hooks. Secondly, the opening bracket of the node text is actually removed before TikZ starts its node machinery (this is what TikZ looks for to know to start processing the text and the test is destructive) so we have to put it back again and this means More Hackery. It is not possible to insert stuff in the begin node/end node hooks for two reasons: Firstly, what appears between those two hooks is not just the node text. It is:

\bgroup%
  \aftergroup\unskip%
  \ifx\tikz@textcolor\pgfutil@empty%
  \else%
   \pgfutil@colorlet{.}{\tikz@textcolor}%
  \fi%
  \pgfsetcolor{.}%
  \setbox\tikz@figbox=\box\pgfutil@voidb@x%
  \tikz@uninstallcommands%
  \aftergroup\tikz@fig@collectresetcolor%
  \tikz@halign@check%
  \ignorespaces%

followed by the node text. There's even more junk after the node text and before the end hook is called. So if we want to get at the actual node text we need to add something after that \ignorespaces and it has to have a genuine opening brace.

Here's code illustrating all the above-mentioned solutions.

\documentclass{article}

\usepackage{tikz}

\pgfdeclareimage{firstpicture}{vignettes.pdf}
\pgfdeclareimage{secondpicture}{vignettes.pdf}
\pgfdeclareimage{thirdpicture}{vignettes.pdf}
\pgfdeclareimage{fourthpicture}{vignettes.pdf}

\makeatletter
\newif\if@pgfimagefound
\tikzset{
  dummy image with key/.style={
    every node/.append style={%
      execute at end
node=\phantom{\pgfuseimage{\pgfkeysvalueof{/tikz/pname}}}
    },
  },
  pname/.initial={},
  dummy image/.style={
    every node/.append style={%
      execute at end
node=\phantom{\pgfuseimage{\pgfkeysvalueof{/tikz/pname}}},
    /tikz/.unknown/.add code=%
    {%
      \@ifundefined{pgf@image@\pgfkeyscurrentname!}{\@pgfimagefoundfalse}{%
        \let\tikz@key=\pgfkeyscurrentname
        \tikzset{pname/.expand once=\tikz@key}%
        \@pgfimagefoundtrue
      }%
      \if@pgfimagefound
      \else
    }%
    {
      \fi
    }
    }
  }
}

\let\orig@tikz@do@fig=\tikz@do@fig
\tikzset{
  slurp node text/.code={
    \def\tikz@do@fig{\orig@tikz@do@fig\expandafter\slurp@node\expandafter{\iffalse}\fi}
  },
  slurp node/.style={
    every node/.append style={
      slurp node text
    },
    slurp node command/.code={#1}
  },
}
\def\slurp@node#1{%
\pgfkeys{/tikz/slurp node command={#1}}%
\egroup}

\newcommand\imgnode[2][]{%
  \node[#1] {\phantom{\pgfuseimage{#2}}};}

\makeatletter
\begin{document}
\tikzset{every node/.append style={draw}}
\begin{tikzpicture}
\matrix [dummy image with key]
{
  \node[pname=firstpicture] {}; & \node[pname=secondpicture] {}; \\
  \node[pname=thirdpicture] {}; & \node[pname=fourthpicture] {}; \\
};
\end{tikzpicture}

\begin{tikzpicture}
\matrix [dummy image]
{
  \node[firstpicture] {}; & \node[secondpicture] {}; \\
  \node[thirdpicture] {}; & \node[fourthpicture] {}; \\
};
\end{tikzpicture}

\begin{tikzpicture}
\matrix
{
  \imgnode{firstpicture} & \imgnode{secondpicture} \\
  \imgnode{thirdpicture} & \imgnode{fourthpicture} \\
};
\end{tikzpicture}

\begin{tikzpicture}
\matrix [slurp node={\phantom{\pgfuseimage{#1}}}] {
  \node {firstpicture}; & \node {secondpicture}; \\
  \node {thirdpicture}; & \node {fourthpicture}; \\
};
\end{tikzpicture}
\end{document}

Best Answer

Related Solutions

[Tex/LaTex] AucTeX extension for TikZ

[Tex/LaTex] Using execute at begin node with \phantom and \pgfuseimage in TikZ

Related Question