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", DynamicModule 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.
DynamicModule 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.
TaggingRules 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.
TaggingRules 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".
"TagName" returns Inherited 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 to True or False.
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.
TaggingRules 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.