Storing and Tracking Palette States
Palettes can be configured to remember their previous states across front end sessions. This is useful for palettes containing multiple expandable sections, tab views, checkboxes, and other control objects. For example, a user who has gone to the trouble of closing nine of 10 opener views would not expect to have to do so again every time he or she opens the palette.
There are several ways Mathematica
can store and track control object states. The first method involves dynamic variables and the second, TaggingRules
. Dynamic variables tracked by DynamicModule
are stored in the notebook expression and therefore require that the palette notebook be savable in order to save the changes. TaggingRules
, on the other hand, is cached by the front end in a separate file for palette notebooks located on PalettePath
. This means that the palette notebook itself need not be savable for the state to be stored. Furthermore, if the TaggingRules
are stored as options at the notebook level, the values can be accessed from other notebooks using expressions similar to Options[Get["filepath"], TaggingRules]
As described in "Advanced Dynamic Functionality"
maintains the values of dynamic variables in the output of an evaluation. However, DynamicModule
is inappropriate for storing values in palettes that should persist across sessions. In order for DynamicModule
values to persist, the document containing the DynamicModule
must be saved, and palettes may be stored in locations where saving them is absolutely forbidden.
is perfectly acceptable for storing values that should be reset each time a palette is opened. Here is an example of two control objects and two dynamic variables.
In this next palette, both checkboxes can be checked or unchecked by clicking either the plus or minus button. The buttons set new dynamic variable values for the control object states.
Two control objects can be controlled with the same dynamic variable so that both check and uncheck simultaneously.
is an option for cells, notebooks, and the front end that provides a way of storing additional information with a selection. This is useful when storing metadata with a cell or attaching values to a cell to call during a notebook search, evaluation, or other operation. TaggingRules
can be a list of strings or rules.
Here are two basic examples of TaggingRules
at the notebook level; the first is a rule and the second is a list of rules.
can also be used to store values for control object states in palette notebooks saved on PalettePath
. The front end automatically caches the current values of the tagging rules in the global option
for use in later front end sessions.
This means that palettes with explicit tagging rules are guaranteed to remember their control object states across different front end sessions. For example, if a user opened an opener tracked by a tagging rule and then closed the front end, the opener would still be open when the user re-opened the palette during a later front end session.
Tagging rules for palette notebooks are implemented as a rule or nested rules and the control object states set these tagging rule values using dynamic CurrentValue
statements similar to the following example for the tagging rule "TagName"
unless initial values have been provided. In the next example, the state of the Checkbox
is tracked by "TagName2"
with the initial value of True
. Checking or unchecking the Checkbox
will change the value of the TaggingRules
Multiple control object states can be tracked at the same time. Below, the states of the two openers are tracked by "MyOpenerValue1"
with initial values.
Once tagging values have been assigned to control object states, buttons or other controls can be created to modify groups of these values. Here, both openers can be expanded or closed by clicking either the plus or minus button. The buttons set new option values for the control object states, which dynamically update.
Two control objects can be tagged with the same TaggingRules
value so that both open and close simultaneously.
Tagging rules can be organized so that expanding one opener on a palette automatically closes the other. In this example, the second argument of Dynamic
is used to control the state of the opposite opener.
can also be inspected from outside the notebook if you have the NotebookObject
corresponding to the notebook you wish to inspect. CreatePalette
always returns a NotebookObject
that can be used for this purpose.
Values can also be set from outside the notebook by simply assigning a value to the appropriate CurrentValue
expression as if it were a variable. This can be useful for debugging purposes or for interfaces where multiple palettes or notebooks interact with each other.