From 6bc1f5497cfb2f56d65c80a4c36ea3bad6dc046c Mon Sep 17 00:00:00 2001 From: Karl Berry Date: Fri, 29 Oct 2010 00:31:31 +0000 Subject: pgf 2.10 (28oct10) git-svn-id: svn://tug.org/texlive/trunk@20236 c570f23f-e606-0410-a88d-b1316a301751 --- .../generic/pgf/utilities/pgfexternalwithdepth.tex | 43 + .../tex/generic/pgf/utilities/pgffor.code.tex | 583 ++++++++++- .../tex/generic/pgf/utilities/pgfkeys.code.tex | 405 +++++++- .../generic/pgf/utilities/pgfkeysfiltered.code.tex | 1016 ++++++++++++++++++++ .../tex/generic/pgf/utilities/pgfrcs.code.tex | 8 +- .../tex/generic/pgf/utilities/pgfutil-common.tex | 339 ++++++- .../tex/generic/pgf/utilities/pgfutil-context.def | 131 ++- .../tex/generic/pgf/utilities/pgfutil-latex.def | 37 + .../tex/generic/pgf/utilities/pgfutil-plain.def | 72 +- 9 files changed, 2514 insertions(+), 120 deletions(-) create mode 100644 Master/texmf-dist/tex/generic/pgf/utilities/pgfexternalwithdepth.tex create mode 100644 Master/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.tex (limited to 'Master/texmf-dist/tex/generic/pgf/utilities') diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfexternalwithdepth.tex b/Master/texmf-dist/tex/generic/pgf/utilities/pgfexternalwithdepth.tex new file mode 100644 index 00000000000..38eeb306855 --- /dev/null +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfexternalwithdepth.tex @@ -0,0 +1,43 @@ +% Copyright 2007 by Till Tantau +% +% This file may be distributed and/or modified +% +% 1. under the LaTeX Project Public License and/or +% 2. under the GNU Public License. +% +% See the file doc/generic/pgf/licenses/LICENSE for more details. +% +% In addition to the above licenses, this particular file may also be +% directly inlined into other documents and this copyright notice may +% be removed. Additionally, when you inline this file, you may modify +% it as needed and you may remove comments. +% +% This file is intended to be distributed or even inlined into a file +% when a document needs to be typeset on a system that does not have +% pgf/TikZ installed. + +% "environment" for reading an external graphic. Note that there are +% no (!) braces around the "name" of the environment +% +% #1 = name of the graphics file +% +% Example: +% +% \beginpgfgraphicnamed{mygraph} +% \begin{tikzpicture} +% ... +% \end{tikzpicture} +% \endpgfgraphicnamed + +\long\def\beginpgfgraphicnamed#1#2\endpgfgraphicnamed{% + \begingroup + \setbox1=\hbox{\includegraphics{#1}}% + \openin1=#1.dpth + \ifeof1 \box1 + \else + \read1 to\pgfincludeexternalgraphicsdp \closein1 + \dimen0=\pgfincludeexternalgraphicsdp\relax + \hbox{\lower\dimen0 \box1 }% + \fi + \endgroup +} diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgffor.code.tex b/Master/texmf-dist/tex/generic/pgf/utilities/pgffor.code.tex index 46a62f31767..d31ddedfe26 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgffor.code.tex +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgffor.code.tex @@ -1,4 +1,4 @@ -% Copyright 2006 by Till Tantau +% Copyright 2008 by Till Tantau and Mark Wibrow % % This file may be distributed and/or modified % @@ -7,23 +7,72 @@ % % See the file doc/generic/pgf/licenses/LICENSE for more details. -\ProvidesPackageRCS[v\pgfversion] $Header: /cvsroot/pgf/pgf/generic/pgf/utilities/pgffor.code.tex,v 1.8 2007/11/07 23:21:48 tantau Exp $ - +\ProvidesPackageRCS[v\pgfversion] $Header: /cvsroot/pgf/pgf/generic/pgf/utilities/pgffor.code.tex,v 1.18 2010/03/23 14:47:45 vibrovski Exp $ \newdimen\pgffor@iter \newdimen\pgffor@skip \newif\ifpgffor@continue + \let\pgffor@beginhook=\pgfutil@empty \let\pgffor@endhook=\pgfutil@empty \let\pgffor@afterhook=\pgfutil@empty +% Stack emulation +% +\newtoks\pgffor@stack +\pgffor@stack={{}{}{}} + +\def\pgffor@stackpush#1{% + \def\pgffor@stacktemp{#1}% + \expandafter\expandafter\expandafter\pgffor@stack\expandafter\expandafter\expandafter=% + \expandafter\expandafter\expandafter{\expandafter\expandafter\expandafter% + {\expandafter\pgffor@stacktemp\expandafter}\the\pgffor@stack}% +} + +\def\pgffor@stackpop{\expandafter\pgffor@@stackpop\the\pgffor@stack\pgffor@stackstop} +\def\pgffor@@stackpop#1#2\pgffor@stackstop{\pgffor@stack{#2}#1} + \def\pgffor@emptyvalues{, \pgffor@stop,}% -\def\foreach#1in{% - \def\pgffor@var{#1}% - \pgfutil@ifnextchar\bgroup{\pgffor@normal@list}{\pgffor@macro@list}} +\def\pgffor@foreach{% + \pgffor@atbeginforeach% + \let\pgffor@assign@before@code=\pgfutil@empty% + \let\pgffor@assign@after@code=\pgfutil@empty% + \let\pgffor@assign@once@code=\pgfutil@empty% + \let\pgffor@remember@code=\pgfutil@empty% + \let\pgffor@remember@once@code=\pgfutil@empty% + \pgffor@alphabeticsequencefalse% + \pgffor@contextfalse% + % + \let\pgffor@var=\pgfutil@empty + % + \pgffor@vars% +} + +\let\foreach=\pgffor@foreach + +\def\pgffor@vars{% + \pgfutil@ifnextchar i{\pgffor@@vars@end}{% + \pgfutil@ifnextchar[{\pgffor@@vars@opt}{%] + \pgfutil@ifnextchar/{\pgffor@@vars@slash@gobble}{% + \pgffor@@vars}}}}% + +\def\pgffor@@vars@end in{\pgfutil@ifnextchar\bgroup{\pgffor@normal@list}{\pgffor@macro@list}} +\def\pgffor@@vars@opt[#1]{\pgfkeys{/pgf/foreach/.cd,#1}\pgffor@vars} +\def\pgffor@@vars#1{\pgffor@var@add#1\pgffor@stop\pgffor@vars} +\def\pgffor@@vars@slash@gobble/{\pgffor@@vars} + +\def\pgffor@var@add#1#2\pgffor@stop{% + \ifx\pgffor@var\pgfutil@empty% + \def\pgffor@var{#1}% + \def\pgffor@mainvar{#1}% + \else% + \expandafter\def\expandafter\pgffor@var\expandafter{\pgffor@var/#1}% + \fi% +} + \def\pgffor@macro@list#1{% \expandafter\pgffor@normal@list\expandafter{#1}} \def\pgffor@normal@list#1{% @@ -31,10 +80,9 @@ \ifx\pgffor@values\pgffor@emptyvalues \def\pgffor@values{\pgffor@stop,}% \fi% - \let\pgffor@body\pgfutil@empty% + \let\pgffor@body=\pgfutil@empty% \global\pgffor@continuetrue% \pgffor@collectbody} - \def\pgffor@collectbody{% \pgfutil@ifnextchar\foreach{\pgffor@collectforeach}{% \pgfutil@ifnextchar\bgroup{\pgffor@collectargument}{\pgffor@collectsemicolon}}% @@ -50,13 +98,18 @@ \expandafter\long\expandafter\def\expandafter\pgffor@body\expandafter{\pgffor@body\foreach#1in{#2}}% \pgffor@collectbody% } - \long\def\pgffor@collectargument#1{% - \expandafter\long\expandafter\def\expandafter\pgffor@body\expandafter{\pgffor@body{#1}}% + \expandafter\pgfutil@in@\expandafter\foreach\expandafter{\pgffor@body}% + \ifpgfutil@in@% + \expandafter\long\expandafter\def\expandafter\pgffor@body\expandafter% + {\pgffor@body{#1}}% + \else% + \expandafter\long\expandafter\def\expandafter\pgffor@body\expandafter% + {\pgffor@body#1}% + \fi% \pgffor@iterate% } - \def\pgffor@collectsemicolon{% \let\pgffor@next=\pgffor@collectnormalsemicolon% \ifnum\the\catcode`\;=\active\relax% @@ -77,12 +130,17 @@ \expandafter\long\expandafter\def\expandafter\pgffor@body\expandafter{\pgffor@body#1;}% \pgffor@iterate% } -} +} \def\pgffor@iterate{% - \let\pgffor@last\pgfutil@empty% - \let\pgffor@prevlast\pgfutil@empty% - \expandafter\pgffor@scan\pgffor@values} + % Must do all of these in case the internal stack is used. + \let\pgffor@last=\pgfutil@empty% + \let\pgffor@prevlast=\pgfutil@empty% + \let\pgffor@dotsend=\pgfutil@empty% + \let\pgffor@dots@pre=\pgfutil@empty% + \let\pgffor@dots@post=\pgfutil@empty% + % + \expandafter\pgffor@scan\pgffor@values} \def\pgffor@stop{\pgffor@stop}% \def\pgffor@dots{...}% @@ -91,35 +149,54 @@ \def\pgffor@scanround(#1)#2,{\def\pgffor@value{(#1)}\pgffor@scanned} \def\pgffor@scanone#1,{\def\pgffor@value{#1}\pgffor@scanned} + +% Check for dots. +\newif\ifpgffor@dots@in@ +\def\pgffor@dots@in@#1...#2#3\pgffor@stop{% + \ifx\pgffor@dots@@#2% + \pgffor@dots@in@false% + \else% + \pgffor@dots@in@true% + \fi% +} + +\def\pgffor@dots@@{\pgffor@dots@@} + \def\pgffor@scanned{% \ifx\pgffor@value\pgffor@stop% - \let\pgffor@next=\pgffor@after% done! + \let\pgffor@next=\pgffor@after% Done! \else% - \ifx\pgffor@value\pgffor@dots% + % Check for dots. Quicker than \pgfutil@in@ and not suceptable + % to false-positives when a token sequence ends in a single full-stop. + \expandafter\pgffor@dots@in@\pgffor@value\pgffor@dots@...\pgffor@dots@@\pgffor@stop% + \ifpgffor@dots@in@% \let\pgffor@next=\pgffor@handledots% \else% \let\pgffor@next=\pgffor@handlevalue% \fi% \ifpgffor@continue% \else% - \let\pgffor@next=\pgffor@scan% done! + \let\pgffor@next=\pgffor@scan% Done! \fi% \fi% \pgffor@next} + \def\pgffor@after{% \global\pgffor@continuetrue% + \pgffor@atendforeach% \pgffor@afterhook} - + \def\pgffor@handlevalue{% - \let\pgffor@prevlast\pgffor@last% - \let\pgffor@last\pgffor@value% + \let\pgffor@prevlast=\pgffor@last% + \let\pgffor@last=\pgffor@value% \pgffor@invokebody% \pgffor@scan% } + \def\pgffor@invokebody{% - \begingroup% + \pgffor@begingroup% \expandafter\pgfutil@in@\expandafter/\expandafter{\pgffor@var}% \ifpgfutil@in@% \expandafter\def\expandafter\pgffor@valuerest\expandafter{\pgffor@value//\relax}% @@ -127,8 +204,25 @@ \else% \expandafter\expandafter\expandafter\def\expandafter\pgffor@var\expandafter{\pgffor@value}% \fi% + % Execute assign once code. + \ifx\pgffor@assign@once@code\pgfutil@empty% + \else% + \pgffor@assign@once@code% + \fi% + % Execute assign before code. + \ifx\pgffor@assign@before@code\pgfutil@empty% + \else% + \pgffor@assign@before@code% + \fi% + % \expandafter\pgffor@beginhook\pgffor@body\pgffor@endhook% - \endgroup% + % Execute assign after code. + \ifx\pgffor@assign@after@code\pgfutil@empty% + \else% + \pgffor@assign@after@code% + \fi% + % + \pgffor@endgroup% } @@ -145,27 +239,60 @@ \def\pgffor@multiassignrest{\expandafter\pgffor@multiassignfinal\pgffor@valuerest} \def\pgffor@multiassignfinal#1/#2/\relax{% + \def\pgffor@temp{#1}% + \ifx\pgffor@currentvar\pgffor@mainvar% + \ifpgffor@alphabeticsequence% + \pgffor@makealphabetic\pgffor@temp% + \fi% + \fi% \def\pgffor@test{#2}% \ifx\pgffor@test\pgfutil@empty% - \def\pgffor@valuerest{#1//\relax}% repeat + \expandafter\def\expandafter\pgffor@valuerest\expandafter{\pgffor@temp//\relax}% repeat \else% \def\pgffor@valuerest{#2/\relax}% \fi% - \expandafter\def\pgffor@currentvar{#1}% + \expandafter\expandafter\expandafter\def\expandafter\pgffor@currentvar\expandafter{\pgffor@temp}% + % \expandafter\pgffor@multiassign\pgffor@rest/\relax% -} - - +} +\def\pgffor@gobblespaces#1{\pgfutil@ifnextchar x{#1}{#1}} \def\pgffor@handledots{% - \ifx\pgffor@last\pgfutil@empty% - \PackageError{pgffor}{``...'' not allowed without prior value}{}% - \fi% - \pgffor@dotsscanend% + \pgffor@gobblespaces{\expandafter\pgffor@@handledots\pgffor@value\pgffor@@stop}% +} + +\newif\ifpgffor@context + +\def\pgffor@@handledots#1...#2\pgffor@@stop{% + % Define the context if any. + \def\pgffor@dots@pre{#1}% + \def\pgffor@dots@post{#2}% + \def\pgffor@dots@stripcontext#1##1#2\pgffor@@stop{\def\pgffor@dotsvalue{##1}}% + \pgffor@contexttrue% + \ifx\pgffor@dots@pre\pgfutil@empty% + \ifx\pgffor@dots@post\pgfutil@empty% + \pgffor@contextfalse% + \def\pgffor@dots@stripcontext##1\pgffor@@stop{\def\pgffor@dotsvalue{##1}}% + \fi% + \fi% + \pgffor@gobblespaces{\pgffor@dotsscanend}% } + +\def\pgffor@dots@value@process#1{% + \expandafter\pgffor@dots@stripcontext#1\pgffor@@stop% + \expandafter\pgffor@dots@charcheck\pgffor@dotsvalue\pgffor@@stop% + \let#1=\pgffor@dotsvalue% +} + \def\pgffor@dotsscanend#1,{% - \def\pgffor@dotsend{#1}% + \pgffor@alphabeticsequencefalse% + % Strip context and check for a character sequence. + \def\pgffor@dotsend{#1}% + \pgffor@dots@value@process{\pgffor@dotsend}% + % + \pgffor@dots@value@process{\pgffor@last}% + % % calculate skip% \ifx\pgffor@prevlast\pgfutil@empty% \ifdim\pgffor@dotsend pt>\pgffor@last pt% @@ -174,6 +301,7 @@ \pgffor@skip=-1pt% \fi% \else% + \pgffor@dots@value@process{\pgffor@prevlast}% \pgffor@skip=\pgffor@last pt% \pgffor@iter=\pgffor@prevlast pt% \advance\pgffor@skip by-\pgffor@iter% @@ -197,19 +325,20 @@ \fi% \ifpgffor@continue% \else% - \let\pgffor@next=\pgffor@endloop% done! + \let\pgffor@next=\pgffor@endloop% Done! \fi% \pgffor@next% } \def\pgffor@endloop{% - \pgffor@scan% + \pgffor@alphabeticsequencefalse% + \pgffor@scan% } {\catcode`\p=12\catcode`\t=12\gdef\Pgffor@geT#1pt{#1}} \def\pgffor@doloop{% - \begingroup% + \pgffor@begingroup \edef\pgffor@temp{\expandafter\Pgffor@geT\the\pgffor@iter}% \edef\pgffor@incheck{{.0/}{\pgffor@temp/}}% \expandafter\pgfutil@in@\pgffor@incheck% @@ -221,16 +350,392 @@ \expandafter\def\expandafter\pgffor@valuerest\expandafter{\pgffor@temp//\relax}% \expandafter\pgffor@multiassign\pgffor@var/\pgffor@stop/\pgffor@stop/\relax% \else% - \expandafter\expandafter\expandafter\def\expandafter\pgffor@var\expandafter{\pgffor@temp}% + % Convert to alphabetic sequence, if necessary. + \ifpgffor@alphabeticsequence% + \pgffor@makealphabetic\pgffor@temp% + \expandafter\let\pgffor@var=\pgffor@temp% + \else% + \expandafter\expandafter\expandafter\def\expandafter\pgffor@var\expandafter{\pgffor@temp}% + \fi% \fi% + % Insert any context, if any. + \ifpgffor@context% + \let\pgffor@temp=\pgffor@dots@pre% + \expandafter\pgfutil@append@macrotomacro\expandafter% + {\expandafter\pgffor@temp\expandafter}\expandafter{\pgffor@var}% + \expandafter\pgfutil@append@macrotomacro\expandafter% + {\expandafter\pgffor@temp\expandafter}\expandafter{\pgffor@dots@post}% + \expandafter\let\pgffor@var=\pgffor@temp% + \fi% + % Perform assignments before loop body. + \ifx\pgffor@assign@before@code\pgfutil@empty% + \else% + \pgffor@assign@before@code% + \fi% + % \expandafter\pgffor@beginhook\pgffor@body\pgffor@endhook% - \endgroup% + % + % Perform assignments after loop body. + \ifx\pgffor@assign@after@code\pgfutil@empty% + \else% + \pgffor@assign@after@code% + \fi% + \pgffor@endgroup% \pgffor@loop% } \def\pgffor@strip#1.0{\def\pgffor@temp{#1}} - \def\breakforeach{\global\pgffor@continuefalse} +\def\pgffor@gobbletil@pgffor@@stop#1\pgffor@@stop{} + + +\newif\ifpgffor@registeriscount + +\def\pgffor@ifcsregister#1{% + \expandafter\pgffor@@ifcsregister\meaning#1\pgffor@stop} + +\def\pgffor@@ifcsregister#1#2#3#4#5\pgffor@stop{% + \if#1m% It is an ordinary (m)acro. + \pgffor@registeriscountfalse% + \let\pgffor@csnext=\pgfutil@secondoftwo% + \else% + \if#1u% It is (u)ndefined. + \let\pgffor@csnext=\pgfutil@secondoftwo% + \pgffor@registeriscountfalse% + \else% + \let\pgffor@csnext=\pgfutil@firstoftwo% + \if#4u% It is a co(u)nt + \pgffor@registeriscounttrue% + \else% Assume it is a dimen or skip (bad assumption in the general case). + \pgffor@registeriscountfalse% + \let\pgffor@csnext=\pgfutil@firstoftwo% + \fi% + \fi% + \fi% + \pgffor@csnext} + +\newif\ifpgffor@alphabeticsequence + +% +\def\pgffor@dots@charcheck#1\pgffor@@stop{% + \edef\pgffor@dots@charcheck@temp{#1}% + \expandafter\expandafter\expandafter\pgffor@@dotscharcheck\expandafter\meaning\pgffor@dots@charcheck@temp\pgffor@@stop% +} +\def\pgffor@@dotscharcheck#1#2\pgffor@@stop{% + \if#1t% + \afterassignment\pgffor@gobbletil@pgffor@@stop% + \expandafter\chardef\expandafter\pgffor@char\expandafter=\expandafter`\pgffor@dots@charcheck@temp\relax\pgffor@@stop% + \edef\pgffor@char{\the\pgffor@char}% + \ifnum\pgffor@char>64\relax% From A-Z? + \ifnum\pgffor@char<91\relax% + \let\pgffor@dotsvalue=\pgffor@char% + \pgffor@alphabeticsequencetrue% + \else% + \ifnum\pgffor@char>96\relax% From a-z? + \ifnum\pgffor@char<123\relax% + \let\pgffor@dotsvalue=\pgffor@char% + \pgffor@alphabeticsequencetrue% + \fi% + \fi% + \fi% + \fi% + \fi% +} + +\def\pgffor@makealphabetic#1{% + % Convert the number in the macro passed as #1 to a-z or A-Z. + \pgfutil@tempcnta=#1\relax% + \ifnum\pgfutil@tempcnta>95\relax% + \advance\pgfutil@tempcnta by-96% + \expandafter\def\expandafter#1\expandafter% + {\pgffor@alpha\pgfutil@tempcnta}% + \else% + \advance\pgfutil@tempcnta by-64% + \expandafter\def\expandafter#1\expandafter% + {\pgffor@Alpha\pgfutil@tempcnta}% + \fi% +} + +\def\pgffor@Alpha#1{% + \ifcase#1\or A\or B\or C\or D\or E\or F\or G\or H\or I\or J\or K\or L\or M% + \or N\or O\or P\or Q\or R\or S\or T\or U\or V\or W\or X\or Y\or Z\else?\fi% +} + +\def\pgffor@alpha#1{% + \ifcase#1\or a\or b\or c\or d\or e\or f\or g\or h\or i\or j\or k\or l\or m% + \or n\or o\or p\or q\or r\or s\or t\or u\or v\or w\or x\or y\or z\else?\fi% +} + +\newtoks\pgffor@toks + +\def\pgffor@addcstotoks#1{% + \expandafter\def\expandafter\pgffor@tokstemp\expandafter{\expandafter\def\expandafter#1\expandafter{#1}}% + \pgffor@@addcstotoks} + +\def\pgffor@addregtotoks#1{% + \expandafter\def\expandafter\pgffor@tokstemp\expandafter{\expandafter#1\expandafter=\the#1}% + \pgffor@@addcstotoks} + +\def\pgffor@addiftotoks#1{% + \begingroup% + \escapechar=-1\relax% + \expandafter\pgffor@@addiftotoks\string#1\pgffor@stop} +\def\pgffor@@addiftotoks#1#2#3#4#5\pgffor@stop{% + \endgroup + \csname if#4#5\endcsname% + \expandafter\def\expandafter\pgffor@tokstemp\expandafter{\csname#4#5true\endcsname}% + \else% + \expandafter\def\expandafter\pgffor@tokstemp\expandafter{\csname#4#5false\endcsname}% + \fi% + \pgffor@@addcstotoks% +} + +\def\pgffor@@addcstotoks{% + \expandafter\expandafter\expandafter\pgffor@toks\expandafter\expandafter\expandafter=% + \expandafter\expandafter\expandafter{\expandafter\pgffor@tokstemp\the\pgffor@toks}% +} + +% Set up the pgffor scopes. + +\def\pgffor@atbeginforeach{% + \begingroup% +} + +\def\pgffor@atendforeach{% + \global\edef\pgffor@remember@expanded{\pgffor@remember@code}% + \endgroup% + \ifx\pgffor@remember@expanded\pgfutil@empty% + \else% + \pgffor@remember@expanded% + \global\let\pgffor@remember@expanded=\pgfutil@empty% + \fi% +} +\def\pgffor@default@begingroup{% + \begingroup% +} + +\let\pgffor@remember@once@expanded=\pgfutil@empty +\let\pgffor@remember@expanded=\pgfutil@empty + +\def\pgffor@default@endgroup{% + \ifx\pgffor@assign@once@code\pgfutil@empty% + \else% + \global\edef\pgffor@remember@once@expanded{\pgffor@remember@once@code}% + \fi% + \ifx\pgffor@remember@code\pgfutil@empty% + \else% + \global\edef\pgffor@remember@expanded{\pgffor@remember@code}% + \fi% + \endgroup% + % + \ifx\pgffor@remember@once@expanded\pgfutil@empty% + \else% + \pgffor@remember@once@expanded% + \let\pgffor@assign@once@code=\pgfutil@empty% + \global\let\pgffor@remember@once@expanded=\pgfutil@empty% + \fi% + % + \ifx\pgffor@remember@expanded\pgfutil@empty% + \else% + \pgffor@remember@expanded% + \global\let\pgffor@remember@expanded=\pgfutil@empty% + \fi% +} + +\let\pgffor@begingroup=\pgffor@default@begingroup +\let\pgffor@endgroup=\pgffor@default@endgroup + + +\def\pgffor@stack@begingroup{% + \pgffor@toks={}% + \pgffor@addcstotoks{\pgffor@mainvar}% + \pgffor@addcstotoks{\pgffor@var}% + \pgffor@addcstotoks{\pgffor@body}% + % + \pgffor@addcstotoks{\pgffor@last}% + \pgffor@addcstotoks{\pgffor@prevlast}% + \pgffor@addcstotoks{\pgffor@dotsend}% + % + \pgffor@addcstotoks{\pgffor@assign@before@code}% + \pgffor@addcstotoks{\pgffor@assign@after@code}% + \pgffor@addcstotoks{\pgffor@remember@code}% + \pgffor@addcstotoks{\pgffor@remember@once@code}% + \pgffor@addcstotoks{\pgffor@dots@pre}% + \pgffor@addcstotoks{\pgffor@dots@post}% + % + \pgffor@addregtotoks{\pgffor@iter}% + \pgffor@addregtotoks{\pgffor@skip}% + % + \pgffor@addiftotoks{\ifpgffor@alphabeticsequence}% + \pgffor@addiftotoks{\ifpgffor@context}% + \expandafter\pgffor@stackpush\expandafter{\the\pgffor@toks}% +} + +\def\pgffor@stack@endgroup{\pgffor@stackpop} + +% Keys stuff. + +\newif\ifpgffor@assign@evaluate +\newif\ifpgffor@assign@once + +\pgfkeys{/pgf/foreach/.cd, + var/.code=\pgffor@var@add#1\pgffor@stop, + scope iterations/.code={ + \csname if#1\endcsname% + \let\pgffor@begingroup=\pgffor@default@begingroup% + \let\pgffor@endgroup=\pgffor@default@endgroup% + \else% + \let\pgffor@begingroup=\pgffor@stack@begingroup% + \let\pgffor@endgroup=\pgffor@stack@endgroup% + \fi% + }, + evaluate/.code=\pgffor@assign@evaluatetrue\pgffor@assign@oncefalse\pgffor@assign@parse{#1},% + assign/.code=\pgffor@assign@evaluatefalse\pgffor@assign@oncefalse\pgffor@assign@parse{#1},% + evaluate once/.code=\pgffor@assign@evaluatetrue\pgffor@assign@oncetrue\pgffor@assign@parse{#1},% + assign once/.code=\pgffor@assign@evaluatefalse\pgffor@assign@oncetrue\pgffor@assign@parse{#1},% + remember/.code=\pgffor@remember@parse{#1},% + count/.code=\pgffor@count@parse#1\pgffor@stop +} + +\def\pgffor@assign@parse#1{% + \pgfutil@in@;{#1}% + \ifpgfutil@in@% + \else% + \pgfutil@in@={#1}% + \fi% + \ifpgfutil@in@% + \pgffor@assign@@parse#1;\pgffor@stop;% + \else% + \pgffor@assign@parse@old#1\pgffor@stop%% + \fi% +} + +\def\pgffor@stop{\pgffor@stop} +\def\pgffor@assign@@parse#1;{% + \def\pgffor@test{#1}% + \ifx\pgffor@test\pgffor@stop% + \let\pgffor@next=\relax% + \else% + \let\pgffor@next=\pgffor@assign@@parse% + \ifx\pgffor@test\pgfutil@empty% + \else% + \pgfutil@in@={#1}% + \ifpgfutil@in@% + \pgffor@assign@@@parse#1\pgffor@stop% + \else% + \pgffor@assign@@@parse#1=#1\pgffor@stop% + \fi% + \fi% + \fi% + \pgffor@next} + +\def\pgffor@assign@@@parse#1=#2\pgffor@stop{% + \ifpgffor@assign@evaluate% + \ifpgffor@assign@once% + \pgfutil@append@tomacro{\pgffor@assign@once@code}{\pgfmathparse{#2}\let#1=\pgfmathresult}% + \pgfutil@append@tomacro{\pgffor@remember@once@code}{\noexpand\def\noexpand#1{#2}}% + \else + \pgfutil@append@tomacro{\pgffor@assign@before@code}{\pgfmathparse{#2}\let#1=\pgfmathresult}% + \fi% + \else% + \ifpgffor@assign@once% + \pgfutil@append@tomacro{\pgffor@assign@once@code}{\def#1{#2}}% + \pgfutil@append@tomacro{\pgffor@remember@once@code}{\noexpand\def\noexpand#1{#2}}% + \else + \pgfutil@append@tomacro{\pgffor@assign@before@code}{\def#1{#2}}% + \fi% + \fi% +} + +\def\pgffor@assign@parse@old#1#2\pgffor@stop{% + \pgffor@assign@@parse@old#2\pgffor@stop as#1using #1\pgffor@@stop} + +\def\pgffor@assign@@parse@old#1as#2#3\pgffor@@stop{% + \pgffor@assign@@@parse@old{#2}#1#3\pgffor@stop\pgffor@@stop} + +\def\pgffor@assign@@@parse@old#1#2using #3\pgffor@stop#4\pgffor@@stop{% + \pgffor@assign@@@parse#1=#3\pgffor@stop} + + + +\def\pgffor@remember@parse#1{% + \pgfutil@in@ a{#1}% This matches the 'a' in 'as' or 'intially'. + \ifpgfutil@in@% + \pgffor@remember@parse@old#1\pgffor@stop% + \else% + \pgffor@remember@@parse#1;\pgffor@stop;% + \fi% +} + +\def\pgffor@remember@@parse#1;{% + \def\pgffor@test{#1}% + \ifx\pgffor@test\pgffor@stop% + \let\pgffor@next=\relax% + \else% + \let\pgffor@next=\pgffor@remember@@parse% + \ifx\pgffor@test\pgfutil@empty% + \else% + \pgfutil@in@={#1}% + \ifpgfutil@in@% + \pgffor@remember@@@parse#1\pgffor@stop% + \else% + \pgffor@ifcsregister{#1}{% + \pgfutil@append@tomacro{\pgffor@remember@code}{\noexpand#1=\the#1\noexpand\relax}% + }% + {% + \pgfutil@append@tomacro{\pgffor@remember@code}{\noexpand\def\noexpand#1{#1}}% + }% + \fi% + \fi% + \fi% + \pgffor@next% +} + +\def\pgffor@remember@@@parse#1=#2\pgffor@stop{% + \pgffor@ifcsregister{#2}{% + \pgfutil@append@tomacro{\pgffor@assign@after@code}{\expandafter\def\expandafter#1\expandafter{\the#2}}% + \pgfutil@append@tomacro{\pgffor@remember@code}{\noexpand\def\noexpand#1{#1}}% + }% + {% + \pgfutil@append@tomacro{\pgffor@assign@after@code}{\expandafter\def\expandafter#1\expandafter{#2}}% + \pgfutil@append@tomacro{\pgffor@remember@code}{\noexpand\def\noexpand#1{#1}}% + }% +} + +\def\pgffor@remember@parse@old#1#2\pgffor@stop{% + \pgffor@remember@@parse@old#1#2\pgffor@stop as#1(initially )\pgffor@@stop} + +\def\pgffor@remember@@parse@old#1#2as#3#4\pgffor@@stop{% + \pgffor@remember@@@parse@old{#1}{#3}#2#4\pgffor@stop\pgffor@@stop} + +\def\pgffor@remember@@@parse@old#1#2#3(initially #4)#5\pgffor@stop#6\pgffor@@stop{% + \pgfutil@append@tomacro{\pgffor@assign@after@code}{\edef#2{#1}}% + \pgfutil@append@tomacro{\pgffor@remember@code}{\noexpand\def\noexpand#2{#2}}% + \def\pgffor@test{#4}% + \ifx\pgffor@test\pgfutil@empty% + \else% + \pgfutil@append@tomacro{\pgffor@assign@once@code}{\def#2{#4}}% + \fi% +} + +\def\pgffor@count@parse#1#2\pgffor@stop{% + \pgffor@count@@parse#1#2\pgffor@stop from 1\pgffor@stop\pgffor@@stop} + +\def\pgffor@count@@parse#1#2from#3\pgffor@stop#4\pgffor@@stop{% + \pgfutil@append@tomacro\pgffor@remember@code{\noexpand\def\noexpand#1{#1}}% + \pgfutil@append@tomacro\pgffor@assign@before@code{\pgfmathparse{int(#1+1)}\let#1=\pgfmathresult}% + \pgfmathparse{int(#3-1)}\let#1=\pgfmathresult% +} + + +\def\pgfutil@append@macrotomacro#1#2{% + \expandafter\expandafter\expandafter\def\expandafter\expandafter\expandafter% + #1\expandafter\expandafter\expandafter{\expandafter#1#2}} + +\def\pgfutil@append@tomacro#1#2{% + \expandafter\def\expandafter#1\expandafter{#1#2}} + + \endinput diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex b/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex index dd660fd6ab7..86e0499ded7 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeys.code.tex @@ -8,7 +8,9 @@ % See the file doc/generic/pgf/licenses/LICENSE for more details. -% This file is perfectly self-contained, except that the catcode of @ should be made a letter. +% The files pgfkeys.code.tex and pgfkeysfiltered.code.tex are +% perfectly self-contained, except that the catcode of @ +% should be made a letter. % Guard against reading twice @@ -64,7 +66,7 @@ % \pgfkeyssetvalue{/tikz/length}{2cm-3cm} % \pgfkeyssetvalue{/algo/swap}{{#2}{#1}} -\def\pgfkeyssetvalue#1#2{% +\long\def\pgfkeyssetvalue#1#2{% \pgfkeys@temptoks{#2}\expandafter\edef\csname pgfk@#1\endcsname{\the\pgfkeys@temptoks}% } @@ -85,13 +87,13 @@ % % \pgfkeysaddvalue{/tikz/length}{}{-3cm} -\def\pgfkeysaddvalue#1#2#3{% +\long\def\pgfkeysaddvalue#1#2#3{% {% - \toks0{#1}% + \toks0{#2}% \pgfkeysifdefined{#1} {\pgfkeys@temptoks\expandafter\expandafter\expandafter{\csname pgfk@#1\endcsname}}% {\pgfkeys@temptoks{}}% - \toks1{#2}% + \toks1{#3}% \xdef\pgfkeys@global@temp{\the\toks0 \the\pgfkeys@temptoks \the\toks1}% believe or don't: the spaces are important }% \pgfkeyslet{#1}\pgfkeys@global@temp% @@ -169,8 +171,20 @@ % % \pgfkeysifdefined{/tikz/length}{key exists}{does not exist} -\def\pgfkeysifdefined#1#2#3{\pgfkeys@ifcsname pgfk@#1\endcsname#2\else#3\fi} +\long\def\pgfkeysifdefined#1#2#3{\pgfkeys@ifcsname pgfk@#1\endcsname#2\else#3\fi} +% Tests whether a key is assignable. For standard keys which just +% store their value, this is identical to \pgfkeysifdefined. +% +% But \pgfkeysifassignable is true for command keys as well (but not +% for handled keys). +\long\def\pgfkeysifassignable#1#2#3{% + \pgfkeysifdefined{#1}% + {#2} + {\pgfkeysifdefined{#1/.@cmd}% + {#2}% + {#3}}% +}% @@ -259,7 +273,7 @@ \let\pgfkeysdefaultpath\pgfkeys@root \def\pgfkeys{\expandafter\pgfkeys@@set\expandafter{\pgfkeysdefaultpath}}% -\def\pgfkeys@@set#1#2{% +\long\def\pgfkeys@@set#1#2{% \let\pgfkeysdefaultpath\pgfkeys@root% \pgfkeys@parse#2,\pgfkeys@mainstop% \def\pgfkeysdefaultpath{#1}} @@ -272,7 +286,7 @@ \expandafter\pgfkeys@normal% \fi% } -\def\pgfkeys@normal#1,{% +\long\def\pgfkeys@normal#1,{% \pgfkeys@unpack#1=\pgfkeysnovalue=\pgfkeys@stop% \pgfkeys@parse% } @@ -284,7 +298,7 @@ \def\pgfkeysnovalue@text{\pgfkeysnovalue} \def\pgfkeysvaluerequired{\pgfkeysvaluerequired} % equals only itself -\def\pgfkeys@unpack#1=#2=#3\pgfkeys@stop{% +\long\def\pgfkeys@unpack#1=#2=#3\pgfkeys@stop{% \pgfkeys@spdef\pgfkeyscurrentkey{#1}% \edef\pgfkeyscurrentkey{\pgfkeyscurrentkey}% \ifx\pgfkeyscurrentkey\pgfkeys@empty% @@ -326,6 +340,10 @@ } +% either handled key or unknown. +% +% This macro will be replaced by the /handler config/handle only existing +% configuration, see below. \def\pgfkeys@case@three{% \pgfkeys@split@path% \pgfkeysifdefined{/handlers/\pgfkeyscurrentname/.@cmd}% @@ -333,6 +351,80 @@ \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov} {\pgfkeys@unknown}% } +\let\pgfkeys@case@three@handleall=\pgfkeys@case@three +\def\pgfkeys@case@three@handle@restricted{% + \pgfkeys@split@path% + \pgfkeysifdefined{/handlers/\pgfkeyscurrentname/.@cmd}{% + \pgfkeys@ifexecutehandler{% + \pgfkeysgetvalue{/handlers/\pgfkeyscurrentname/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov + }{% + % this here is necessary: /my search path/key/.code + % won't be called, so \pgfkeyscurrentpath == '/my search path/key' + % -> it should be one directory higher! We want to invoke the + % .unknown handler in + % '/my search path' + % + % Idea: + % set + % - path := '/my search path' + % - name := 'key/.code' + % - key = '/my search path/key/.code' + \let\pgfkeys@temp=\pgfkeyscurrentkey + \let\pgfkeys@tempb=\pgfkeyscurrentname + \edef\pgfkeyscurrentkey{\pgfkeyscurrentpath}% + \pgfkeys@split@path% + \let\pgfkeyscurrentkey=\pgfkeys@temp + \edef\pgfkeyscurrentname{\pgfkeyscurrentname/\pgfkeys@tempb}% + \pgfkeys@unknown + }% + }{% + \pgfkeys@unknown + }% +} + +% this macro is to implement the |handly only existing| key in key filtering: +% #1: the code to invoke IF the key handler shall be executed +% #2: the code to invoke if it shall not run. +\def\pgfkeys@ifexecutehandler#1#2{#1}% +\let\pgfkeys@ifexecutehandler@handleall=\pgfkeys@ifexecutehandler +\def\pgfkeys@ifexecutehandler@handleonlyexisting#1#2{% + \pgfkeys@ifcsname pgfk@excpt@\pgfkeyscurrentname\endcsname% + #1% ok, this particular key handler is known and should be processed in any case (for example .try) + \else + % implement the 'only existing' feature here: + \pgfkeysifdefined{\pgfkeyscurrentpath}{#1}{% + \pgfkeysifdefined{\pgfkeyscurrentpath/.@cmd}{#1}{#2}% + }{}% + \fi% +}% +\def\pgfkeys@ifexecutehandler@handlefullorexisting#1#2{% + \ifpgfkeysaddeddefaultpath + \pgfkeys@ifcsname pgfk@excpt@\pgfkeyscurrentname\endcsname% +%\message{ifexecutehandler(\pgfkeyscurrentkeyRAW, path \pgfkeysdefaultpath): '\pgfkeyscurrentname' is an exception; processing it (on \pgfkeyscurrentpath).}% + #1% ok, this particular key handler is known and be processed in any case (for example .try) + \else + % implement the 'only existing' feature here: + \pgfkeysifdefined{\pgfkeyscurrentpath}{% +%\message{ifexecutehandler(\pgfkeyscurrentkeyRAW, path \pgfkeysdefaultpath): '\pgfkeyscurrentpath' does exist. Executing '\pgfkeyscurrentname'.}% + #1% + }{% + \pgfkeysifdefined{\pgfkeyscurrentpath/.@cmd}{% +%\message{ifexecutehandler(\pgfkeyscurrentkeyRAW, path \pgfkeysdefaultpath): '\pgfkeyscurrentpath/.@cmd' does exist. Executing '\pgfkeyscurrentname'.}% + #1% + }{% +%\message{ifexecutehandler(\pgfkeyscurrentkeyRAW, path \pgfkeysdefaultpath): '\pgfkeyscurrentpath' does NOT exist. Skipping '\pgfkeyscurrentname'.}% + #2% + }% + }% + \fi% + \else +%\message{ifexecutehandler(\pgfkeyscurrentkeyRAW, path \pgfkeysdefaultpath): Fully qualified key provided. Executing '\pgfkeyscurrentname'.}% + #1% ok, always true if the USER explicitly provided the full key path. + \fi +}% +\def\pgfkeysaddhandlyonlyexistingexception#1{\expandafter\def\csname pgfk@excpt@#1\endcsname{1}}% + \def\pgfkeys@unknown{% \pgfkeysifdefined{\pgfkeyscurrentpath/.unknown/.@cmd}% @@ -346,8 +438,8 @@ } -\def\pgfkey@argumentisspace#1{% - \def\pgfkeys@spdef##1##2{% +\long\def\pgfkey@argumentisspace#1{% + \long\def\pgfkeys@spdef##1##2{% \futurelet\pgfkeys@possiblespace\pgfkeys@sp@a##2\pgfkeys@stop\pgfkeys@stop#1\pgfkeys@stop\relax##1}% \def\pgfkeys@sp@a{% \ifx\pgfkeys@possiblespace\pgfkeys@sptoken% @@ -355,10 +447,10 @@ \else% \expandafter\pgfkeys@sp@b\expandafter#1% \fi}% - \def\pgfkeys@sp@b#1##1 \pgfkeys@stop{\pgfkeys@sp@c##1}% + \long\def\pgfkeys@sp@b#1##1 \pgfkeys@stop{\pgfkeys@sp@c##1}% } \pgfkey@argumentisspace{ } -\def\pgfkeys@sp@c#1\pgfkeys@stop#2\relax#3{\pgfkeys@temptoks{#1}\edef#3{\the\pgfkeys@temptoks}} +\long\def\pgfkeys@sp@c#1\pgfkeys@stop#2\relax#3{\pgfkeys@temptoks{#1}\edef#3{\the\pgfkeys@temptoks}} {\def\:{\global\let\pgfkeys@sptoken= } \: } @@ -367,6 +459,7 @@ % \pgfkeyscurrentkey does not start with / \expandafter\futurelet\expandafter\pgfkeys@possibleslash\expandafter\pgfkeys@check@slash\pgfkeyscurrentkey\relax% } +\newif\ifpgfkeysaddeddefaultpath \def\pgfkeys@check@slash{% \ifx\pgfkeys@possibleslash/% \expandafter\pgfkeys@nevermind% @@ -375,8 +468,16 @@ \fi% } -\def\pgfkeys@nevermind#1\relax{} -\def\pgfkeys@addpath#1\relax{\edef\pgfkeyscurrentkey{\pgfkeysdefaultpath#1}} +\def\pgfkeys@nevermind#1\relax{% + \pgfkeysaddeddefaultpathfalse + \let\pgfkeyscurrentkeyRAW\pgfkeyscurrentkey +} +\def\pgfkeys@addpath#1\relax{% + \pgfkeysaddeddefaultpathtrue + \def\pgfkeyscurrentkeyRAW{#1}% + \edef\pgfkeyscurrentkey{\pgfkeysdefaultpath#1}% +} + \def\pgfkeys@split@path{% Should assign the two codes % \pgfkeyscurrentname and \pgfcurrentlkeypath @@ -417,7 +518,7 @@ % \pgfqkeys{/tikz}{myother length/.code=\def\myotherlength{#1}\pgfkeysalso{length=#1}} \def\pgfqkeys{\expandafter\pgfkeys@@qset\expandafter{\pgfkeysdefaultpath}}% -\def\pgfkeys@@qset#1#2#3{\def\pgfkeysdefaultpath{#2/}\pgfkeys@parse#3,\pgfkeys@mainstop\def\pgfkeysdefaultpath{#1}} +\long\def\pgfkeys@@qset#1#2#3{\def\pgfkeysdefaultpath{#2/}\pgfkeys@parse#3,\pgfkeys@mainstop\def\pgfkeysdefaultpath{#1}} % Sets keys while setting keys @@ -434,7 +535,7 @@ % % \pgfkeys{tikz,myother length/.code=\def\myotherlength{#1}\pgfkeysalso{length=#1}} -\def\pgfkeysalso#1{\pgfkeys@parse#1,\pgfkeys@mainstop} +\long\def\pgfkeysalso#1{\pgfkeys@parse#1,\pgfkeys@mainstop} @@ -454,7 +555,7 @@ % \begingroup % \pgfqkeysalso{/tikz}{myother length/.code=\def\myotherlength{#1}\pgfkeysalso{length=#1}} -\def\pgfqkeysalso#1#2{\def\pgfkeysdefaultpath{#1/}\pgfkeys@parse#2,\pgfkeys@mainstop} +\long\def\pgfqkeysalso#1#2{\def\pgfkeysdefaultpath{#1/}\pgfkeys@parse#2,\pgfkeys@mainstop} @@ -475,12 +576,12 @@ % % \pgfkeysdef{/my key}{\show#1} -\def\pgfkeysdef#1#2{% - \def\pgfkeys@temp##1\pgfeov{#2}% +\long\def\pgfkeysdef#1#2{% + \long\def\pgfkeys@temp##1\pgfeov{#2}% \pgfkeyslet{#1/.@cmd}{\pgfkeys@temp}% } -\def\pgfkeysedef#1#2{% - \edef\pgfkeys@temp##1\pgfeov{#2}% +\long\def\pgfkeysedef#1#2{% + \long\edef\pgfkeys@temp##1\pgfeov{#2}% \pgfkeyslet{#1/.@cmd}{\pgfkeys@temp}% } @@ -500,19 +601,98 @@ % % \pgfkeysdefargs{/swap}{#1#2}{#2#1} -\def\pgfkeysdefargs#1#2#3{% - \def\pgfkeys@temp#2\pgfeov{#3}% +\long\def\pgfkeysdefargs#1#2#3{% + \long\def\pgfkeys@temp#2\pgfeov{#3}% \pgfkeyslet{#1/.@cmd}{\pgfkeys@temp}% \pgfkeyssetvalue{#1/.@args}{#2\pgfeov}% \pgfkeyssetvalue{#1/.@body}{#3}% } -\def\pgfkeysedefargs#1#2#3{% - \edef\pgfkeys@temp#2\pgfeov{#3}% +\long\def\pgfkeysedefargs#1#2#3{% + \long\edef\pgfkeys@temp#2\pgfeov{#3}% \pgfkeyslet{#1/.@cmd}{\pgfkeys@temp}% \pgfkeyssetvalue{#1/.@args}{#2\pgfeov}% \pgfkeyssetvalue{#1/.@body}{#3}% } +% Like \pgfkeysdefargs, but `#2' is an integer denoting the expected +% *number* of arguments. +% +% There is a subtle difference between the 'args' command, when it +% comes to spaces: +% a key defined with defargs{#1#2} must not have spaces between the +% arguments when it is used. +% +% See this: +% +%-------------------------------------------------- +% % defnargs: +% \pgfkeysdefnargs{/a}{2}{1=`#1', 2=`#2'} +% \pgfkeys{ +% /a= +% {1} +% {2} +% } +% ->defnargs: 1=`1', 2=`2' +% +% defargs: +% \pgfkeysdefargs{/b}{#1#2}{1=`#1', 2=`#2'} +% \pgfkeys{ +% /b= +% {1} +% {2} +% } +% ->defargs: 1=`1', 2=` 2' (note the space!) +% +% defargs: +% \pgfkeysdefargs{/b}{#1#2}{1=`#1', 2=`#2'} +% \pgfkeys{ +% /b= +% {1}% +% {2} +% } +% ->defargs: 1=`1', 2=`2' +%-------------------------------------------------- +\long\def\pgfkeysdefnargs#1#2#3{\pgfkeysdefnargs@{#1}{#2}{#3}{\def}}% +\long\def\pgfkeysedefnargs#1#2#3{\pgfkeysdefnargs@{#1}{#2}{#3}{\edef}}% +\long\def\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}% +} + % Defining a key command @@ -521,8 +701,10 @@ \pgfkeysdef{/handlers/.code 2 args}{\pgfkeysdefargs{\pgfkeyscurrentpath}{##1##2}{#1}} \pgfkeysdef{/handlers/.ecode}{\pgfkeysedef{\pgfkeyscurrentpath}{#1}} \pgfkeysdef{/handlers/.ecode 2 args}{\pgfkeysedefargs{\pgfkeyscurrentpath}{##1##2}{#1}} -\pgfkeysdefargs{/handlers/.code args}{#1#2}{\pgfkeysdefargs{\pgfkeyscurrentpath}{#1}{#2}} -\pgfkeysdefargs{/handlers/.ecode args}{#1#2}{\pgfkeysedefargs{\pgfkeyscurrentpath}{#1}{#2}} +\pgfkeysdefnargs{/handlers/.code args}{2}{\pgfkeysdefargs{\pgfkeyscurrentpath}{#1}{#2}} +\pgfkeysdefnargs{/handlers/.ecode args}{2}{\pgfkeysedefargs{\pgfkeyscurrentpath}{#1}{#2}} +\pgfkeysdefnargs{/handlers/.code n args}{2}{\pgfkeysdefnargs{\pgfkeyscurrentpath}{#1}{#2}} +\pgfkeysdefnargs{/handlers/.ecode n args}{2}{\pgfkeysedefnargs{\pgfkeyscurrentpath}{#1}{#2}} % Adding to a key command @@ -530,22 +712,31 @@ % Find out, whether with args or not. \pgfkeysifdefined{\pgfkeyscurrentpath/.@args}% {% Yes, so add to body and reuse args - \pgfkeysaddvalue{\pgfkeyscurrentpath/.@body}{#1}{#2}% - % Redefine code - \pgfkeysgetvalue{\pgfkeyscurrentpath/.@args}{\pgfkeys@tempargs} - \pgfkeysgetvalue{\pgfkeyscurrentpath/.@body}{\pgfkeys@tempbody} - \expandafter\expandafter\expandafter\def\expandafter\pgfkeys@temp\expandafter\pgfkeys@tempargs\expandafter{\pgfkeys@tempbody}% - \pgfkeyslet{\pgfkeyscurrentpath/.@cmd}{\pgfkeys@temp}% + \pgfkeysaddvalue{\pgfkeyscurrentpath/.@body}{#1}{#2}% + % Redefine code + {% + \pgfkeysgetvalue{\pgfkeyscurrentpath/.@args}{\pgfkeys@tempargs}% + \pgfkeysgetvalue{\pgfkeyscurrentpath/.@body}{\pgfkeys@tempbody}% + \def\pgfkeys@marshal{\expandafter\gdef\expandafter\pgfkeys@global@temp\pgfkeys@tempargs}% + \expandafter\pgfkeys@marshal\expandafter{\pgfkeys@tempbody}% + }% + \pgfkeysifdefined{\pgfkeyscurrentpath/.@@body}{% + % support for \pgfkeysndefargs: + \pgfkeyslet{\pgfkeyscurrentpath/.@@body}{\pgfkeys@global@temp}% + }{% + % support for \pgfkeysdefargs: + \pgfkeyslet{\pgfkeyscurrentpath/.@cmd}{\pgfkeys@global@temp}% + }% }% {% - % No, so single argument. Redefine accordingly. + % No, so single argument (simple \pgfkeysdef). Redefine accordingly. {% \toks0{#1}% \pgfkeysifdefined{\pgfkeyscurrentpath/.@cmd}% {\pgfkeys@temptoks\expandafter\expandafter\expandafter{\csname pgfk@\pgfkeyscurrentpath/.@cmd\endcsname##1\pgfeov}}% {\pgfkeys@temptoks{}}% \toks1{#2}% - \xdef\pgfkeys@global@temp{\the\toks0 \the\pgfkeys@temptoks \the\toks1}% + \xdef\pgfkeys@global@temp{\the\toks0 \the\pgfkeys@temptoks \the\toks1 }% }% \expandafter\def\expandafter\pgfkeys@temp\expandafter##\expandafter1\expandafter\pgfeov\expandafter{\pgfkeys@global@temp}% \pgfkeyslet{\pgfkeyscurrentpath/.@cmd}\pgfkeys@temp% @@ -562,6 +753,7 @@ \pgfkeys{/handlers/.style args/.code 2 args=\pgfkeys{\pgfkeyscurrentpath/.code args={#1}{\pgfkeysalso{#2}}}} \pgfkeys{/handlers/.estyle args/.code 2 args=\pgfkeys{\pgfkeyscurrentpath/.ecode args={#1}{\noexpand\pgfkeysalso{#2}}}} \pgfkeys{/handlers/.style 2 args/.code=\pgfkeys{\pgfkeyscurrentpath/.code 2 args=\pgfkeysalso{#1}}} +\pgfkeys{/handlers/.style n args/.code 2 args=\pgfkeys{\pgfkeyscurrentpath/.code n args={#1}{\pgfkeysalso{#2}}}} % Adding to a style @@ -574,7 +766,11 @@ \pgfkeys{/handlers/.initial/.code=\pgfkeyssetvalue{\pgfkeyscurrentpath}{#1}} \pgfkeys{/handlers/.add/.code 2 args=\pgfkeysaddvalue{\pgfkeyscurrentpath}{#1}{#2}} +\pgfkeys{/handlers/.prefix/.code=\pgfkeysaddvalue{\pgfkeyscurrentpath}{#1}{}} +\pgfkeys{/handlers/.append/.code=\pgfkeysaddvalue{\pgfkeyscurrentpath}{}{#1}} \pgfkeys{/handlers/.get/.code=\pgfkeysgetvalue{\pgfkeyscurrentpath}{#1}} +\pgfkeys{/handlers/.link/.code=\pgfkeyssetvalue{\pgfkeyscurrentpath}{\pgfkeysvalueof{#1}}} + % Defining a default @@ -614,6 +810,26 @@ .unknown/.style={/errors/unknown choice value=\pgfkeyscurrentkey\pgfkeyscurrentvalue}}} +% Repeatedly setting a key + +\pgfkeys{/handlers/.list/.code=% + {% + % Use foreach to unfold the list + \let\pgf@keys@temp=\pgfutil@empty% + \foreach \pgf@keys@key in{#1}% + {\expandafter\expandafter\expandafter\gdef% + \expandafter\expandafter\expandafter\pgf@keys@temp% + \expandafter\expandafter\expandafter{\expandafter\pgf@keys@temp\expandafter{\pgf@keys@key}}}% + \edef\pgf@keys@list@path{\pgfkeyscurrentpath}% + \expandafter\expandafter\expandafter\pgf@keys@do@list% + \expandafter\expandafter\expandafter{\expandafter\pgf@keys@list@path\expandafter}\pgf@keys@temp\pgf@stop% + }% +} +\def\pgf@keys@do@list#1{\pgfutil@ifnextchar\bgroup{\pgf@keys@do@list@item{#1}}\pgfutil@gobble} +\def\pgf@keys@do@list@item#1#2{\pgfkeysalso{#1={#2}}\pgf@keys@do@list{#1}} + + + % Inspection handlers \pgfkeys{/handlers/.show value/.code=\pgfkeysgetvalue{\pgfkeyscurrentpath}{\pgfkeysshower}\show\pgfkeysshower} % inspect the value @@ -622,8 +838,65 @@ % Path handling -\pgfkeys{/handlers/.is family/.code=\pgfkeys{\pgfkeyscurrentpath/.ecode=\edef\noexpand\pgfkeysdefaultpath{\pgfkeyscurrentpath/}}} -\pgfkeys{/handlers/.cd/.code=\edef\pgfkeysdefaultpath{\pgfkeyscurrentpath/}} +% Prepares the .unknown handler used by '.search also'. +% It will be stored into \pgfkeys@global@temp. +\def\pgfkeys@searchalso@prepare@unknown@handler#1{% + \global\def\pgfkeys@global@temp##1\pgfeov{}% + \pgfkeys@searchalso@parse#1,\pgfkeys@mainstop + {% + \toks0=\expandafter{\pgfkeys@global@temp##1\pgfeov}% + \toks1={\def\pgfutilnext{\pgfkeysvalueof{/handlers/.unknown/.@cmd}##1\pgfeov}\pgfutilnext}% + \xdef\pgfkeys@global@temp{% + \noexpand\ifpgfkeysaddeddefaultpath + \noexpand\pgfkeyssuccessfalse + \noexpand\let\noexpand\pgfkeys@searchalso@name=\noexpand\pgfkeyscurrentkeyRAW + \the\toks0 % one or more /.try things; one for each path. The last element won't have a /.try + %\noexpand\ifpgfkeyssuccess + %\noexpand\else + % \the\toks1 % invoke /handlers/.unknown handler + %\noexpand\fi + \noexpand\else + \the\toks1 % invoke /handlers/.unknown handler + \noexpand\fi + }% + \expandafter\gdef\expandafter\pgfkeys@global@temp\expandafter##\expandafter1\expandafter\pgfeov\expandafter{\pgfkeys@global@temp}% + }% +}% + +\def\pgfkeys@searchalso@parse{\futurelet\pgfkeys@possiblerelax\pgfkeys@searchalso@parse@main} +\def\pgfkeys@searchalso@parse@main{% + \ifx\pgfkeys@possiblerelax\pgfkeys@mainstop% + \expandafter\pgfkeys@cleanup% + \else% + \expandafter\pgfkeys@searchalso@appendentry% + \fi% +} +\def\pgfkeys@searchalso@appendentry#1,#2{% + \def\pgfkeys@searchalso@nexttok{#2}% + \pgfkeys@spdef\pgfkeys@temp{#1}% + {% + \toks0=\expandafter{\pgfkeys@global@temp##1\pgfeov}% + \toks1=\expandafter{\pgfkeys@temp}% + \toks2={##1}% + \xdef\pgfkeys@global@temp{% + \the\toks0 % the space is important! + \noexpand\ifpgfkeyssuccess\noexpand\else + \noexpand\pgfqkeys{\the\toks1 }{\noexpand\pgfkeys@searchalso@name + \ifx\pgfkeys@searchalso@nexttok\pgfkeys@mainstop\else/.try\fi={\the\toks2 }}% + \noexpand\fi}% + \expandafter\gdef\expandafter\pgfkeys@global@temp\expandafter##\expandafter1\expandafter\pgfeov\expandafter{\pgfkeys@global@temp}% + }% + \pgfkeys@searchalso@parse#2% +} +\pgfkeys{% + /handlers/.is family/.code=\pgfkeys{\pgfkeyscurrentpath/.ecode=\edef\noexpand\pgfkeysdefaultpath{\pgfkeyscurrentpath/}},% + /handlers/.cd/.code=\edef\pgfkeysdefaultpath{\pgfkeyscurrentpath/},% + /handlers/.search also/.code={% + \pgfkeys@searchalso@prepare@unknown@handler{#1}% +%\message{I prepared the '\pgfkeyscurrentpath/.unknown' handler \meaning\pgfkeys@global@temp\space for '#1'.}% + \pgfkeyslet{\pgfkeyscurrentpath/.unknown/.@cmd}{\pgfkeys@global@temp}% + } +}% % Value expansion @@ -632,7 +905,7 @@ \pgfkeys{/handlers/.expand twice/.code=\expandafter\expandafter\expandafter\pgfkeys@exp@call\expandafter\expandafter\expandafter{#1}} \pgfkeys{/handlers/.expanded/.code=\edef\pgfkeys@temp{#1}\expandafter\pgfkeys@exp@call\expandafter{\pgfkeys@temp}} -\def\pgfkeys@exp@call#1{\pgfkeysalso{\pgfkeyscurrentpath=#1}} +\def\pgfkeys@exp@call#1{\pgfkeysalso{\pgfkeyscurrentpath={#1}}} % Try to set a key and do nothing if not define @@ -640,14 +913,15 @@ \pgfkeys{/handlers/.try/.code=\pgfkeys@try} \pgfkeys{/handlers/.retry/.code=\ifpgfkeyssuccess\else\pgfkeys@try\fi} \def\pgfkeys@try{% + \edef\pgfkeyscurrentkey{\pgfkeyscurrentpath}% make sure that \pgfkeys@code doesn't know about 'try'. Important for .is choice + \ifx\pgfkeyscurrentvalue\pgfkeysnovalue@text% Hmm... no value + \pgfkeysifdefined{\pgfkeyscurrentpath/.@def}% + {\pgfkeysgetvalue{\pgfkeyscurrentpath/.@def}{\pgfkeyscurrentvalue}} + {}% no default, so leave it + \fi% \pgfkeysifdefined{\pgfkeyscurrentpath/.@cmd}% {% \pgfkeysgetvalue{\pgfkeyscurrentpath/.@cmd}{\pgfkeys@code}% - \ifx\pgfkeyscurrentvalue\pgfkeysnovalue@text% Hmm... no value - \pgfkeysifdefined{\pgfkeyscurrentpath/.@def}% - {\pgfkeysgetvalue{\pgfkeyscurrentpath/.@def}{\pgfkeyscurrentvalue}} - {}% no default, so leave it - \fi% \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov% \pgfkeyssuccesstrue% }% @@ -661,7 +935,23 @@ \fi% \pgfkeyssuccesstrue% }% - {\pgfkeyssuccessfalse}% + {% + \pgfkeys@split@path% + \pgfkeysifdefined{/handlers/\pgfkeyscurrentname/.@cmd}{% + % in the standard configuration, this check here is redundand + % because pgfkeys@ifexecutehandler === true. + % It is only interesting for 'handle only existing'. + \pgfkeys@ifexecutehandler{% + \pgfkeysgetvalue{/handlers/\pgfkeyscurrentname/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov + \pgfkeyssuccesstrue% + }{% + \pgfkeyssuccessfalse + }% + }{% + \pgfkeyssuccessfalse + }% + }% }% } @@ -694,6 +984,29 @@ } } - +\pgfkeys{ + /handler config/.is choice, + /handler config/all/.code={% + \let\pgfkeys@case@three=\pgfkeys@case@three@handleall + \let\pgfkeys@ifexecutehandler=\pgfkeys@ifexecutehandler@handleall + }, + /handler config/only existing/.code={% + \let\pgfkeys@case@three=\pgfkeys@case@three@handle@restricted + \let\pgfkeys@ifexecutehandler=\pgfkeys@ifexecutehandler@handleonlyexisting + }, + /handler config/full or existing/.code={% + \let\pgfkeys@case@three=\pgfkeys@case@three@handle@restricted + \let\pgfkeys@ifexecutehandler=\pgfkeys@ifexecutehandler@handlefullorexisting + }, + /handler config/only existing/add exception/.code={\pgfkeysaddhandlyonlyexistingexception{#1}}, +}% +\pgfkeysaddhandlyonlyexistingexception{.cd}% +\pgfkeysaddhandlyonlyexistingexception{.try}% +\pgfkeysaddhandlyonlyexistingexception{.retry}% +\pgfkeysaddhandlyonlyexistingexception{.lastretry}% +\pgfkeysaddhandlyonlyexistingexception{.unknown}% + + +\input pgfkeysfiltered.code.tex \endinput diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.tex b/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.tex new file mode 100644 index 00000000000..c46e418ddad --- /dev/null +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfkeysfiltered.code.tex @@ -0,0 +1,1016 @@ +% Copyright 2008 by Christian Feuersaenger +% +% This file may be distributed and/or modified +% +% 1. under the LaTeX Project Public License and/or +% 2. under the GNU Public License. +% +% See the file doc/generic/pgf/licenses/LICENSE for more details. +% +% This file contains additions to pgfkeys.code.tex (loaded +% automatically at the end of pgfkeys.code.tex) +% +% Improvements: +% +% - option filtering +% you provide +% - a boolean predicate +% - a "filter handler" which will be invoked for non-matching options, +% - a key=value list as usual. +% The filter sets only matching options and invokes the handler for +% unmatching ones. +% +% - Fast family support as in xkeyval. +% - A key like /my tree/my option can be associated with /my family +% - You can efficiently set keys which belong to a set of "active" +% families. +% Remaining options can be collected into a macro. + +% WARNING: +% this file overwrites +% \pgfkeys@addpath +% \pgfkeys@nevermind +% +% all other features are 'additive' + + +% these implementations will be switched dynamically with their +% filtered versions (in \pgfkeys@install@filter@and@invoke) +\let\pgfkeys@orig@case@one=\pgfkeys@case@one +\let\pgfkeys@orig@@set=\pgfkeys@@set +\let\pgfkeys@orig@@qset=\pgfkeys@@qset +\let\pgfkeys@orig@try=\pgfkeys@try +\let\pgfkeys@orig@unknown=\pgfkeys@unknown + +\newif\ifpgfkeysfilteringisactive +\newif\ifpgfkeysfiltercontinue +\let\pgfkeys@key@predicate=\pgfkeys@empty +\let\pgfkeys@filtered@handler=\pgfkeys@empty +\newtoks\pgfkeys@tmptoks + +% Performs 'filtered' key settings. +% +% For every option for which the path prefixing has already been done, +% the current key filter predicate will be invoked. If the predicate +% returns true, pgfkeys will process this key in the normal manner. +% If not, a key filter handler will be invoked. +% +% The *predicate* and *handler* semantics are as follows: +% PRECONDITION: +% 1. The variables +% \pgfkeyscurrentkey (full path including name) +% \pgfkeyscurrentkeyRAW (the current key as it has been +% found in the key=value list +% without path modification) +% \pgfkeyscurrentvalue +% are all set. If the current key is a handler variable, +% \pgfkeyscurrentname +% and +% \pgfkeyscurrentpath +% are also set. +% 2. The type of option has already been checked, that means +% case (1) whether '.@cmd' exists +% case (2) whether the key as such has its value +% case (3) it is a handler like '.code', '.cd' or whatever. +% case (0) it is unknown. +% The actual case number (0-3) will be provided as contents +% of the macro +% \pgfkeyscasenumber. +% It is always a one-character token, so it may be compared +% with both, \ifnum or \if. +% Please note that unknown options will be processed with +% the usual '.unknown' handlers unless the key filter takes +% control over unknown options as well. +% +% POSTCONDITION: +% the predicate sets +% \pgfkeysfiltercontinuetrue +% or +% \pgfkeysfiltercontinuefalse +% (the boolean \ifpgfkeysfiltercontinue). +% Depending on this 'if', option processing will be continued or +% skipped. +% +% The handler can do anything with the option, for example collect +% unmatched ones. +% +% ATTENTION: \pgfkeysfiltered can't be nested (yet). Use the +% \pgfkeyspredicateAND if you need multiple predicates at once. +% Nesting would produce unexpected results because the current filter +% state can't be stored/restored without TeX-groups, therefor it is +% disabled. +% +% ATTENTION: you can't filter error messages. +% +% REMARK: In case (3), the macros \pgfkeyscurrentpath and +% \pgfkeyscurrentname have already been computed, you do not need to +% invoke \pgfkeyssplitpath. In any other case, neither path nor name +% are required for the options processing - if you need them for +% predicates/handlers, you need to compute them by hand. +% +% +% Example: +% \def\unmatched{} +% \pgfkeys{/pgf/key filters/is descendant of/.install key filter=/my group} +% \pgfkeys{/pgf/key filter handlers/append filtered to/.install key filter handler=\unmatched} +% \pgfkeysfiltered% +% {/my group/option 1=value 1,/tikz/option 2=value 2} +% -> +% will set '/my group/option 1' as usual, but '/tikz/option 2' will not +% be set. Instead, it will be appended to '\unmatched' such that +% \unmatched = {/tikz/option 2=value2} +% after the operation. +% +% Arguments: +% #1: key-value list. +\def\pgfkeysfiltered{% + % produce + % '{}' + % each expanded exactly one time into the register: + \expandafter\pgfkeysfiltered@@install\expandafter{\pgfkeysdefaultpath}% +} + +% #1: old value of default path. +% #2: key-value-list. +\def\pgfkeysfiltered@@install#1#2{% + \pgfkeys@install@filter@and@invoke{% + \let\pgfkeysdefaultpath\pgfkeys@root% + \pgfkeys@parse#2,\pgfkeys@mainstop% + \def\pgfkeysdefaultpath{#1}% + }% +} + +% Assuming that macro #1 contains a key=value list, this command +% performs an \pgfkeysalso command for the content of macro #1. +% +% It can be used in conjunction with +% - \pgfkeysfiltered and +% - \pgfkeysappendfilterednamestomacro: +% the first pass fill only process options matching the filter, then, +% a \pgfkeysalsofrom can be used at a later time to set the remaining +% options. +% +% Example: +% \pgfkeys{/my group/.cd,/utils/exec=\pgfkeysalsofrom\filtered} +\long\def\pgfkeysalsofrom#1{% + \expandafter\pgfkeysalso\expandafter{#1}% +} + +% The same as \pgfkeysalsofrom, but it invokes \pgfkeysalsofiltered. +\long\def\pgfkeysalsofilteredfrom#1{% + \expandafter\pgfkeysalsofiltered\expandafter{#1}% +} + +% #1 = options +\long\long\def\pgfkeysalsofiltered#1{% + \pgfkeys@install@filter@and@invoke{\pgfkeysalso{#1}}% +}% + +% The same like \pgfkeysfiltered, but with quick search path setting. +% +% #1: default path +% #2: key-value-pairs +\long\def\pgfqkeysfiltered#1{% + \expandafter\pgfqkeysfiltered@@install\expandafter{\pgfkeysdefaultpath}{#1}% +} + +% #1: old value of default path. +% #2: default path +% #3: key-value-list. +\long\def\pgfqkeysfiltered@@install#1#2#3{% + \pgfkeys@install@filter@and@invoke{% + \def\pgfkeysdefaultpath{#2/}\pgfkeys@parse#3,\pgfkeys@mainstop\def\pgfkeysdefaultpath{#1}% + }% +} + +% Family management +% +% The family code provides the following features: +% 1. every key can be associated with 0 or 1 'family'. +% 2. Families are a loose association which are independend of the key +% hierarchy. +% For example, /my tree/key1 can belong to family /tikz. +% +% 3. It is possible to "activate" or "deactivate" single families. +% Furthermore, it is possible to set only keys which belong to +% active families (using \pgfkeysfiltered). +% 4. Runtime complexities: +% If you have N options and you only want to process K active +% families, the runtime is O( N + K ): +% - activate every family O(K) +% - use \pgfkeyshasactivefamily as filter predicate O(N) +% - deactivate every family O(K) + + +% Activates family #1. +% +% #1 maybe a macro. +\def\pgfkeysactivatefamily#1{% + \pgfkeysiffamilydefined + {#1}% + {\csname pgfk@#1/familyactivetrue\endcsname}% + {\pgfkeysvalueof{/errors/family unknown/.@cmd}{#1}\pgfeov}% +%\message{[ACTIVATING FAMILY #1]}% +} + +% Deactivates family #1. +% +% #1 maybe a macro. +\def\pgfkeysdeactivatefamily#1{% + \pgfkeysiffamilydefined + {#1}% + {\csname pgfk@#1/familyactivefalse\endcsname}% + {\pgfkeysvalueof{/errors/family unknown/.@cmd}{#1}\pgfeov}% +%\message{[DEACTIVATING FAMILY #1]}% +} + +% Activates all families in the comma separated list #1. +% +% It will also generate code for deactivation of all those families +% into the command #2. +% +% #1: a comma-separated list of fully qualified family names. +% #2: a command which will be filled with a deactivate-all command. +\def\pgfkeysactivatefamilies#1#2{% + \pgfkeyssavekeyfilterstateto\pgfkeys@cur@state + \expandafter\pgfkeysactivatefamilies@impl\expandafter{\pgfkeys@cur@state}{#1}{#2}% +} +% #1: commands needed to restore the old filtering state +% #2: family name list +% #3: macro name for de-activate command +\def\pgfkeysactivatefamilies@impl#1#2#3{% + \pgfkeysinstallkeyfilter{/pgf/key filters/false}{}% + \let#3=\pgfkeys@empty% + \def\pgfkeys@filtered@handler{\pgfkeys@family@activate@handler{#3}}% + \pgfkeysalsofiltered{#2}% + #1% +} + +\def\pgfkeys@family@activate@handler#1{% + \pgfkeysactivatefamily{\pgfkeyscurrentkey}% + % produce + % '\pgfkeysdeactivatefamily{' '}' + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter#1\expandafter\pgfkeysdeactivatefamily\expandafter{\pgfkeyscurrentkey}}% + \edef#1{\the\pgfkeys@tmptoks}% +} + +% If for testing whether a family exists. +% +% #1 = fully qualified family name +% #2 = if-case +% #3 = else-case +% +% Description: +% +% If the family exists, #2 will be executed. Otherwise, #3 will be +% called. +\long\def\pgfkeysiffamilydefined#1#2#3{\pgfkeys@ifcsname ifpgfk@#1/familyactive\endcsname#2\else#3\fi} + +% Sets the TeX boolean +% \ifpgfkeysfiltercontinue := ( family #1 is active ) +% +% Argument: +% #1 the family name. Maybe a macro. +\def\pgfkeysisfamilyactive#1{% + \pgfkeysiffamilydefined{#1}{% + \expandafter\let\expandafter\ifpgfkeysfiltercontinue\csname ifpgfk@#1/familyactive\endcsname + }{% + \pgfkeysvalueof{/errors/family unknown/.@cmd}{#1}\pgfeov% + \expandafter\expandafter\expandafter\let\csname ifpgfkeysfiltercontinue\endcsname\csname iffalse\endcsname + }% +}% + +% Retrieve the family of full key #1 into macro #2. +% +% Will set the TeX boolean \ifpgfkeyssuccess to whether the full key +% really has a family. +% +% The family for any key is stored in the sub-key #1/family. +% +% Parameters: +% #1: the full key name for which the family is requested. Maybe a +% macro. +% #2: a macro name which will be filled with the result. +\def\pgfkeysgetfamily#1#2{% + \pgfkeysifdefined{#1/family}{\pgfkeysgetvalue{#1/family}{#2}\pgfkeyssuccesstrue}{\pgfkeyssuccessfalse}% +} + +% Equivalent to \pgfkeys{#1/.belongs to family=#2} +\def\pgfkeyssetfamily#1#2{% + \pgfkeysiffamilydefined{#2}{% + \pgfkeyssetvalue{#1/family}{#2}% + }{% + \pgfkeysalso{/errors/family unknown=#2}% + }% +}% + + +% Sets \ifpgfkeysfiltercontinue to true iff the current key belongs to +% the /errors tree. +\long\def\pgfkeys@cur@is@descendant@of@errors{% + \expandafter\pgfkeys@cur@is@descendant@of@errors@impl\pgfkeyscurrentkey/errors\pgf@@eov +}% +\long\def\pgfkeys@cur@is@descendant@of@errors@impl#1/errors#2\pgf@@eov{% + \def\pgfkeyspred@TMP{#1}% + \ifx\pgfkeyspred@TMP\pgfkeys@empty +%\message{[SPECIAL CHECK] '\pgfkeyscurrentkey' is descendant of '/errors': TRUE.}% + \pgfkeysfiltercontinuetrue + \else +%\message{[SPECIAL CHECK] '\pgfkeyscurrentkey' is descendant of '/errors': FALSE.}% + \pgfkeysfiltercontinuefalse + \fi +}% + +% \pgfkeysinterruptkeyfilter +% ... +% \endpgfkeysinterruptkeyfilter +% temporarily interrupts key filtering and enables it in +% \endpgfkeysinterruptkeyfilter. +% +% If key filtering it not active, this has no effect at all. +% +% REMARK: +% \pgfkeysinterruptkeyfilter...\endpgfkeysinterruptkeyfilter does NOT +% introduce a \TeX-group. +\def\pgfkeysinterruptkeyfilter{% + \ifpgfkeysfilteringisactive + \let\pgfkeys@case@one=\pgfkeys@orig@case@one + \let\pgfkeys@try=\pgfkeys@orig@try + \let\pgfkeys@unknown=\pgfkeys@orig@unknown + \fi +} + +\def\endpgfkeysinterruptkeyfilter{% + \ifpgfkeysfilteringisactive + \let\pgfkeys@case@one=\pgfkeys@case@one@filtered + \let\pgfkeys@try=\pgfkeys@try@filtered + \let\pgfkeys@unknown=\pgfkeys@unknown@filtered + \fi +} + +% Activates families #1, calls \pgfkeysfiltered and deactivates the +% families afterwards. +% +% REMARK: you need to install a family-based key filter predicate +% manually to benefit from the activated families! +% +% #1: comma separated family list +% #2: key-value pairs +% +% @see \pgfkeysactivatefamiliesandfilteroptions +\def\pgfkeysactivatefamiliesandfilteroptions#1#2{% + \pgfkeysactivatefamilies{#1}{\pgfkeys@family@deactivation}% + \pgfkeysfiltered{#2}% + \pgfkeys@family@deactivation +} + +% The "quick" variant of \pgfkeysactivatefamiliesandfilteroptions: it +% also assigns a default path. +% +% #1: comma separated family list +% #2: default path +% #3: key-value pairs +\def\pgfqkeysactivatefamiliesandfilteroptions#1#2#3{% + \pgfkeysactivatefamilies{#1}{\pgfkeys@family@deactivation}% + \pgfqkeysfiltered{#2}{#3}% + \pgfkeys@family@deactivation +} + +% Public version of split path: +\def\pgfkeyssplitpath{\pgfkeys@split@path}% + + +% The same as \pgfkeysactivatefamiliesandfilteroptions but just for +% ONE family. +% +% #1: family (maybe a macro) +% #2: key-value pairs +\def\pgfkeysactivatesinglefamilyandfilteroptions#1#2{% + \pgfkeysactivatefamily{#1}% + \pgfkeysfiltered{#2}% + \pgfkeysdeactivatefamily{#1}% +} + +% The "quick" variant of \pgfkeysactivatesinglefamilyandfilteroptions +% +% #1: family (maybe a macro) +% #2: default path +% #3: key-value pairs +\def\pgfqkeysactivatesinglefamilyandfilteroptions#1#2#3{% + \pgfkeysactivatefamily{#1}% + \pgfqkeysfiltered{#2}{#3}% + \pgfkeysdeactivatefamily{#1}% +} + +% Installs the key filter '#1' with argument '#2'. +% This is equivalent to +% \pgfkeys{#1/.install key filter=#2} +% +% The current values of the key filter handler is stored into the public +% macros +% \pgfkeyscurrentkeyfilter +% and +% \pgfkeyscurrentkeyfilterargs +% +% #1: a full key name; may be a macro +% #2: optional arguments for the key. If the key expects more than one +% argument, supply '{{first}{second}}' +\def\pgfkeysinstallkeyfilter#1#2{% + \pgfkeysifdefined{#1/.@cmd}{% + \edef\pgfkeyscurrentkeyfilter{#1}% + \def\pgfkeyscurrentkeyfilterargs{#2}% + \pgfkeysgetvalue{#1/.@cmd}{\pgfkeys@key@predicate@}% + \def\pgfkeys@key@predicate{\pgfkeys@key@predicate@#2\pgfeov}% + }{% + \pgfkeysvalueof{/errors/no such key filter/.@cmd}{#1}{#2}\pgfeov% + }% +} + +% Installs the key filter handler '#1' with argument '#2'. +% This is equivalent to +% \pgfkeys{#1/.install key filter handler=#2} +% +% The current values of the key filter handler is stored into the public +% macros +% \pgfkeyscurrentkeyfilterhandler +% and +% \pgfkeyscurrentkeyfilterhandlerargs +% +% #1: a full key name; may be a macro +% #2: optional arguments for the handler. If the handler expects more than one +% argument, supply '{{first}{second}}' +\def\pgfkeysinstallkeyfilterhandler#1#2{% + \pgfkeysifdefined{#1/.@cmd}{% + \edef\pgfkeyscurrentkeyfilterhandler{#1}% + \def\pgfkeyscurrentkeyfilterhandlerargs{#2}% + \pgfkeysgetvalue{#1/.@cmd}{\pgfkeys@filtered@handler@}% + \def\pgfkeys@filtered@handler{\pgfkeys@filtered@handler@#2\pgfeov}% + }{% + \pgfkeysvalueof{/errors/no such key filter handler/.@cmd}{#1}{#2}\pgfeov% + }% +} + +% Creates a macro which contains commands to re-activate the current +% key filter and key filter handler. It can be used to temporarily +% switch the key filter. +\def\pgfkeyssavekeyfilterstateto#1{% + % produce the string + % \pgfkeysinstallkeyfilter{...}{...} + % \pgfkeysinstallkeyfilterhandler{...}{...} + % where each argument is expanded once + % FIXME: Do the same with less overhead! + \pgfkeys@tmptoks={\pgfkeysinstallkeyfilter}% + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfkeys@tmptoks\expandafter{\pgfkeyscurrentkeyfilter}}% + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfkeys@tmptoks\expandafter{\pgfkeyscurrentkeyfilterargs}\pgfkeysinstallkeyfilterhandler}% + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfkeys@tmptoks\expandafter{\pgfkeyscurrentkeyfilterhandler}}% + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter\the\expandafter\pgfkeys@tmptoks\expandafter{\pgfkeyscurrentkeyfilterhandlerargs}}% + \edef#1{% + \the\pgfkeys@tmptoks + }% +} + + +\pgfkeys{% + /errors/family unknown/.code=\pgfkeys@error{% + Sorry, I do not know family '#1' and can't work with any assoicated family handling. Perhaps you misspelled it?}, + /errors/no such key filter/.code 2 args=\pgfkeys@error{Sorry, there is no such key filter '#1'.}, + /errors/no such key filter handler/.code 2 args=\pgfkeys@error{Sorry, there is no such key filter handler '#1'.}, + % HANDLERS: + % + % .is family should + % 1. '.cd' into the families' path, + % 2. define booleans to activate/deactive the family + % (see \pgfkeysisfamilyactive) + % 3. make sure that \pgfkeyshasactivefamily returns true for + % the family itsself. + /handlers/.is family/.append code={% + %\newif is an \outer macro in plain tex, so this here is not portable: + %\expandafter\newif\csname if\pgfkeyscurrentpath/familyactive\endcsname + \edef\pgfkeyspred@TMP{pgfk@\pgfkeyscurrentpath/familyactive}% + \expandafter\pgfkeys@non@outer@newif\expandafter{\pgfkeyspred@TMP}% + \edef\pgfkeyspred@TMP{\pgfkeyscurrentpath/.belongs to family=\pgfkeyscurrentpath}% + \expandafter\pgfkeysalso\expandafter{\pgfkeyspred@TMP}% + },% + /handlers/.activate family/.code=\pgfkeysactivatefamily{\pgfkeyscurrentpath}, + /handlers/.deactivate family/.code=\pgfkeysdeactivatefamily{\pgfkeyscurrentpath}, + /handlers/.belongs to family/.code={\pgfkeyssetfamily{\pgfkeyscurrentpath}{#1}},% + % + % + % An addition to the '.try' and '.retry' handlers: + % + % It is the same as '.retry', but if the option is still unknown, the + % usual handlers for unknown keys will be invoked. + /handlers/.lastretry/.code={% + \ifpgfkeyssuccess\else + \pgfkeys@try + \ifpgfkeyssuccess\else + % discard the '.lastretry' suffix: + \edef\pgfkeyscurrentkey{\pgfkeyscurrentpath}% + \pgfkeys@split@path% + \pgfkeys@unknown + \fi + \fi + }, + % + % + /handlers/.install key filter/.code={% + \pgfkeysinstallkeyfilter{\pgfkeyscurrentpath}{#1}% + },% + /handlers/.install key filter handler/.code={% + \pgfkeysinstallkeyfilterhandler{\pgfkeyscurrentpath}{#1}% + },% + % + % + % KEY FILTER HANDLERS: + % + /pgf/key filter handlers/append filtered to/.code={% + % Produce + % '={' '}' + % where both, the key and the value are expanded just ONCE: + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter\pgfkeyscurrentkeyRAW\expandafter=\expandafter{\pgfkeyscurrentvalue}}% + \ifx#1\pgfkeys@empty + \else + % Produce ',' '={' '}' + \pgfkeys@tmptoks=\expandafter\expandafter\expandafter{\expandafter#1\expandafter,\the\pgfkeys@tmptoks}% + \fi + \edef#1{\the\pgfkeys@tmptoks}% + },% + /pgf/key filter handlers/ignore/.code={}, + /pgf/key filter handlers/ignore/.install key filter handler, + /pgf/key filter handlers/log/.code={% + \immediate\write16{LOG: the option '\pgfkeyscurrentkey' (was originally '\pgfkeyscurrentkeyRAW') (case \pgfkeyscasenumber) has not been processed due to pgfkeysfiltered.}% + }, + % + % + % KEY FILTER PREDICATES: + % + % Returns true iff the currently processed key belongs to an active family. + % A family is active if it has been activated before. + /pgf/key filters/active families/.code={% + \if\pgfkeyscasenumber0% + % unknown options shall be processed with the + % unknown-handlers. + \pgfkeysfiltercontinuetrue + \else + \if\pgfkeyscasenumber3% + \pgfkeysgetfamily\pgfkeyscurrentpath\pgfkeyspred@TMP + \else + \pgfkeysgetfamily\pgfkeyscurrentkey\pgfkeyspred@TMP + \fi + \ifpgfkeyssuccess + \pgfkeysisfamilyactive{\pgfkeyspred@TMP}% + \else% Ok, it does not belong to any family. + \pgfkeysfiltercontinuefalse + \fi + \fi + },% + % + % + % + % This filter works as follows: + % 1. if the current key belongs to a family: + % return whether its family is active, + % 2. if the current key does NOT belong to a family: + % return the result of criterion '#1', + % 3. the current key is unknown: + % return the result of criterion '#2'. + % + % Arguments: + % #1: the predicate which will be invoked in case 2. + % It will be invoked with the current case number as argument. + % #2: the predicate which will be invoked in case 3 with + % the current case number as argument. + /pgf/key filters/active families or no family/.code 2 args={% + \if\pgfkeyscasenumber0% + \pgfkeysevalkeyfilterwith{#2}% + \else + \if\pgfkeyscasenumber3% + \pgfkeysgetfamily\pgfkeyscurrentpath\pgfkeyspred@TMP + \else + \pgfkeysgetfamily\pgfkeyscurrentkey\pgfkeyspred@TMP + \fi + \ifpgfkeyssuccess + \pgfkeysisfamilyactive{\pgfkeyspred@TMP}% + \else% Ok, it does not belong to any family. + \pgfkeysevalkeyfilterwith{#1}% + \fi + \fi + }, + /pgf/key filters/active families or no family DEBUG/.code 2 args={% + \if\pgfkeyscasenumber0% + \immediate\write16{[pgfkeyshasactivefamilyornofamily(\pgfkeyscurrentkey, \pgfkeyscasenumber) invoking unknown handler '#2']}% + \pgfkeysevalkeyfilterwith{#2}% + \else + \if\pgfkeyscasenumber3% + \pgfkeysgetfamily\pgfkeyscurrentpath\pgfkeyspred@TMP + \else + \pgfkeysgetfamily\pgfkeyscurrentkey\pgfkeyspred@TMP + \fi + \ifpgfkeyssuccess + \pgfkeysisfamilyactive{\pgfkeyspred@TMP}% + \ifpgfkeysfiltercontinue + \immediate\write16{[pgfkeyshasactivefamilyornofamily(\pgfkeyscurrentkey, \pgfkeyscasenumber) family is ACTIVE]}% + \else + \immediate\write16{[pgfkeyshasactivefamilyornofamily(\pgfkeyscurrentkey, \pgfkeyscasenumber) family is NOT active.]}% + \fi + \else% Ok, it does not belong to any family. + \immediate\write16{[pgfkeyshasactivefamilyornofamily(\pgfkeyscurrentkey, \pgfkeyscasenumber) invoking has-no-family-handler '#1']}% + \pgfkeysevalkeyfilterwith{#1}% + \fi + \fi + }, + % + % A (faster) shortcut for + % /pgf/key filters/active families or no family= + % {/pgf/keys filters/false} + % {/pgf/keys filters/false} + /pgf/key filters/active families and known/.code={% + \if\pgfkeyscasenumber0% + \pgfkeysfiltercontinuefalse + \else + \if\pgfkeyscasenumber3% + \pgfkeysgetfamily\pgfkeyscurrentpath\pgfkeyspred@TMP + \else + \pgfkeysgetfamily\pgfkeyscurrentkey\pgfkeyspred@TMP + \fi + \ifpgfkeyssuccess + \pgfkeysisfamilyactive{\pgfkeyspred@TMP}% + \else% Ok, it does not belong to any family. + \pgfkeysfiltercontinuefalse + \fi + \fi + }, + % A (faster) shortcut for + % /pgf/key filters/active families or no family= + % {/pgf/key filters/is descendant of=#1}% for keys without family + % {/pgf/keys filters/false} + /pgf/key filters/active families or descendants of/.code={% + \if\pgfkeyscasenumber0% + \pgfkeysfiltercontinuefalse + \else + \if\pgfkeyscasenumber3% + \pgfkeysgetfamily\pgfkeyscurrentpath\pgfkeyspred@TMP + \else + \pgfkeysgetfamily\pgfkeyscurrentkey\pgfkeyspred@TMP + \fi + \ifpgfkeyssuccess + \pgfkeysisfamilyactive{\pgfkeyspred@TMP}% + \else% Ok, it does not belong to any family. + % the 'is descendendant of' implementation has been + % COPY PASTED here: + % + % string prefix comparison: + \def\pgfkeysisdescendantof@impl##1#1##2\pgf@@eov{% + \def\pgfkeyspred@TMP{##1}% + \ifx\pgfkeyspred@TMP\pgfkeys@empty + \pgfkeysfiltercontinuetrue + \else + \pgfkeysfiltercontinuefalse + \fi + }% + \expandafter\pgfkeysisdescendantof@impl\pgfkeyscurrentkey#1\pgf@@eov + \fi + \fi + }, + % + % Processes only options which are childs of #1. + % Example: + % is descendant of/.install key filter=/foo + % will be true for + % /foo/bar/x=y + % /foo/.cd + % /foo/bar/.style=... + % but not for + % /bar/foo/... + /pgf/key filters/is descendant of/.code={% + \if\pgfkeyscasenumber0% +%\message{'\pgfkeyscurrentkey' (case \pgfkeyscasenumber) is UNKNOWN. Calling unknown handler.}% + % unknown options shall be processed with the + % unknown-handlers. + \pgfkeysfiltercontinuetrue + \else + % string prefix comparison: + % [ note : this has been COPY-PASTED to + % |active families or descendants of| ] + \def\pgfkeysisdescendantof@impl##1#1##2\pgf@@eov{% + \def\pgfkeyspred@TMP{##1}% + \ifx\pgfkeyspred@TMP\pgfkeys@empty +%\message{'\pgfkeyscurrentkey' (case \pgfkeyscasenumber) is descendant of '#1': TRUE.}% + \pgfkeysfiltercontinuetrue + \else +%\message{'\pgfkeyscurrentkey' (case \pgfkeyscasenumber) is descendant of '#1': FALSE.}% + \pgfkeysfiltercontinuefalse + \fi + }% + \expandafter\pgfkeysisdescendantof@impl\pgfkeyscurrentkey#1\pgf@@eov + \fi + },% + % + % + % + % Returns true if the currently processed full key equals #2. + /pgf/key filters/equals/.code={% + \if\pgfkeyscasenumber0% + % Unknown option: + \pgfkeysfiltercontinuetrue + \else + \def\pgfkeyspred@TMP{#1}% + \ifx\pgfkeyscurrentkey\pgfkeyspred@TMP + \pgfkeysfiltercontinuetrue + \else + \pgfkeysfiltercontinuefalse + \fi + \fi + },% + % + % + % Argument #1 can be any other (evaluated) filter predicate, its logical return + % value will be inverted. + % Example: + % not/.install key filter={is descendend of=/tikz} + % will install a key filter which evaluates 'is descendant of' with argument '/tikz' and returns the logical negation of the result. + % + /pgf/key filters/not/.code={% + \pgfkeysevalkeyfilterwith{#1}% + \ifpgfkeysfiltercontinue + \pgfkeysfiltercontinuefalse + \else + \pgfkeysfiltercontinuetrue + \fi + },% + /pgf/key filters/and/.code 2 args={% + \pgfkeysevalkeyfilterwith{#1}% + \ifpgfkeysfiltercontinue + \pgfkeysevalkeyfilterwith{#2}% + \fi + },% + /pgf/key filters/or/.code 2 args={% + \pgfkeysevalkeyfilterwith{#1}% + \ifpgfkeysfiltercontinue + \else + \pgfkeysevalkeyfilterwith{#2}% + \fi + },% + /pgf/key filters/true/.code={\pgfkeysfiltercontinuetrue},% + /pgf/key filters/true/.install key filter, + /pgf/key filters/false/.code={% + \pgfkeysfiltercontinuefalse + },% + % + % Returns false if the current key is unknown, which avoids calling + % the unknown handlers. + /pgf/key filters/defined/.code={% + \if\pgfkeyscasenumber0% + \pgfkeysfiltercontinuefalse + \else + \pgfkeysfiltercontinuetrue + \fi + }, +}% + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% +% Private IMPLEMENTATION +% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + +% This command does THE SAME work as \pgfkeys@case@one, +% but it applies filtering whenever it identified the type of an +% option. +\def\pgfkeys@case@one@filtered{% + \pgfkeys@cur@is@descendant@of@errors + \ifpgfkeysfiltercontinue + \pgfkeys@orig@case@one + \else + \pgfkeysfiltercontinuetrue + \pgfkeysifdefined{\pgfkeyscurrentkey/.@cmd}{% + % CASE ONE: a command option + \def\pgfkeyscasenumber{1}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue +%\message{PROCESSING KEY \pgfkeyscurrentkey!}% + \pgfkeysgetvalue{\pgfkeyscurrentkey/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov + \else +%\message{FILTERED OUT KEY \pgfkeyscurrentkey!}% + \pgfkeys@filtered@handler% + \fi + }{% + % CASE TWO: a normal value option + \pgfkeysifdefined{\pgfkeyscurrentkey}{% + \def\pgfkeyscasenumber{2}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue +%\message{PROCESSING KEY \pgfkeyscurrentkey!}% + \pgfkeys@case@two@extern + \else +%\message{FILTEReD OUT KEY \pgfkeyscurrentkey!}% + \pgfkeys@filtered@handler% + \fi + }{% + \pgfkeys@split@path + % CASE THREE: a handler + \pgfkeysifdefined{/handlers/\pgfkeyscurrentname/.@cmd}{% + \pgfkeys@ifexecutehandler{% + \def\pgfkeyscasenumber{3}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue +%\message{PROCESSING KEY \pgfkeyscurrentkey!}% + \pgfkeysgetvalue{/handlers/\pgfkeyscurrentname/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov + \else +%\message{FILTERED OUT KEY \pgfkeyscurrentkey!}% + \pgfkeys@filtered@handler% + \fi + }{% + \pgfkeys@unknown + }% + }{% + \pgfkeys@unknown + }% + }% + }% + \fi +}% + +\def\pgfkeys@unknown@filtered{% + % CASE ZERO: an unknown option. + \def\pgfkeyscasenumber{0}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue +%\message{PROCESSING KEY \pgfkeyscurrentkey!}% + % start normal 'unknown' handlers: + \pgfkeys@orig@unknown + \else +%\message{FILTEReD OUT KEY \pgfkeyscurrentkey!}% + \pgfkeys@filtered@handler% + \fi +} + +% Does the same as \pgfkeys@try, but it also invokes the key filters. +\def\pgfkeys@try@filtered{% + \ifpgfkeysfiltercontinue + \pgfkeys@orig@try + \else + \pgfkeysfiltercontinuetrue + \edef\pgfkeyscurrentkey{\pgfkeyscurrentpath}% make sure that \pgfkeys@code doesn't know about 'try'. Important for .is choice + \ifx\pgfkeyscurrentvalue\pgfkeysnovalue@text% Hmm... no value + \pgfkeysifdefined{\pgfkeyscurrentpath/.@def}% + {\pgfkeysgetvalue{\pgfkeyscurrentpath/.@def}{\pgfkeyscurrentvalue}} + {}% no default, so leave it + \fi% + \pgfkeysifdefined{\pgfkeyscurrentpath/.@cmd}% + {% + % CASE ONE: a command option + \def\pgfkeyscasenumber{1}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue + \pgfkeysgetvalue{\pgfkeyscurrentkey/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov% + \else + \pgfkeys@filtered@handler% + \fi + \pgfkeyssuccesstrue% + }% + {% + \pgfkeysifdefined{\pgfkeyscurrentpath}% + {% CASE TWO: a normal value option + \def\pgfkeyscasenumber{2}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue + \ifx\pgfkeyscurrentvalue\pgfkeysnovalue@text% + \pgfkeysvalueof{\pgfkeyscurrentpath}% + \else% + \pgfkeyslet{\pgfkeyscurrentpath}\pgfkeyscurrentvalue% + \fi% + \else + \pgfkeys@filtered@handler% + \fi + \pgfkeyssuccesstrue% + }% + {% + \pgfkeys@split@path% + \pgfkeysifdefined{/handlers/\pgfkeyscurrentname/.@cmd}{% + % CASE THREE: a handled key + % + % in the standard configuration, this check here is redundand + % because pgfkeys@ifexecutehandler === true. + % It is only interesting for 'handle only existing'. + \pgfkeys@ifexecutehandler{% + \def\pgfkeyscasenumber{3}% + \pgfkeys@key@predicate% + \ifpgfkeysfiltercontinue +%\message{PROCESSING KEY \pgfkeyscurrentkey!}% + \pgfkeysgetvalue{/handlers/\pgfkeyscurrentname/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyscurrentvalue\pgfeov + \else +%\message{FILTERED OUT KEY \pgfkeyscurrentkey!}% + \pgfkeys@filtered@handler% + \fi + \pgfkeyssuccesstrue% + }{% + \pgfkeyssuccessfalse + }% + }{% + \pgfkeyssuccessfalse + }% + }% + }% + \fi +} + + +% #1 the code to invoke after init and before cleanup +\def\pgfkeys@install@filter@and@invoke#1{% + \ifpgfkeysfilteringisactive + \pgfkeys@error{Sorry, nested calls to key filtering routines are not allowed. (reason: It is not possible to properly restore the previous filtering state after returning from the nested call)}% + \fi + \pgfkeysfilteringisactivetrue + \let\pgfkeys@case@one=\pgfkeys@case@one@filtered + \let\pgfkeys@try=\pgfkeys@try@filtered + \let\pgfkeys@unknown=\pgfkeys@unknown@filtered + #1% + \let\pgfkeys@case@one=\pgfkeys@orig@case@one + \let\pgfkeys@try=\pgfkeys@orig@try + \let\pgfkeys@unknown=\pgfkeys@orig@unknown + \pgfkeysfilteringisactivefalse +} + + +%-------------------------------------------------- +% \def\pgfkeys@eval@key@filter@subroutine@case@one{% +% \pgfkeysifdefined{\pgfkeyscurrentkey/.@cmd}{% +% \pgfkeysgetvalue{\pgfkeyscurrentkey/.@cmd}{\pgfkeys@code}% +% \let\pgfkeyspred@TMP=\pgfkeyscurrentvalue +% \pgfkeys@eval@key@filter@subroutine@restorestate +% \expandafter\pgfkeys@code\pgfkeyspred@TMP\pgfeov +% }{% +% \pgfkeysvalueof{/errors/no such key filter/.@cmd}\pgfkeyscurrentkey\pgfkeyscurrentvalue\pgfeov% +% }% +% } +% % THIS VERSION IS TOO SLOW. See below. +% \def\pgfkeysevalkeyfilterwith#1{% +% \edef\pgfkeys@eval@key@filter@subroutine@restorestate{% +% \noexpand\def\noexpand\pgfkeyscurrentkey{\pgfkeyscurrentkey}% +% \noexpand\def\noexpand\pgfkeyscurrentkeyRAW{\pgfkeyscurrentkeyRAW}% +% \noexpand\def\noexpand\pgfkeyscurrentname{\pgfkeyscurrentname}% +% \noexpand\def\noexpand\pgfkeyscurrentvalue{\pgfkeyscurrentvalue}% +% \noexpand\pgfkeys@pathtoks={\pgfkeyscurrentpath}% +% }% +% \pgfkeysinterruptkeyfilter +% \let\pgfkeys@case@one=\pgfkeys@eval@key@filter@subroutine@case@one +% \pgfkeysalso{#1}% +% \endpgfkeysinterruptkeyfilter% this here also restored \pgfkeys@case@one. +% \pgfkeys@eval@key@filter@subroutine@restorestate +% }% +%-------------------------------------------------- + + +% Evaluates a key filter '#1'. Example: +% \pgfkeysevalkeyfilterwith{/pgf/key filters/equals=/tikz} +% +% \pgfkeysevalkeyfilterwith works only if key filtering is +% active. +% +% The argument '#1' MUST be a FULL KEY. +% +% The implementation employs a subset of the \pgfkeysalso code. +\long\def\pgfkeysevalkeyfilterwith#1{% + \pgfkeys@eval@key@filter@subroutine@unpack#1=\pgfkeysnovalue=\pgfkeys@stop +}% +\long\def\pgfkeys@eval@key@filter@subroutine@unpack#1=#2=#3\pgfkeys@stop{% + \pgfkeys@spdef\pgfkeyspred@TMP{#1}% + \edef\pgfkeyspred@TMP{\pgfkeyspred@TMP}% + \pgfkeys@spdef\pgfkeyspred@TMPB{#2}% TMPB=value + \ifx\pgfkeyspred@TMPB\pgfkeysnovalue@text% Hmm... no value + \pgfkeysifdefined{\pgfkeyspred@TMP/.@def}% + {\pgfkeysgetvalue{\pgfkeyspred@TMP/.@def}{\pgfkeyspred@TMPB}} + {}% no default, so leave it + \fi% + \ifx\pgfkeyspred@TMPB\pgfkeysvaluerequired% + \pgfkeysvalueof{/errors/value required/.@cmd}\pgfkeyspred@TMP\pgfkeyspred@TMPB\pgfeov% + \else% + \pgfkeysifdefined{\pgfkeyspred@TMP/.@cmd}{% + \pgfkeysgetvalue{\pgfkeyspred@TMP/.@cmd}{\pgfkeys@code}% + \expandafter\pgfkeys@code\pgfkeyspred@TMPB\pgfeov + }{% + \pgfkeysvalueof{/errors/no such key filter/.@cmd}\pgfkeyspred@TMP\pgfkeyspred@TMPB\pgfeov% + }% + \fi% +} + + +\def\pgfkeys@non@outer@newif@#1#2{% + \expandafter\edef\csname #2true\endcsname{\noexpand\let\noexpand#1=\noexpand\iftrue}% + \expandafter\edef\csname #2false\endcsname{\noexpand\let\noexpand#1=\noexpand\iffalse}% + \csname #2false\endcsname +}% + +% For latex and context, this here has the same effect as a \newif +% applied to 'if#1'. For plain tex, it has also the same effect, but +% it is not an \outer macro as the plain-tex \newif. +\def\pgfkeys@non@outer@newif#1{% + \expandafter\pgfkeys@non@outer@newif@\csname if#1\endcsname{#1}% +} +\endinput diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex b/Master/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex index 97727fdbeb7..6a0a1be016d 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfrcs.code.tex @@ -15,8 +15,10 @@ % prints out a message to the log. -\def\pgfversion{2.00} -\def\pgftypesetversion{\oldstylenums{2}.\oldstylenums{00}} +%\def\pgfversion{2.00-cvs} +%\def\pgftypesetversion{\oldstylenums{2}.\oldstylenums{00}--\textsc{cvs}} +\def\pgfversion{2.10} +\def\pgftypesetversion{\oldstylenums{2}.\oldstylenums{10}} \ifx\pgfrcsloaded\undefined @@ -87,7 +89,7 @@ \def\ProvidesFile#1[#2]{\wlog{Loading file #1 version #2.}} \fi -\ProvidesPackageRCS[v\pgfversion] $Header: /cvsroot/pgf/pgf/generic/pgf/utilities/pgfrcs.code.tex,v 1.21 2008/02/20 11:00:42 tantau Exp $ +\ProvidesPackageRCS[v\pgfversion] $Header: /cvsroot/pgf/pgf/generic/pgf/utilities/pgfrcs.code.tex,v 1.24 2010/10/25 20:57:06 ludewich Exp $ \catcode`\@=\pgfrcsatcode diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex index 29c27b499c7..7b3c34a0510 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-common.tex @@ -39,6 +39,7 @@ \def\pgfutil@firstoftwo#1#2{#1} \def\pgfutil@secondoftwo#1#2{#2} \def\pgfutil@empty{} +\def\pgfutil@gobble@until@relax#1\relax{} \def\pgfutil@gobble#1{} \def\pgfutil@gobbletwo#1#2{} \def\pgfutil@namedef#1{\expandafter\def\csname #1\endcsname} @@ -46,8 +47,8 @@ \def\pgfutil@@namelet#1#2{\expandafter\let\expandafter#1\csname#2\endcsname} \long\def\pgfutil@g@addto@macro#1#2{% \begingroup - \toks@\expandafter{#1#2}% - \xdef#1{\the\toks@}% + \pgfutil@toks@\expandafter{#1#2}% + \xdef#1{\the\pgfutil@toks@}% \endgroup} \newif\ifpgfutil@tempswa @@ -77,6 +78,19 @@ % pgfutil@in@ \newif\ifpgfutil@in@ + +% Usage: +% \pgfutil@in@{one}{three two one} +% \ifpgfutil@in@ +% -> will be true! +% \else +% \fi +% +% \pgfutil@in@{,}{1234,456567} +% \ifpgfutil@in@ +% -> will be true! +% \else +% \fi \def\pgfutil@in@#1#2{% \def\pgfutil@in@@##1#1##2##3\pgfutil@in@@{% \ifx\pgfutil@in@##2\pgfutil@in@false\else\pgfutil@in@true\fi}% @@ -106,9 +120,9 @@ % pgfutil@IfFileExists -\chardef\pgfutil@inputcheck0 +%\chardef\pgfutil@inputcheck0 \def\pgfutil@IfFileExists#1#2#3{% - \openin\pgfutil@inputcheck#1 % + \openin\pgfutil@inputcheck=#1 % \ifeof\pgfutil@inputcheck #3\relax \else @@ -119,6 +133,13 @@ \def\pgfutil@InputIfFileExists#1#2#3{\pgfutil@IfFileExists{#1}{\input #1\relax#2}{#3}}% +% pgfutil@loop (from plain.tex) + +\def\pgfutil@loop#1\pgfutil@repeat{\def\pgfutil@body{#1}\pgfutil@iterate} +\def\pgfutil@iterate{\pgfutil@body \let\pgfutil@next\pgfutil@iterate \else\let\pgfutil@next\relax\fi \pgfutil@next} +\let\pgfutil@repeat=\fi % this makes \loop...\if...\repeat skippable + + % aux-read-hook \let\pgfutil@aux@read@hook=\relax @@ -130,4 +151,314 @@ \newtoks\pgfutil@everybye +% +% PDF-Resource management -- might seem strange that this is here, but +% it turns out to be the correct place since latex and context handle +% this stuff quite differently +% + +% Adding something to the pdf-resources: + +\def\pgfutil@addpdfresource@extgs#1{\pgf@sys@addpdfresource@extgs@plain{#1}} +\def\pgfutil@addpdfresource@colorspaces#1{\pgf@sys@addpdfresource@colorspaces@plain{#1}} +\def\pgfutil@addpdfresource@patterns#1{\pgf@sys@addpdfresource@patterns@plain{#1}} +\def\pgfutil@setuppdfresources{\pgf@sys@setuppdfresources@plain} + + +% Inserts the argument at the begin of the current page (hopefully) + +\let\pgfutil@insertatbegincurrentpage=\relax + + +% Library files inclusion + + +% Include a library file. +% +% #1 = List of names of library file. +% +% Description: +% +% This command includes a list of library files. For each file X in the +% list, the file pgflibraryX.code.tex is included, provided this has +% not been done earlier. +% +% For the convenience of Context users, both round and square brackets +% are possible for the argument. +% +% Example: +% +% \usepgflibrary{arrows} +% \usepgflibrary[patterns,snakes] + +\def\usepgflibrary{\pgfutil@ifnextchar[{\use@pgflibrary}{\use@@pgflibrary}}%} +\def\use@pgflibrary[#1]{\use@@pgflibrary{#1}} +\def\use@@pgflibrary#1{% + \edef\pgf@list{#1}% + \pgfutil@for\pgf@temp:=\pgf@list\do{% + \expandafter\pgfkeys@spdef\expandafter\pgf@temp\expandafter{\pgf@temp}% + \ifx\pgf@temp\pgfutil@empty + \else + \expandafter\ifx\csname pgf@library@\pgf@temp @loaded\endcsname\relax% + \expandafter\let\csname pgf@library@\pgf@temp @loaded\endcsname=\pgfutil@empty% + \expandafter\edef\csname pgf@library@#1@atcode\endcsname{\the\catcode`\@} + \expandafter\edef\csname pgf@library@#1@barcode\endcsname{\the\catcode`\|} + \catcode`\@=11 + \catcode`\|=12 + \input pgflibrary\pgf@temp.code.tex + \catcode`\@=\csname pgf@library@#1@atcode\endcsname + \catcode`\|=\csname pgf@library@#1@barcode\endcsname + \fi% + \fi + }% +} + + +% Include a module file. +% +% #1 = List of names of module files. +% +% Description: +% +% This command includes a list of module files. For each file X in the +% list, the file pgfmoduleX.code.tex is included, provided this has +% not been done earlier. +% +% For the convenience of Context users, both round and square brackets +% are possible for the argument. +% +% Example: +% +% \usepgfmodule{matrix} + +\def\usepgfmodule{\pgfutil@ifnextchar[{\use@pgfmodule}{\use@@pgfmodule}}%} +\def\use@pgfmodule[#1]{\use@@pgfmodule{#1}} +\def\use@@pgfmodule#1{% + \edef\pgf@list{#1}% + \pgfutil@for\pgf@temp:=\pgf@list\do{% + \expandafter\ifx\csname pgf@module@\pgf@temp @loaded\endcsname\relax% + \expandafter\let\csname pgf@module@\pgf@temp @loaded\endcsname=\pgfutil@empty% + \expandafter\edef\csname pgf@module@#1@atcode\endcsname{\the\catcode`\@} + \expandafter\edef\csname pgf@module@#1@barcode\endcsname{\the\catcode`\|} + \catcode`\@=11 + \catcode`\|=12 + \input pgfmodule\pgf@temp.code.tex + \catcode`\@=\csname pgf@module@#1@atcode\endcsname + \catcode`\|=\csname pgf@module@#1@barcode\endcsname + \fi% + }% +} + +\def\pgfutilensuremath#1{% + \ifmmode#1\else$#1$\fi +} + + +% +% Guess the driver: +% + +\def\pgfutil@guessdriver{\edef\pgfsysdriver{pgfsys-\Gin@driver}} + +\begingroup + \catcode`\"=12 + \edef\pgf@loc@TMPa{"}% + % + % prepares file names by checking for double colons. + % + % If '#1' is a usual file name without anything fancy, \pgfretval + % will simply contain it. However, if '#1' contains double colons + % (introduces, for example, by pdftex because there are white + % spaces in '#1'), the routine + % - removes the double colons, + % - re-inserts them outside of the string. + % + % \pgfutilpreparefilename{file.tex} -> file.tex + % \pgfutilpreparefilename{"A file name".file} -> "A file name.file" + % + % The resulting file name is returned in '\pgfretval', + % furthermore, a *quoted* version of the file name is returned in + % \pgfretvalquoted. The latter result is to have some sort of + % output normalisation: if the file name as such contains double + % quotes, we don't want to insert another set of them. + % + % This special handling has the following purposes: + % 1. Both, treatment of white spaces and double colons is not + % properly defined in TeX. Thus, we should only work with them if + % necessary and maintain backwards compatibility as far as + % possible. + % 2. It *should* work if there are spaces. + % + \gdef\pgfutilpreparefilename#1{% + \begingroup + \ifnum\the\catcode`\"=13 + \pgfutilconvertdcolon + \fi + \xdef\pgf@temp{#1}% + \endgroup + \expandafter\pgfutil@in@\expandafter"\expandafter{\pgf@temp}% + \ifpgfutil@in@ + \def\pgf@loc@TMPa{\pgfutilstrreplace{"}{}}% + \expandafter\pgf@loc@TMPa\expandafter{\pgf@temp}% + \edef\pgfretval{"\pgfretval"}% re-insert quotes! Otherwise, TeX can't use the file name. + \let\pgfretvalquoted=\pgfretval + \else + \let\pgfretval=\pgf@temp + \edef\pgfretvalquoted{"\pgfretval"}% + \fi + }% + \catcode`\"=13 + \xdef\pgfutilconvertdcolon{% + \noexpand\def\noexpand"{\pgf@loc@TMPa}% + }% +\endgroup + +% Usage: +% \pgfutilstrreplace{}{}{} +% +% -> will assign the modified string into \pgfretval. +% +% #1: the string to search (one or more tokens) +% #2: zero, one or more tokens which will be inserted instead of '#1'. +% #3: the string to search in +\long\def\pgfutilstrreplace#1#2#3{% + \def\pgfretval{}% + \long\def\pgfutil@search@and@replace@@##1#1##2\pgf@EOI{% + \expandafter\def\expandafter\pgfretval\expandafter{\pgfretval ##1#2}% + \pgfutil@search@and@replace@loop{#1}{##2}% + }% + \pgfutil@search@and@replace@loop{#1}{#3}% +} +\long\def\pgfutil@search@and@replace@loop#1#2{% + \pgfutil@in@{#1}{#2}% + \ifpgfutil@in@ + \def\pgf@loc@TMPa{\pgfutil@search@and@replace@@ #2\pgf@EOI}% + \else + \expandafter\def\expandafter\pgfretval\expandafter{\pgfretval #2}% + \let\pgf@loc@TMPa=\relax + \fi + \pgf@loc@TMPa +}% + +% Solves a linear equation system of size 2x2 using gauss elimination. +% +% It employs TeX register arithmetics to do so. +% #1: should contain 4 sets of braces with matrix entries, +% {}{} +% {}{} +% where each entry should be a number without unit. +% It is acceptable if '#1' is a macro which expands to the expected +% format. +% #2: should contain 2 sets of braces with the right-hand-side, +% {}{} +% where each entry should be a number without unit. +% It is acceptable if '#2' is a macro which expands to the expected +% format. +% +% It will assign \pgfmathresult to contain two sets of braces with the +% result. +% +% Example: +% \pgfutilsolvetwotwoleq{ +% {0.24}{1} +% {-0.97}{0} +% }{ +% {-7} +% {18} +% } +% -> yields \pgfmathresult={−18.55618}{−2.54642} +% +% The algorithm employs column pivotisation. +\def\pgfutilsolvetwotwoleq#1#2{% + \begingroup + \dimendef\aa=0 + \dimendef\ab=1 + \dimendef\ba=2 + \dimendef\bb=3 + \dimendef\ra=4 + \dimendef\rb=5 + \dimendef\tmpa=6 + \dimendef\tmpb=7 + \edef\pgf@temp{#1}% + \expandafter\pgfutilsolvetwotwoleq@A\pgf@temp + \edef\pgf@temp{#2}% + \expandafter\pgfutilsolvetwotwoleq@r\pgf@temp + % + \pgfutilsolvetwotwoleq@ifislarger\aa\ba{% + % identity "permutation": + \def\Pa{a}% + \def\Pb{b}% + }{% + % permutation matrix: switch rows! + \def\Pa{b}% + \def\Pb{a}% + }% + % \pivot := 1/aa + \pgfmathreciprocal@ + {\csname m\Pa a\endcsname}% + \let\pivot=\pgfmathresult + % + % \factor := 1/aa * ba + \csname \Pb a\endcsname=\pivot\csname \Pb a\endcsname + \edef\factor{\expandafter\pgf@sys@tonumber\csname \Pb a\endcsname}% + % + % bb -= ba/aa * ab + \tmpa=-\factor\csname \Pa b\endcsname + \advance\csname \Pb b\endcsname by\tmpa + % + % rb -= ba/aa * ra + \tmpa=-\factor\csname r\Pa\endcsname + \advance\csname r\Pb\endcsname by\tmpa + % + % xb := rb / bb (the modified rb and modified bb!) + \pgfmathdivide@ + {\expandafter\pgf@sys@tonumber\csname r\Pb\endcsname} + {\expandafter\pgf@sys@tonumber\csname \Pb b\endcsname}% + \expandafter\let\csname pgfmathresult\Pb\endcsname=\pgfmathresult + % + % ra -= xb * ab + \tmpa=\csname pgfmathresult\Pb\endcsname\csname \Pa b\endcsname + \advance\csname r\Pa\endcsname by-\tmpa + % + % xa := 1/aa * ra (the modified ra!) + \tmpa=\pivot\csname r\Pa\endcsname + \expandafter\edef\csname pgfmathresult\Pa\endcsname{\pgf@sys@tonumber\tmpa}% + % + \edef\pgfmathresult{% + {\csname pgfmathresult\Pa\endcsname}% + {\csname pgfmathresult\Pb\endcsname}% + }% + \pgfmath@smuggleone\pgfmathresult + \endgroup +}% +\def\pgfutilsolvetwotwoleq@ifislarger#1#2#3#4{% + \tmpa=#1 + \ifdim\tmpa<0pt + \multiply\tmpa by-1 + \fi + \tmpb=#2 + \ifdim\tmpb<0pt + \multiply\tmpb by-1 + \fi + \ifdim\tmpa>\tmpb + #3% + \else + #4% + \fi +}% +\def\pgfutilsolvetwotwoleq@A#1#2#3#4{% + \def\maa{#1}\def\mab{#2}% + \def\mba{#3}\def\mbb{#3}% + \aa=#1pt \ab=#2pt + \ba=#3pt \bb=#4pt +} +\def\pgfutilsolvetwotwoleq@r#1#2{% + \ra=#1pt \rb=#2pt +}% + +% there are funny programs which overwrite \read and \write (like +% tabularx). +\let\pgfutil@write=\write +\let\pgfutil@read=\read + \endinput diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-context.def b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-context.def index 784cb59cdc9..08d3bf93c77 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-context.def +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-context.def @@ -59,7 +59,15 @@ \edef#3{\expandafter\expandafter\expandafter\pgfutil@emu@select\csname\string\color@#1\endcsname}% } -\let\pgfutil@doifcolorelse=\doifcolorelse + +\def\pgfutil@doifcolorelse#1#2#3{% + \expandafter\ifx\csname\string\color@#1\endcsname\relax% + \doifcolorelse{#1}{\let\pgf@next=\pgfutil@firstoftwo}{\let\pgf@next=\pgfutil@secondoftwo}% + \else + \let\pgf@next=\pgfutil@firstoftwo% + \fi% + \pgf@next{#2}{#3}% +} \def\pgfutil@reset@color{% @@ -136,12 +144,12 @@ \edef\pgf@marshal{\noexpand\pgfutil@in@{ g}{\pgf@temp}}% \pgf@marshal% \ifpgfutil@in@% - \expandafter\pgfutil@context@parse@gray\pgf@temp{#1}% + \expandafter\pgfutil@context@parse@gray\pgf@temp\pgf@stop{#1}% \else% \edef\pgf@marshal{\noexpand\pgfutil@in@{ rg}{\pgf@temp}}% \pgf@marshal% \ifpgfutil@in@% - \expandafter\pgfutil@context@parse@rgb\pgf@temp{#1}% + \expandafter\pgfutil@context@parse@rgb\pgf@temp\pgf@stop{#1}% \else% \PackageError{pgf}{Color #1 has an unsupported color model.}{}% \pgfutil@definecolor{#1}{gray}{0} @@ -149,14 +157,16 @@ \fi% } -\def\pgfutil@context@parse@gray#1 g#2{% - \pgfutil@definecolor{#2}{gray}{#1} +\def\pgfutil@context@parse@gray#1 g#2\pgf@stop#3{% + \pgfutil@definecolor{#3}{gray}{#1} } -\def\pgfutil@context@parse@rgb#1 #2 #3 rg#4{% - \pgfutil@definecolor{#4}{rgb}{#1,#2,#3} +\def\pgfutil@context@parse@rgb#1 #2 #3 rg#4\pgf@stop#5{% + \pgfutil@definecolor{#5}{rgb}{#1,#2,#3} } +% Make this command available in general: +\let\colorlet=\pgfutil@colorlet % pgfutil@minipage @@ -174,12 +184,39 @@ \ifx\pdfoutput\@undefined\newcount\pdfoutput\fi \ifx\pdfoutput\relax\newcount\pdfoutput\fi -\ifcase\pdfoutput% - \gdef\Gin@driver{dvips.def}% -\else% - \gdef\Gin@driver{pdftex.def}% -\fi% +\def\pgfutil@guessdriver{ + \ifx\XeTeXversion\@undefined + \ifx\preloadedspecials\@undefined% + \ifcase\pdfoutput% + \def\pgfsysdriver{pgfsys-dvips.def}% + \else% + \def\pgfsysdriver{pgfsys-pdftex.def}% pdfTeX & LuaTeX + \fi% + \else% + \pgfutil@driver@if@in{postscript}{pgfsys-dvips.def} + \pgfutil@driver@if@in{tpd}{pgfsys-pdftex.def} + \pgfutil@driver@if@in{dpm}{pgfsys-dvipdfm.def} + \pgfutil@driver@if@in{dpx}{pgfsys-dvipdfmx.def} + \pgfutil@driver@if@in{xetex}{pgfsys-xetex.def} + \ifx\pgfsysdriver\relax% + \PackageWarning{pgf}{I was not able to discern the driver, the + preloaded specials were \preloadedspecials. I am going to use + pgfsys-dvips.def}% + \def\pgfsysdriver{pgfsys-dvips.def} + \fi% + \fi + \else + \def\pgfsysdriver{pgfsys-xetex.def}% should be right + \fi +} +\def\pgfutil@driver@if@in#1#2{% + \edef\pgf@marshal{\noexpand\pgfutil@in@{#1}{\preloadedspecials}} + \pgf@marshal + \ifpgfutil@in@% + \def\pgfsysdriver{#2}% + \fi% +} % Global colors @@ -191,7 +228,7 @@ % Font stuff -\def\pgfutil@font@tiny{\tfxx} % How to do this correctly? +\def\pgfutil@font@tiny{\tfxx} \def\pgfutil@font@scriptsize{\tfxx} \def\pgfutil@font@footnotesize{\tfx} \def\pgfutil@font@small{\tfx} @@ -204,9 +241,9 @@ \def\pgfutil@font@itshape{\it} \def\pgfutil@font@bfseries{\bf} -\let\pgfutil@font@normalfont=\rm +\let\pgfutil@font@normalfont=\tf -\let\pgfutil@selectfont=\rm +\let\pgfutil@selectfont=\tf % Extra counters, registers, boxes @@ -219,14 +256,68 @@ \newdimen\pgfutil@tempdima \newdimen\pgfutil@tempdimb +\newbox \pgfutil@voidb@x +\newtoks \pgfutil@toks@ + % Module stuff -\def\pgfutil@usemodule#1{\usemodule[#1]} +\long\def\pgfutil@usemodule#1{% + % seems as if \usemodule resets \catcodes... handle that here: + \long\edef\pgf@temp##1{% + \noexpand\usemodule[##1]\noexpand\relax% + \noexpand\catcode`\noexpand\@=\the\catcode`\@\relax + \noexpand\catcode`\noexpand\|=\the\catcode`\|\relax + }% + \pgf@temp{#1}% +} -% End of job stuff +% Adding something at the begin of the current page: + +\let\pgfutil@insertatbegincurrentpagefrombox=\flushatshipout +\let\pgfutil@insertatbegincurrentpage=\flushatshipout +\def\pgfutil@insertatbegineverypage#1{\appendtoks #1 \to \everyshipout} + +% Adding something to the pdf-resources: + +\def\pgfutil@addpdfresource@extgs#1{\appendtoPDFdocumentextgstates{#1}} +\def\pgfutil@addpdfresource@colorspaces#1{\appendtoPDFdocumentcolorspaces{#1}} +\def\pgfutil@addpdfresource@patterns#1{\appendtoPDFdocumentpatterns{#1}} +\def\pgfutil@setuppdfresources{} + +\ifx\appendtoPDFdocumentpatterns\undefined + \let\docuPDFpatterns\empty + \def\checkPDFpatterns + {\ifx\docuPDFpatterns\empty \else + \ifnum\realpageno=\lastpage\relax + \doPDFdictionaryobject{FDF}{docupatterns}{\docuPDFpatterns}% + \fi + \doPDFgetobjectreference{FDF}{docupatterns}\PDFobjectreference + \doPDFpageresource{/Pattern \PDFobjectreference}% + \fi} + \appendtoksonce \checkPDFpatterns \to \everyshipout + \def\appendtoPDFdocumentpatterns#1{\xdef\docuPDFpatterns{\docuPDFpatterns\space#1}} +\fi + +% Collect resources (don't know how to do this otherwise) + +\def\pgf@sys@pdf@check@resources{% + \global\let\pgf@sys@pdf@possible@resources\pgfutil@empty% + \doifobjectreferencefoundelse{FDF}{docushades} + {\doPDFgetobjectreference{FDF}{docushades}\PDFobjectreference + \xdef\pgf@sys@pdf@possible@resources{\pgf@sys@pdf@possible@resources/Shading \PDFobjectreference}}\donothing + \doifobjectreferencefoundelse{FDF}{docuextgstates} + {\doPDFgetobjectreference{FDF}{docuextgstates}\PDFobjectreference + \xdef\pgf@sys@pdf@possible@resources{\pgf@sys@pdf@possible@resources/ExtGState \PDFobjectreference}}\donothing + \doifobjectreferencefoundelse{FDF}{colorspaces} + {\doPDFgetobjectreference{FDF}{colorspaces}\PDFobjectreference + \xdef\pgf@sys@pdf@possible@resources{\pgf@sys@pdf@possible@resources/ColorSpace \PDFobjectreference}}\donothing +} + + +% Do something at the end of a job \appendtoks \the\pgfutil@everybye \to \everybye @@ -237,9 +328,9 @@ % prefixed by pgfutil@): \def\PackageInfo#1#2{} -\def\PackageWarning#1#2{\immediate\write-1{Package #1: Warning! #2.}}% -\def\PackageError#1#2#3{\immediate\write-1{Package #1: Error! #2.}}% +\def\PackageWarning#1#2{\immediate\write17{Package #1: Warning! #2.}}% +\def\PackageError#1#2#3{\immediate\write17{Package #1: Error! #2.}}% \long\def\AtBeginDocument#1{#1}% -\long\def\AtBeginDvi#1{#1}% \endinput +% vi: ft=tex ts=2 sw=2 expandtab diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def index b50830db666..f9681aa4a56 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-latex.def @@ -13,6 +13,9 @@ \let\pgfutil@auxout=\@auxout \let\pgfutil@tempcnta=\@tempcnta \let\pgfutil@tempcntb=\@tempcntb +\let\pgfutil@voidb@x=\voidb@x +\let\pgfutil@toks@=\toks@ + \def\pgfutil@definecolor{\definecolor} \def\pgfutil@color{\color} @@ -61,4 +64,38 @@ \AtEndDocument{\the\pgfutil@everybye} +\def\pgfutil@insertatbegincurrentpagefrombox#1{% + \global\setbox\pgfutil@abb\hbox{\unhbox\pgfutil@abb#1}% +} +\newbox\pgfutil@abb% +\def\pgfutil@insertatbegincurrentpage#1{% + \expandafter\gdef\expandafter\pgfutil@abc\expandafter{\pgfutil@abc#1}% +} +\let\pgfutil@abc\pgfutil@empty% +\def\pgfutil@insertatbegineverypage#1{% + \expandafter\gdef\expandafter\pgfutil@abe\expandafter{\pgfutil@abe#1}% +} +\let\pgfutil@abe\pgfutil@empty% + +\RequirePackage{everyshi} +\EveryShipout{% + % Add at begin page stuff + \setbox\@cclv=\vbox{% + \setbox\z@=\hbox{\pgfutil@abe\unhbox\pgfutil@abb\pgfutil@abc\global\let\pgfutil@abc\pgfutil@empty}% + \wd\z@=\z@ + \ht\z@=\z@ + \dp\z@=\z@ + \box\z@ + % if TeX changes into vertical mode, it inserts \parskip and + % \lineskip. Disable it here: + \nointerlineskip + \ifvbox\@cclv \unvbox\@cclv \else\hsize=\wd\@cclv \unhbox\@cclv \fi% + %\box\@cclv + % using \box instead of \unhbox or \unvbox + % has the advantage that glue settings won't be + % altered (as for \unhbox/\unvbox). But \box breaks compatibility + % with the 'remember picture' feature. + }% +} + \endinput diff --git a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-plain.def b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-plain.def index 9128021faa7..c09cf21fe0f 100644 --- a/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-plain.def +++ b/Master/texmf-dist/tex/generic/pgf/utilities/pgfutil-plain.def @@ -157,12 +157,20 @@ \ifx\pdfoutput\@undefined\alloc@0\count\countdef\insc@unt\pdfoutput\fi \ifx\pdfoutput\relax\alloc@0\count\countdef\insc@unt\pdfoutput\fi -\ifcase\pdfoutput% - \gdef\Gin@driver{dvips.def}% -\else% - \gdef\Gin@driver{pdftex.def}% -\fi% +\def\pgfutil@guessdriver{ + \ifcase\pdfoutput% + \ifx\XeTeXversion\@undefined + \def\pgfsysdriver{pgfsys-dvips.def}% hopefully + \else + \def\pgfsysdriver{pgfsys-xetex.def}% should be right + \fi + \else% + \def\pgfsysdriver{pgfsys-pdftex.def}% should be right + \fi% +} + + % Global colors @@ -213,14 +221,62 @@ \let\pgfutil@origend=\end \def\end{\the\pgfutil@everybye\pgfutil@origend} +% Link to existing stuff +\let\pgfutil@voidb@x\voidb@x +\let\pgfutil@toks@\toks@ + + + + +% Hack shipout. Should perhaps use atbegshi? Not in standard distribution, currently... +% Code inspired (but patched...) from everyshi.sty: + +\def\pgfutil@insertatbegincurrentpagefrombox#1{% + \global\setbox\pgfutil@abb\hbox{\unhbox\pgfutil@abb#1}% +} +\newbox\pgfutil@abb% +\def\pgfutil@insertatbegincurrentpage#1{% + \expandafter\gdef\expandafter\pgfutil@abc\expandafter{\pgfutil@abc#1}% +} +\let\pgfutil@abc\pgfutil@empty% +\def\pgfutil@insertatbegineverypage#1{% + \expandafter\gdef\expandafter\pgfutil@abe\expandafter{\pgfutil@abe#1}% +} +\let\pgfutil@abe\pgfutil@empty% + +\def\pgfutil@@EveryShipout@Shipout{% + \afterassignment\pgfutil@@EveryShipout@Test + \setbox255= % +} +\def\pgfutil@@EveryShipout@Test{% + \ifvoid\@cclv\relax + \aftergroup\pgfutil@EveryShipout@Output + \else + \pgfutil@EveryShipout@Output + \fi% +} +\def\pgfutil@EveryShipout@Output{% + \setbox255=\vbox{% + \setbox0=\hbox{\pgfutil@abe\unhbox\pgfutil@abb\pgfutil@abc\global\let\pgfutil@abc\pgfutil@empty}% + \wd0=0pt% + \ht0=0pt% + \dp0=0pt% + \box0% + \unvbox255% + }% + \pgfutil@@EveryShipout@Org@Shipout\box\@cclv% +} +\let\pgfutil@@EveryShipout@Org@Shipout\shipout +\let\shipout\pgfutil@@EveryShipout@Shipout + + % The following is still messy and needs to be cleanup up (everything % prefixed by pgfutil@): \def\PackageInfo#1#2{} -\def\PackageWarning#1#2{\immediate\write-1{Package #1: Warning! #2.}}% -\def\PackageError#1#2#3{\immediate\write-1{Package #1: Error! #2.}}% +\def\PackageWarning#1#2{\immediate\write17{Package #1: Warning! #2.}}% +\def\PackageError#1#2#3{\immediate\write17{Package #1: Error! #2.}}% \long\def\AtBeginDocument#1{#1}% -\long\def\AtBeginDvi#1{#1}% \endinput -- cgit v1.2.3