The TikZ and PGF Packages
Manual for version 3.1.10

This package can be used independently of pgf. Note that no other package of pgf needs to be loaded (so neither the emulation layer nor the system layer is needed). The ConTeXt abbreviation is pgfkey if pgfmod is not loaded.

Stores the ⟨token text⟩ in the ⟨full key⟩. The ⟨full key⟩ may not be a partial key, so no default-path-adding is done. The ⟨token text⟩ can be arbitrary tokens and may even contain things like # or unbalanced TeX-ifs.

The setting of a key is always local to the current TeX group.

The \edef version of \pgfkeyssetvalue.

Performs a \let statement so the ⟨full key⟩ points to the contents of ⟨macro⟩.

You should never let a key be equal to \relax. Such a key may or may not be indistinguishable from an undefined key.

Retrieves the tokens stored in the ⟨full key⟩ and lets ⟨macro⟩ be equal to these tokens. If the key has not been set, the ⟨macro⟩ will be equal to \relax.

Inserts the value stored in ⟨full key⟩ at the current position into the text. It expands to an alias of the primitive \relax if the key is undefined.

Note: It is an error to assign to the result of the expansion of \pgfkeysvalueof, not only semantically but in recent versions of pgf also logically. To set the value of a key always use the appropriate interfaces, e.g. \pgfkeyssetvalue.

Checks whether this key was previously set using either \pgfkeyssetvalue or \pgfkeyslet. If so, the code in ⟨if⟩ is executed, otherwise the code in ⟨else⟩.

The ⟨key list⟩ should be a list of key–value pairs, separated by commas. A key–value pair can have the following two forms: ⟨key⟩=⟨value⟩ or just ⟨key⟩. Any spaces around the ⟨key⟩ or around the ⟨value⟩ are removed. It is permissible to surround both the ⟨key⟩ or the ⟨value⟩ in curly braces, which are also removed. Especially putting the ⟨value⟩ in curly braces needs to be done quite often, namely whenever the ⟨value⟩ contains an equal-sign or a comma.

The key–value pairs in the list are handled in the order they appear. How this handling is done, exactly, is described in the rest of this section.

If a ⟨key⟩ is a partial key, the current value of the default path is prefixed to the ⟨key⟩ and this “upgraded” key is then used. The default path is just the root path / when the first key is handled, but it may change later on. At the end of the command, the default path is reset to the value it had before this command was executed.

Calls of this command may be nested. Thus, it is permissible to call \pgfkeys inside the code that is executed for a key. Since the default path is restored after a call of \pgfkeys, the default path will not change when you call \pgfkeys while executing code for a key (which is exactly what you want).

This command has the same effect as \pgfkeys{⟨default path⟩/.cd,⟨key list⟩}, it is only marginally quicker. This command should not be used in user code, but rather in commands like \tikzset or \pgfset that get called very often.

This command has exactly the same effect as \pgfkeys, only the default path is not modified before or after the keys are being set. This command is mainly intended to be called by the code that is being processed for a key.

This command has the same effect as \pgfkeysalso{⟨default path⟩/.cd,⟨key list⟩}, it is only quicker. Changing the default path inside a \pgfkeyalso is dangerous, so use with care. A rather safe place to call this command is at the beginning of a TeX group.

This command temporarily defines a TeX-macro with the argument list #1\pgfeov and then lets ⟨key⟩/.@cmd be equal to this macro. The net effect of all this is that you have then set up code for the key ⟨key⟩ so that when you write \pgfkeys{⟨key⟩=⟨value⟩}, then the ⟨code⟩ is executed with all occurrences of #1 in ⟨code⟩ being replaced by ⟨value⟩. (This behavior is quite similar to the \define@key command of keyval and xkeyval).

This command works like \pgfkeysdef, but it uses \edef rather than \def when defining the key macro. If you do not know the difference between the two, then you will not need this command; and if you know the difference, then you will know when you need this command.

This command works like \pgfkeysdef, but it allows you to provide an arbitrary ⟨argument count⟩ between \(0\) and \(9\) (inclusive).

The resulting key will expect exactly {⟨argument count⟩} arguments.

The \edef version of \pgfkeysdefnargs.

This command works like \pgfkeysdefnargs, but it allows you to provide an arbitrary ⟨argument pattern⟩ rather than just a number of arguments.

Note that \pgfkeysdefnargs is better when it comes to simple argument counts¹⁴.

The \edef version of \pgfkeysdefargs.

Changes the initial configuration how key handlers will be used.

This configuration is for advanced users and rarely necessary.

all

The preconfigured setting all works as described above and imposes no restriction on the key setting process.

only existing

The value only existing modifies the algorithm for handled keys as follows: a handler ⟨key name⟩/.⟨handler⟩ will be executed only if ⟨key name⟩ is either a key which stores its value directly or a command key for which /.@cmd exists. If ⟨key name⟩ does not exist already, the complete string ⟨key name⟩/.⟨handler⟩ is considered to be an unknown key and the procedure described in the next section applies (for the path of ⟨key name⟩).

Initial definition.Re-Definition.Unknown key ‘/the/other key/.code’.

copy
% Define a test key and error handlers:
\pgfkeys{/the/key/.code={Initial definition. }}
\pgfkeys{/handlers/.unknown/.code={Unknown key `\pgfkeyscurrentkey'. }}

% calling the test key yields 'Initial definition. ':
\pgfkeys{/the/key}

% Change configuration:
\pgfkeys{/handler config=only existing}

% allowed: key *re*-definition:
\pgfkeys{/the/key/.code={Re-Definition. }}
% calling the key yields 'Re-Definition. ':
\pgfkeys{/the/key}

% not allowed: definition of new keys:
% this checks for '/the/other key/.unknown'
% and '/handlers/.unknown'
% and yields finally
% 'Unknown key `/the/other key/.code`'
\pgfkeys{/the/other key/.code={New definition. }}


It is necessary to exclude some key handlers from this procedure. Altogether, the detailed procedure is as follows:

• 1. If a handled key like /a path/a key/.a handler=value is encountered, it is checked whether the handler should be invoked. This is the case if

  • • An exception from only existing for this key exists (see below),

  • • The key /a path/a key exists already – either directly as storage key or with the .@cmd suffix.

• 2. If the check passes, everything works as before.

• 3. If the check fails, the complete key will be considered to be unknown. In that case, the handling of unknown keys as described in the next section applies. There, the current key path will be set to /a path and the current key’s name to key/.a handler.

A consequence of this configuration is to provide more meaningful processing of handled keys if a search path for keys is in effect, see section 87.3.6 for an example.

full or existing

Finally, the choice full or existing is a variant of only existing: it works in the same way for keys which do not have a full key path. For example, the style

\pgfkeys{/my path/.cd,key/.style={\(\dotsc \)}}

can only be redefined: it doesn’t have a full path, so the only existing mechanism applies. But the style

\pgfkeys{/my path/key/.style={\(\dotsc \)}}

will still work. This allows users to override the only existing feature if they know what they’re doing (and provide full key paths).

Allows to add exceptions to the /handler config=only existing feature. Initially exceptions for the key handlers /.cd, /.try, /.retry, /.lastretry and /.unknown are defined. The value {⟨key handler name⟩} should be the name of a key handler.

This handler causes the default path to be set to ⟨key⟩. Note that the default path is reset at the beginning of each call to \pgfkeys to be equal to /.

Example: \pgfkeys{/tikz/.cd,...}

This handler sets up things such that when ⟨key⟩ is executed, then the current path is set to ⟨key⟩. A typical use is the following:

The effect of this handler is the same as if you had written ⟨key⟩/.style=⟨key⟩/.cd, only the code produced by the /.is family handler is quicker.

Sets the default value of ⟨key⟩ to ⟨value⟩. This means that whenever no value is provided in a call to \pgfkeys, then this ⟨value⟩ will be used instead.

Example: \pgfkeys{/width/.default=1cm}

This handler causes the error message key /errors/value required to be issued whenever the ⟨key⟩ is used without a value.

Example: \pgfkeys{/width/.value required}

This handler causes the error message key /errors/value forbidden to be issued whenever the ⟨key⟩ is used with a value.

This handler works be adding code to the code of the key. This means that you have to define the key first before you can use this handler.

This handler executes \pgfkeysdef with the parameters ⟨key⟩ and ⟨code⟩. This means that, afterwards, whenever the ⟨key⟩ is used, the ⟨code⟩ gets executed. More precisely, when ⟨key⟩=⟨value⟩ is encountered in a key list, ⟨code⟩ is executed with any occurrence of #1 replaced by ⟨value⟩. As always, if no ⟨value⟩ is given, the default value is used, if defined, or the special value \pgfkeysnovalue.

It is permissible that ⟨code⟩ calls the command \pgfkeys. It is also permissible that ⟨code⟩ calls the command \pgfkeysalso, which is useful for styles, see below.

This handler works like /.code, only the command \pgfkeysedef is used.

This handler works like /.code, only two arguments rather than one are expected when the ⟨code⟩ is executed. This means that when ⟨key⟩=⟨value⟩ is encountered in a key list, the ⟨value⟩ should consist of two arguments. For instance, ⟨value⟩ could be {first}{second}. Then ⟨code⟩ is executed with any occurrence of #1 replaced first and any occurrence of #2 replaced by second.

Because of the special way the ⟨value⟩ is parsed, if you set ⟨value⟩ to, for instance, first (without any braces), then #1 will be set to f and #2 will be set to irst.

This handler works like /.code 2 args, only an \edef is used rather than a \def to define the macro.

This handler also works like /.code, but you can now specify a number of arguments between \(0\) and \(9\) (inclusive).

In contrast to /.code 2 args, there must be exactly ⟨argument count⟩ arguments, not more and not less and these arguments should be properly delimited.

This handler works like /.code n args, only an \edef is used rather than a \def to define the macro.

This handler is the most flexible way to define a /.code key: you can now specify an arbitrary ⟨argument pattern⟩. Such a pattern is a usual TeX macro pattern. For instance, suppose ⟨argument pattern⟩ is (#1/#2) and ⟨key⟩=⟨value⟩ is encountered in a key list with ⟨value⟩ being (first/second). Then ⟨code⟩ is executed with any occurrence of #1 replaced first and any occurrence of #2 replaced by second. So, the actual ⟨value⟩ is matched against the ⟨argument pattern⟩ in the standard TeX way.

Note that /.code n args should be preferred in case you need just a number of arguments (when the resulting keys are used, /.code n args gobbles spaces between the arguments whereas /.code args considers spaces to be part of the argument).

This handler works like /.code args, only an \edef is used rather than a \def to define the macro.

This handler adds code to an existing key. The ⟨prefix code⟩ is added to the code stored in ⟨key⟩/.@cmd at the beginning, the ⟨append code⟩ is added to this code at the end. Either can be empty. The argument list of ⟨code⟩ cannot be changed using this handler. Note that both ⟨prefix code⟩ and ⟨append code⟩ may contain parameters like #2.

This handler is a shortcut for ⟨key⟩/.add code={⟨prefix code⟩}{}. That is, this handler adds the ⟨prefix code⟩ at the beginning of the code stored in ⟨key⟩/.@cmd.

This handler is a shortcut for ⟨key⟩/.add code={}{⟨append code⟩}.

This handler sets things up so that whenever ⟨key⟩=⟨value⟩ is encountered in a key list, then the ⟨key list⟩, with every occurrence of #1 replaced by ⟨value⟩, is processed instead. As always, if no ⟨value⟩ is given, the default value is used, if defined, or the special value \pgfkeysnovalue.

You can achieve the same effect by writing ⟨key⟩/.code=\pgfkeysalso{⟨key list⟩}. This means, in particular, that the code of a key could also first execute some normal code and only then process some further keys.

The following example shows a parameterized style “in action”.

This handler works like /.style, only the ⟨code⟩ is set using \edef rather than \def. Thus, all macros in the ⟨code⟩ are expanded prior to saving the style.

This handler works like /.code 2 args, only for styles. Thus, the ⟨key list⟩ may contain occurrences of both #1 and #2 and when the style is used, two parameters must be given as ⟨value⟩.

This handler works like /.style 2 args, only an \edef is used rather than a \def to define the macro.

This handler works like /.code n args, only for styles. Here, ⟨key list⟩ may depend on all ⟨argument count⟩ parameters.

This handler works like /.add code, only for styles. However, it is permissible to add styles to keys that have previously been set using /.code. (It is also permissible to add normal ⟨code⟩ to a key that has previously been set using /.style). When you add a style to a key that was previously set using /.code, the following happens: When ⟨key⟩ is processed, the ⟨prefix key list⟩ will be processed first, then the ⟨code⟩ that was previously stored in ⟨key⟩/.@cmd, and then the keys in ⟨append key list⟩ are processed.

This handler works like /.code args, only for styles.

This handler works like /.ecode args, only for styles.

Works like /.add style, but only for the prefix key list.

Works like /.add style, but only for the append key list.

This handler sets the value of ⟨key⟩ to ⟨value⟩. Note that no subkeys are involved. After this handler has been used, by the rules governing keys, you can subsequently change the value of the ⟨key⟩ by just writing ⟨key⟩=⟨value⟩. Thus, this handler is used to set the initial value of key.

Note that with this configuration, writing \pgfkeys{/my key} will not have the effect you might expect (namely that blue is inserted into the main text). Rather, /my key will be promoted to /my key=\pgfkeysnovalue and, thus, \pgfkeysnovalue will be stored in /my key.

To retrieve the value stored in a key, the handler /.get is used.

Remark: A key can both store a value and execute commands¹⁵. If so, using ⟨key⟩ will always execute commands with the passed value, or the default value \pgfkeysnovalue if no value is provided. Note that the stored value is never used. To update the stored value, the handler /.initial or command \pgfkeyssetvalue is used.

Executes a \let command so that ⟨macro⟩ contains the contents stored in ⟨key⟩.

Adds the ⟨prefix value⟩ at the beginning and the ⟨append value⟩ at the end of the value stored in ⟨key⟩.

Adds the ⟨prefix value⟩ at the beginning of the value stored in ⟨key⟩.

Adds the ⟨append value⟩ at the end of the value stored in ⟨key⟩.

Stores the value \pgfkeysvalueof{⟨another key⟩} in the ⟨key⟩. The idea is that when you expand the ⟨key⟩, the value of ⟨another key⟩ is expanded instead. This corresponds loosely to the notion of soft links in Unix, hence the name.

This handler has the following effect: When you write ⟨key⟩=⟨value⟩, the code \def⟨macro⟩{⟨value⟩} is executed. Thus, the given value is “stored” in the ⟨macro⟩.

This handler is similar to /.store in, only the code \edef⟨macro⟩{⟨value⟩} is used. Thus, the macro-expanded version of ⟨value⟩ is stored in the ⟨macro⟩.

This handler has the following effect: When you write ⟨key⟩=⟨value⟩, it is first checked that ⟨value⟩ is true or false (the default is true if no ⟨value⟩ is given). If this is not the case, the error key /errors/boolean expected is executed. Otherwise, the code \⟨TeX-if name⟩⟨value⟩ is executed, which sets the TeX-if accordingly.

This handler sets things up so that writing ⟨key⟩=⟨value⟩ will cause the subkey ⟨key⟩/⟨value⟩ to be executed. So, each of the different possible choices should be given by a subkey of ⟨key⟩.

If the subkey ⟨key⟩/⟨value⟩ does not exist, the error key /errors/unknown choice value is executed.

This handler expands ⟨value⟩ once (more precisely, it executes an \expandafter command on the first token of ⟨value⟩) and then process the resulting ⟨result⟩ as if you had written ⟨key⟩=⟨result⟩. Note that if ⟨key⟩ contains a handler itself, this handler will be called normally.

This handler works like saying ⟨key⟩/.expand once/.expand once=⟨value⟩.

This handler will completely expand ⟨value⟩ (using \edef) before processing ⟨key⟩=⟨result⟩.

This handler will evaluate ⟨value⟩ as a mathematical expression with \pgfmathparse and assign ⟨key⟩=\pgfmathresult.

This handler causes the key to be used repeatedly, namely once for every element of the list of values. Note that the list of values should typically be surrounded by braces since, otherwise, TeX will not be able to tell whether a comma starts a new key or a new value.

The ⟨list of values⟩ is processed using the \foreach statement, so you can use the ... notation.

This handler causes the ⟨key⟩ to “forward” its argument to ⟨another key⟩. When the ⟨key⟩ is used, its normal code will be executed first. Then, the value is (additionally) passed to ⟨another key⟩. If the ⟨key⟩ has not yet been defined prior to the use of .forward to, it will be defined then (and do nothing by itself, expect for forwarding it to ⟨key name⟩). The ⟨another key⟩ must be a fully qualified key name.

A style which installs a /.unknown handler into ⟨key⟩. This /.unknown handler will then search for unknown keys in every path provided in {⟨path list⟩}.

The /.search also handler follows the strategy

• 1. If a user provides a fully qualified key which could not be found, for example the full string /main path/option, it assumes that the user knew what she is doing – and does not continue searching for option in {⟨path list⟩}.

• 2. If a user provides only the key’s name, for example option and option cannot be found in the current default path (which is /main path in our example above), the current default path is set to the next element in {⟨path list⟩} (which is /secondary path here) and \pgfkeys will be restarted.

  This will be iterated until either a match has been found or all elements in {⟨path list⟩} have been tested.

• 3. If all elements in {⟨path list⟩} have been checked and the key is still unknown, the fall-back handler /handlers/.unknown will be invoked.

Please note that the strategy of /.search also is different from the first example provided in section 87.3.6 “Unknown Keys” because /.search also only applies to keys that are not fully qualified.

For those who are familiar with \pgfkeys, the actual implementation of /.search also might be interesting:

• 1. \pgfkeys{/path/.search also={/tikz}} is equivalent to

  copy
\pgfkeys{/path/.unknown/.code={%
\def\pgfkeys@searchalso@temp@value{#1}%
\ifpgfkeysaddeddefaultpath
\expandafter\pgfkeys@firstoftwo
\else
\expandafter\pgfkeys@secondoftwo
\fi{%
% only process keys for which no full path has been
% provided:
\pgfkeyssuccessfalse
\let\pgfkeys@searchalso@name=\pgfkeyscurrentkeyRAW
\ifpgfkeyssuccess
\else
% search with /tikz as default path:
\pgfqkeys{/tikz}{\pgfkeys@searchalso@name/.expand once=%
\pgfkeys@searchalso@temp@value}%
\fi
}{%
\pgfkeysgetvalue{/handlers/.unknown/.@cmd}{\pgfkeys@code}%
\expandafter\pgfkeys@code\pgfkeys@searchalso@temp@value\pgfeov
}%
}
}


• 2. \pgfkeys{/path/.search also={/tikz,/pgf}} is equivalent to

  copy
\pgfkeys{/path/.unknown/.code={%
\def\pgfkeys@searchalso@temp@value{#1}%
\ifpgfkeysaddeddefaultpath
\expandafter\pgfkeys@firstoftwo
\else
\expandafter\pgfkeys@secondoftwo
\fi{%
\pgfkeyssuccessfalse
\let\pgfkeys@searchalso@name=\pgfkeyscurrentkeyRAW
\ifpgfkeyssuccess
\else
% step 1: search in /tikz with .try:
\pgfqkeys{/tikz}{\pgfkeys@searchalso@name/.try/.expand once=%
\pgfkeys@searchalso@temp@value}%
\fi
\ifpgfkeyssuccess
\else
% step 2: search in /pgf (without .try!):
\pgfqkeys{/pgf}{\pgfkeys@searchalso@name/.expand once=\pgfkeys@searchalso@}%
\fi
}{%
\pgfkeysgetvalue{/handlers/.unknown/.@cmd}{\pgfkeys@code}%
\expandafter\pgfkeys@code\pgfkeys@searchalso@temp@value\pgfeov
}%
}
}


To also enable searching for styles (or other handled keys), consider changing the configuration for handled keys to /handler config=full or existing when you use /.search also, that is, use

This handler causes the same things to be done as if ⟨key⟩=⟨value⟩ had been written instead. However, if neither ⟨key⟩/.@cmd nor the key itself is defined, no handlers will be called. Instead, the execution of the key just stops. Thus, this handler will “try” to use the key, but no further action is taken when the key is not defined.

The TeX-if \ifpgfkeyssuccess will be set according to whether the ⟨key⟩ was successfully executed or not.

This handler works just like /.try, only it will not do anything if \ifpgfkeyssuccess is false. Thus, this handler will only retry to set a key if “the last attempt failed”.

This handler works like /.retry, only it will invoke the usual handlers for unknowns keys if \ifpgfkeyssuccess is false. Thus, this handler will only try to set a key if “the last attempt failed”. Furthermore, this here is the last such attempt.

This handler executes a \show command on the value stored in ⟨key⟩. This is useful mostly for debugging.

Example: \pgfkeys{/my/obscure key/.show value}

This handler executes a \show command on the code stored in ⟨key⟩/.@cmd. This is useful mostly for debugging.

Example: \pgfkeys{/my/obscure key/.show code}

This key will simply execute the given ⟨code⟩.

Example: \pgfkeys{some key=some value,/utils/exec=\show\hallo,obscure key=obscure}

This key is executed whenever an ⟨offending key⟩ is used without a value when a value is actually required.

This key is executed whenever a key is used with a value when a value is actually forbidden.

This key is executed whenever a key set up using /.is if gets called with a ⟨value⟩ other than true or false.

This key is executed whenever a choice is used as a ⟨value⟩ for a key set up using the /.is choice handler that is not defined.

This key is executed whenever a key is unknown and no specific /.unknown handler is found.

\usepgfkeyslibrary{filtered} % LaTeX and plain TeX
\usepgfkeyslibrary[filtered] % ConTeXt

The filtered library provides functionality to filter keys and only process selected ones, while forwarding the others to another namespace.

This library is loaded by default by pgfkeys.

Processes all options in exactly the same way as \pgfkeys{⟨key–value-list⟩}, but a key filter is considered as soon as key identification is complete.

The key filter tells \pgfkeysfiltered whether it should continue to apply the current option (return value is ‘true’) or whether something different shall be done (filter returns ‘false’).

There is exactly one key filter in effect, and it is installed by the .install key filter handler or by \pgfkeysinstallkeyfilter.

If the key filter returns ‘false’, a unique key filter handler gets control. This handler is installed by the .install key filter handler method and has access to the key’s full name, value and (possibly) path.

Key filtering applies to any (possibly nested) call to \pgfkeys, \pgfkeysalso, \pgfqkeys and \pgfqkeysalso during the evaluation of {⟨key–value-list⟩}. It does not apply to routines like \pgfkeyssetvalue or \pgfkeysgetvalue. Furthermore, keys belonging to /errors are always processed. Key filtering routines can’t be nested: you can’t combine different key filters automatically.

A variant of \pgfkeysfiltered which uses the ‘quick’ search path setting. It is the \pgfqkeys variant of \pgfkeysfiltered, see the documentation for \pgfqkeys for more details.

A variant of \pgfkeysalso which loads its key list from {⟨macro⟩}.

It is useful in conjunction with the /pgf/key filter handlers/append filtered to=⟨macro⟩ handler.

The following example uses the same settings as in the intro section 87.6.1.

This command works as \pgfkeysfiltered, but it does not change the current default path. See the documentation of \pgfkeysalso for more details.

A variant of \pgfkeysalsofiltered which loads its key list from {⟨macro⟩}.

This handler installs a key filter. A key filter is a command key which sets the TeX-boolean \ifpgfkeysfiltercontinue, that means a key with existing ‘/.@cmd’ suffix. A simple example is a key filter which returns always true:

If key filters require arguments, they are installed by .install key filter as well. An example is the /pgf/key filters/equals handler:

If a key filter requires more than one argument, you need to provide the complete argument list in braces like {{first}{second}}.

You can also use \pgfkeysinstallkeyfilter⟨full key⟩⟨optional arguments⟩, it has the same effect.

See section 87.6.7 for how to write key filters.

This handler installs the routine which will be invoked for every unprocessed option, that means any option for which the key filter returned ‘false’.

The .install key filter handler is used in the same way as .install key filter. There exists a macro version, \pgfkeysinstallkeyfilterhandler⟨full key⟩⟨optional arguments⟩, which has the same effect.

See section 87.6.7 for how to write key filter handlers.

Install this filter handler to append any unprocessed options to macro {⟨macro⟩}.

This example uses the same keys as defined in the intro section 87.6.1.

Install this filter handler if you simply want to ignore any unprocessed option. This is the default.

This key filter handler writes messages for any unprocessed option to your logfile (and terminal).

Defines a new family. This option has already been described in section 87.4.1.

Activates a family. The family needs to be defined, otherwise /errors/family unknown will be raised.

Activation means a TeX-boolean will be set to true, indicating that a family should be processed.

You can also use \pgfkeysactivatefamily⟨full path⟩ to get the same effect. Furthermore, you can use \pgfkeysactivatefamilies⟨list of families⟩⟨macro name for de-activation⟩ to activate a list of families (see section 87.6.6).

Deactivates a family. The family needs to be defined, otherwise /errors/family unknown will be raised.

You can also use \pgfkeysdeactivatefamily⟨full path⟩ to get the same effect.

Associates the current option with {⟨family name⟩}, which is expected to be a full path of a family.

Each option can have up to one family, .belongs to family overwrites any old setting.

Install this key filter if \pgfkeysfiltered should only process activated families. If a key does not belong to any family, it is not processed. If a key is completely unknown within the default path, the normal ‘unknown’ handlers of \pgfkeys are invoked.

This key filter configures \pgfkeysfiltered to work as follows.

• 1. If the current key belongs to a family, set \ifpgfkeysfiltercontinue to true if and only if its family is active.

• 2. If the current key does not belong to a family, assign \ifpgfkeysfiltercontinue as result of {⟨key filter 1⟩}.

• 3. If the current key is unknown within the default path, assign \ifpgfkeysfiltercontinue as result of {⟨key filter 2⟩}.

The arguments {⟨key filter 1⟩} and {⟨key filter 2⟩} are other key filters (possibly with options) and allow fine-grained control over the filtering process.

This key filter will return true for any option with active family. If an option has no family, the return value is true if and only if it belongs to /tikz. If the option is unknown, the return value is false and unknown handlers won’t be called.

A variant of active families or no family which protocols each action on your terminal (log-file).

A fast alias for

/pgf/key filters/active families or no family=

{/pgf/keys filters/false}

{/pgf/keys filters/false}.

A fast alias for

/pgf/key filters/active families or no family=

{/pgf/keys filters/is descendant of={⟨path prefix⟩}}

{/pgf/keys filters/false}.

A simple shortcut macro which activates any family in the comma separated {⟨family list⟩}, invokes \pgfkeysfiltered⟨key–value-list⟩ and deactivates the families afterwards.

Please note that you will need to install a family key filter, otherwise family activation has no effect.

The ‘quick’ default path variant of \pgfkeysactivatefamiliesandfilteroptions.

A shortcut macro which activates a single family and invokes \pgfkeysfiltered.

Please note that you will need to install a family key filter, otherwise family activation has no effect.

The ‘quick’ default path variant of \pgfkeysactivatesinglefamilyandfilteroptions.

Install this key filter to process only options belonging to the key tree ⟨path⟩. It returns true for every key whose key path is equal to ⟨path⟩. It also returns true for any unknown key, that means unknown keys are processed using the standard unknown handlers of pgf.

Install this key filter to process only the fully qualified option {⟨full key⟩}. The filter returns true for any unknown key or if the key equals {⟨full key⟩}.

This key filter logically inverts the result of {⟨key filter⟩}.

Please note that unknown keys will be handed to the usual unknown handlers.

This key filter returns true if and only if both, {⟨key filter 1⟩} and {⟨key filter 2⟩} return true.

This key filter returns true if one of {⟨key filter 1⟩} and {⟨key filter 2⟩} returns true.

This key filter returns always true.

This key filter returns always false (including unknown keys).

This key filter returns false if the current key is unknown, which avoids calling the unknown handlers.

Temporarily disables key filtering inside the environment. If key filtering is not active, this has no effect at all.

Please note that no TeX-group is introduced.

Creates {⟨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.

The command \pgfkeysinstallkeyfilter{⟨full key⟩}{⟨optional arguments⟩} has the same effect as \pgfkeys{⟨full key⟩/.install key filter={⟨optional arguments⟩}}.

The command \pgfkeysinstallkeyfilterhandler{⟨full key⟩}{⟨optional arguments⟩} has the same effect as \pgfkeys{⟨full key⟩/.install key filter handler={⟨optional arguments⟩}}.

Equivalent to \pgfkeys{⟨family name⟩/.activate family}.

Equivalent to \pgfkeys{⟨family name⟩/.deactivate family}.

Activates each family in ⟨family list⟩ and creates a macro ⟨deactivate macro name⟩ which deactivates each family in ⟨family list⟩.

Checks whether the full key ⟨family⟩ is a family and executes either ⟨true case⟩ or ⟨false case⟩.

Sets the TeX-boolean \ifpgfkeysfiltercontinue to whether ⟨family⟩ is active or not.

Returns the family associated to a ⟨full key⟩ into macro ⟨resultmacro⟩.

The command \pgfkeyssetfamily{⟨full key⟩}{⟨family⟩} has the same effect as \pgfkeys{⟨full key⟩/.belongs to family={⟨family⟩}}.

Evaluates a fully qualified key filter ⟨full key⟩ with argument(s) ⟨filter arguments⟩.