Adding Presets to Global Context Variables - Revision history

Ericmehl at 21:07, 23 July 2024

2024-07-23T21:07:32Z

← Older revision		Revision as of 14:07, 23 July 2024
Line 82:		Line 82:

	=== Adding Presets to a Menu ===		=== Adding Presets to a Menu ===
	Global context variables can also be controlled from a customized menu in Gaffer's main application menu. In a script in your <code>~/gaffer/startup/gui</code> directory add the following code. It will add new menu item to Gaffer called <code>Shot</code>. Each time the user opens it, it will be rebuilt by the method `__shotMenu()`, which you can customize to populate the shot menu with shot names from any source accessible to Python such as a node in the node graph or an external database.<~~pre~~>		Global context variables can also be controlled from a customized menu in Gaffer's main application menu. In a script in your <code>~/gaffer/startup/gui</code> directory add the following code. It will add new menu item to Gaffer called <code>Shot</code>. Each time the user opens it, it will be rebuilt by the method <code>__shotMenu()</code>, which you can customize to populate the shot menu with shot names from any source accessible to Python such as a node in the node graph or an external database.
			<syntaxhighlight lang="python">
	import functools		import functools

Line 148:		Line 149:
	scriptWindowMenu = GafferUI.ScriptWindow.menuDefinition( application )		scriptWindowMenu = GafferUI.ScriptWindow.menuDefinition( application )
	scriptWindowMenu.append( "/Shot", { "subMenu": __shotMenu } )		scriptWindowMenu.append( "/Shot", { "subMenu": __shotMenu } )
	</~~pre~~>		</syntaxhighlight>

Ericmehl at 21:00, 23 July 2024

2024-07-23T21:00:55Z

← Older revision		Revision as of 14:00, 23 July 2024
Line 80:		Line 80:
	globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )		globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )
	</syntaxhighlight>		</syntaxhighlight>

			=== Adding Presets to a Menu ===
			Global context variables can also be controlled from a customized menu in Gaffer's main application menu. In a script in your <code>~/gaffer/startup/gui</code> directory add the following code. It will add new menu item to Gaffer called <code>Shot</code>. Each time the user opens it, it will be rebuilt by the method `__shotMenu()`, which you can customize to populate the shot menu with shot names from any source accessible to Python such as a node in the node graph or an external database.<pre>
			import functools

			import IECore

			import GafferUI


			# This will be called each time the user makes a selection from the `Shot` menu.
			def __setShot( shotPlug, shot, checked ) :
			if shotPlug is not None :
			shotPlug.setValue( shot )

			# This will be called for each menu item when showing the menu. It should return `True`
			# if it should be checked and `False` if it should not be.
			def __activeShot( shotPlug, shot ) :
			if shotPlug is not None :
			return shotPlug.getValue() == shot

			# This will be called each time the user opens the `Shot` menu. It should return an
			# `IECore.MenuDefinition` object representing the menu.
			def __shotMenu( menu ) :
			globalContextVariable = "shot"
			# Populate the menu with placeholder item if no plug is found for `globalContextVariable`
			defaultItems = [ "None" ]

			scriptWindow = menu.ancestor(GafferUI.ScriptWindow)
			currentScript = scriptWindow.scriptNode()

			# Find the plug for the value of the global context variable.
			shotPlug = None
			for p in currentScript["variables"] :
			if p["name"].getValue() == globalContextVariable :
			shotPlug = p["value"]

			result = IECore.MenuDefinition()

			if shotPlug is None :
			shotList = defaultItems
			else :
			# Hardcoded shot list
			shotList = ["shotA", "shotB", "shotC"]

			# Shot list from the enabled rows of a spreadsheet named "shots"
			# shotList = currentScript["shots"]["enabledRowNames"].getValue()

			# Add a shot for each item in `shotList`. When selecting the item, the `__setShot()`
			# function will be called with the the `shotPlug`, the `shot` value from the loop
			# and a `checked` variable the Gaffer menu system adds.
			# When determining if the item should have a checkmark next to it, `__activeShot()` will
			# be called with the `shotPlug` and `shot` value from the loop.
			for shot in shotList :
			result.append(
			"/" + shot,
			{
			"command": functools.partial( __setShot, shotPlug, shot ) ,
			"checkBox": functools.partial( __activeShot, shotPlug, shot ),
			}
			)

			return result

			# Called once at the start of a Gaffer session. Note that this will not be called
			# on subsequent loading of a script, since the newly created window will be in the same session.
			scriptWindowMenu = GafferUI.ScriptWindow.menuDefinition( application )
			scriptWindowMenu.append( "/Shot", { "subMenu": __shotMenu } )
			</pre>

Murraystevenson at 17:23, 22 July 2024

2024-07-22T17:23:14Z

← Older revision		Revision as of 10:23, 22 July 2024
Line 15:		Line 15:

	==== Set the widget type ====		==== Set the widget type ====
	Next we need to tell Gaffer to use a presets dropdown widget for our value plug. That is done by setting <code>plugValueWidget:type</code> to <code>"GafferUI.PresetsPlugValueWidget"</code> : <~~pre~~>		Next we need to tell Gaffer to use a presets dropdown widget for our value plug. That is done by setting <code>plugValueWidget:type</code> to <code>"GafferUI.PresetsPlugValueWidget"</code> : <syntaxhighlight lang="python">
	Gaffer.Metadata.registerValue( variablePlug, "plugValueWidget:type", "GafferUI.PresetsPlugValueWidget" )		Gaffer.Metadata.registerValue( variablePlug, "plugValueWidget:type", "GafferUI.PresetsPlugValueWidget" )
	</~~pre~~>		</syntaxhighlight>

	==== Set the preset names and values ====		==== Set the preset names and values ====
	Now we add the presets themselves. This can be done in one of two ways. You can add a metadata entry starting with <code>preset:</code> followed by the display string of your preset set to the preset value. For example, <code>Gaffer.Metadata.registerValue( variablePlug, "preset:Shot 1004", "shot1004")</code>will create a preset showing in the UI as <code>Shot 1004</code>. When the user chooses that preset, the actual value of the context variable will be <code>shot1004</code>.		Now we add the presets themselves. This can be done in one of two ways. You can add a metadata entry starting with <code>preset:</code> followed by the display string of your preset set to the preset value. For example, <code>Gaffer.Metadata.registerValue( variablePlug, "preset:Shot 1004", "shot1004")</code>will create a preset showing in the UI as <code>Shot 1004</code>. When the user chooses that preset, the actual value of the context variable will be <code>shot1004</code>.

	The second method sets all of the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>IECoreFloatVectorData</code>.<~~pre~~>		The second method sets all of the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>IECoreFloatVectorData</code>.<syntaxhighlight lang="python">
	Gaffer.Metadata.registerValue( variablePlug, "presetNames", IECore.StringVectorData( presetNames ) )		Gaffer.Metadata.registerValue( variablePlug, "presetNames", IECore.StringVectorData( presetNames ) )
	Gaffer.Metadata.registerValue( variablePlug, "presetValues", IECore.StringVectorData( presetValues ) )		Gaffer.Metadata.registerValue( variablePlug, "presetValues", IECore.StringVectorData( presetValues ) )
	</~~pre~~>		</syntaxhighlight>

	==== Resetting the <code>Settings</code> dialog ====		==== Resetting the <code>Settings</code> dialog ====

	Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. You can force Gaffer to rebuild the <code>Settings</code> dialog by running the following code in the Python editor:<~~pre~~>		Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. You can force Gaffer to rebuild the <code>Settings</code> dialog by running the following code in the Python editor:<syntaxhighlight lang="python">
	sw = GafferUI.ScriptWindow.acquire(root)		sw = GafferUI.ScriptWindow.acquire(root)
	for window in sw.childWindows():		for window in sw.childWindows():
	if hasattr( window, "_settingsEditor" ) :		if hasattr( window, "_settingsEditor" ) :
	sw.removeChild(window)		sw.removeChild(window)
	</~~pre~~>		</syntaxhighlight>

	Once you have registered the metadata for a plug in this way, it will be saved with the script so there is no need to register the metadata again.		Once you have registered the metadata for a plug in this way, it will be saved with the script so there is no need to register the metadata again.
Line 40:		Line 40:
	==== Example Script ====		==== Example Script ====

	The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.<~~pre~~>		The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.
			<syntaxhighlight lang="python">
	# Sets the preset names and values for a global context variable.		# Sets the preset names and values for a global context variable.
	# `scriptNode` is the script node which you want to set global context variables for.		# `scriptNode` is the script node which you want to set global context variables for.
Line 76:		Line 77:
	if hasattr( window, "_settingsEditor" ) :		if hasattr( window, "_settingsEditor" ) :
	sw.removeChild(window)		sw.removeChild(window)
	</~~pre~~>For example, to set a few presets for a global context variable named <code>shot</code> run the script above in the Python editor, then run the line below.<~~pre~~>		</syntaxhighlight>For example, to set a few presets for a global context variable named <code>shot</code> run the script above in the Python editor, then run the line below.<syntaxhighlight lang="python">
	globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )		globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )
	</~~pre~~>		</syntaxhighlight>

Ericmehl at 20:35, 19 July 2024

2024-07-19T20:35:14Z

← Older revision		Revision as of 13:35, 19 July 2024
Line 5:		Line 5:

	=== Adding Presets to the <code>Settings</code> Dialog ===		=== Adding Presets to the <code>Settings</code> Dialog ===
	~~One way of controlling global context variables is through~~ the <code>Settings</code> dialog ~~as described above. Presets can be added here~~ by assigning metadata to the value plug for a global context variable. ~~Before we assign metadata, we need~~ to ~~identify which plug represents~~ the context variable you want to add presets to. Global context variables are stored in the <code>variables</code> child of the script root. In the Python editor, these are accessed by <code>root["variables"]</code>.		Presets can be added to plugs in the <code>Settings</code> dialog by assigning metadata to the value plug for a global context variable. There are three steps to adding the needed metadata.

	The entries in <code>root["variables"]</code> are of the type <code>NameValuePlug</code>. These plugs themselves have three child plugs : <code>name</code>, <code>enabled</code> and <code>value</code>. The <code>name</code> plug sets the name of the context variable and the <code>value</code> sets the value of the variable. The <code>enabled</code> plug is used to enable or disable the variable. Note that the value of <code>name</code> may be different from the name of the actual <code>NameValuePlug</code>. When adding plugs in using the <code>+</code> button in the <code>Settings</code> dialog, the <code>NameValuePlug</code> added will start with <code>member</code> and be followed by the next available number to keep the child names of <code>root["variables"]</code> unique.		==== Identify the target plug ====
			Before we assign metadata, we need to identify which plug represents the context variable you want to add presets to. Global context variables are stored in the <code>variables</code> child of the script node. In the Python editor, these are accessed by <code>root["variables"]</code>.

			The entries in <code>root["variables"]</code> are of the type <code>NameValuePlug</code>. These plugs themselves have three child plugs: <code>name</code>, <code>enabled</code> and <code>value</code>. The <code>name</code> plug sets the name of the context variable and the <code>value</code> sets the value of the variable. The <code>enabled</code> plug is used to enable or disable the variable. Note that the value of <code>name</code> may be different from the name of the actual <code>NameValuePlug</code>.

	To determine which child of <code>root["variables"]</code> you want to add metadata to, loop through all the children of <code>root["variables"]</code> checking the value of the <code>name</code> plug until you find the variable. The corresponding <code>value</code> child plug will be the plug we add metadata to.		To determine which child of <code>root["variables"]</code> you want to add metadata to, loop through all the children of <code>root["variables"]</code> checking the value of the <code>name</code> plug until you find the variable. The corresponding <code>value</code> child plug will be the plug we add metadata to.

	~~The first metadata entry will~~ tell Gaffer to use a presets dropdown ~~as the~~ plug ~~widget~~. That is done by setting <code>plugValueWidget:type</code> to <code>"GafferUI.PresetsPlugValueWidget"</code>.		==== Set the widget type ====
			Next we need to tell Gaffer to use a presets dropdown widget for our value plug. That is done by setting <code>plugValueWidget:type</code> to <code>"GafferUI.PresetsPlugValueWidget"</code> : <pre>
			Gaffer.Metadata.registerValue( variablePlug, "plugValueWidget:type", "GafferUI.PresetsPlugValueWidget" )
			</pre>

			==== Set the preset names and values ====
			Now we add the presets themselves. This can be done in one of two ways. You can add a metadata entry starting with <code>preset:</code> followed by the display string of your preset set to the preset value. For example, <code>Gaffer.Metadata.registerValue( variablePlug, "preset:Shot 1004", "shot1004")</code>will create a preset showing in the UI as <code>Shot 1004</code>. When the user chooses that preset, the actual value of the context variable will be <code>shot1004</code>.

	~~Now we can add~~ the ~~presets themselves~~. ~~That~~ can be done ~~in one of two ways. You can add a metadata entry starting with~~ <code>~~preset:~~</code> ~~followed by the display~~ string ~~of your preset, the value of which is the preset value. For example,~~ <code>~~Gaffer.Metadata~~.~~registerValue( root["variables"]["member1"]["value"], "preset:Shot 1004", "shot1004")~~</code>~~will create a~~ preset ~~on the~~ <code>~~member1~~</code> ~~plug's~~ <code>~~value~~</code> ~~plug called~~ <code>~~Shot 1004~~</code>. ~~When the user chooses that preset, the actual value of the context variable will be~~ <~~code~~>~~shot1004~~</~~code~~>.		The second method sets all of the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>IECoreFloatVectorData</code>.<pre>
			Gaffer.Metadata.registerValue( variablePlug, "presetNames", IECore.StringVectorData( presetNames ) )
			Gaffer.Metadata.registerValue( variablePlug, "presetValues", IECore.StringVectorData( presetValues ) )
			</pre>

	~~The second method sets all of~~ the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>~~IECoreFloatVectorData~~</code>.		==== Resetting the <code>Settings</code> dialog ====

	Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. You can force Gaffer to rebuild the <code>Settings</code> dialog by running the following code in the Python editor :<pre>		Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. You can force Gaffer to rebuild the <code>Settings</code> dialog by running the following code in the Python editor:<pre>
	sw = GafferUI.ScriptWindow.acquire(root)		sw = GafferUI.ScriptWindow.acquire(root)
	for window in sw.childWindows():		for window in sw.childWindows():
Line 23:		Line 35:
	sw.removeChild(window)		sw.removeChild(window)
	</pre>		</pre>

			Once you have registered the metadata for a plug in this way, it will be saved with the script so there is no need to register the metadata again.

			==== Example Script ====

	The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.<pre>		The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.<pre>
Line 60:		Line 76:
	if hasattr( window, "_settingsEditor" ) :		if hasattr( window, "_settingsEditor" ) :
	sw.removeChild(window)		sw.removeChild(window)
	</pre>For example, to set a few presets for a global context variable named <code>shot</code> run the script above in the Python editor, ~~followed by~~ the line below.<pre>		</pre>For example, to set a few presets for a global context variable named <code>shot</code> run the script above in the Python editor, then run the line below.<pre>
	globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )		globalContextPresets( root, "shot", ["shot A", "shot B", "shot C"], IECore.StringVectorData( [ "shotA", "shotB", "shotC" ] ) )
	</pre>		</pre>

Ericmehl at 20:19, 19 July 2024

2024-07-19T20:19:13Z

@@ Line 17: / Line 17: @@
 The second method sets all of the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>IECoreFloatVectorData</code>.
-Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. The last four lines of the following script show how to do that.
+Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. You can force Gaffer to rebuild the <code>Settings</code> dialog by running the following code in the Python editor :<pre>
 The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.<pre>
-#test
+# Sets the preset names and values for a global context variable.
 </pre>

Ericmehl at 20:01, 19 July 2024

2024-07-19T20:01:51Z

← Older revision		Revision as of 13:01, 19 July 2024
Line 1:		Line 1:
	Global context variables can be useful for ensuring a context variable is always accessible and set for the entire script. Unless it is overridden by a [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariables.html ContextVariables] or [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariableTweaks.html ContextVariablesTweaks] node, all nodes will ~~see~~ the global context variable. There are some global context variables added by Gaffer by default when creating a new script. You can see these, and add your own, from the <code>Variables</code> tab in the <code>Settings</code> dialog accessed from the <code>File.Settings</code>menu item.
			Global context variables can be useful for ensuring a context variable is always accessible and set for the entire script. Unless it is overridden by a [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariables.html ContextVariables] or [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariableTweaks.html ContextVariablesTweaks] node in the node graph, all nodes will have access to the same global context variable. There are some global context variables added by Gaffer by default when creating a new script. You can see these, and add your own, from the <code>Variables</code> tab in the <code>Settings</code> dialog accessed from the <code>File.Settings</code>menu item.

			The default user interface for a global context variable can be useful for many situations, but like all plugs in Gaffer, it is possible to customize how the plugs for global context variables are presented to the user. One such customization is adding presets for the user to choose from. This ensures only valid values can be assigned to the context variable. This guide will describe how to add presets to the widget controlling a global context variable.

			=== Adding Presets to the <code>Settings</code> Dialog ===
			One way of controlling global context variables is through the <code>Settings</code> dialog as described above. Presets can be added here by assigning metadata to the value plug for a global context variable. Before we assign metadata, we need to identify which plug represents the context variable you want to add presets to. Global context variables are stored in the <code>variables</code> child of the script root. In the Python editor, these are accessed by <code>root["variables"]</code>.

			The entries in <code>root["variables"]</code> are of the type <code>NameValuePlug</code>. These plugs themselves have three child plugs : <code>name</code>, <code>enabled</code> and <code>value</code>. The <code>name</code> plug sets the name of the context variable and the <code>value</code> sets the value of the variable. The <code>enabled</code> plug is used to enable or disable the variable. Note that the value of <code>name</code> may be different from the name of the actual <code>NameValuePlug</code>. When adding plugs in using the <code>+</code> button in the <code>Settings</code> dialog, the <code>NameValuePlug</code> added will start with <code>member</code> and be followed by the next available number to keep the child names of <code>root["variables"]</code> unique.

			To determine which child of <code>root["variables"]</code> you want to add metadata to, loop through all the children of <code>root["variables"]</code> checking the value of the <code>name</code> plug until you find the variable. The corresponding <code>value</code> child plug will be the plug we add metadata to.

			The first metadata entry will tell Gaffer to use a presets dropdown as the plug widget. That is done by setting <code>plugValueWidget:type</code> to <code>"GafferUI.PresetsPlugValueWidget"</code>.

			Now we can add the presets themselves. That can be done in one of two ways. You can add a metadata entry starting with <code>preset:</code> followed by the display string of your preset, the value of which is the preset value. For example, <code>Gaffer.Metadata.registerValue( root["variables"]["member1"]["value"], "preset:Shot 1004", "shot1004")</code>will create a preset on the <code>member1</code> plug's <code>value</code> plug called <code>Shot 1004</code>. When the user chooses that preset, the actual value of the context variable will be <code>shot1004</code>.

			The second method sets all of the preset names and all of the values in one step each. This can be done by setting the <code>presetNames</code> metadata entry to a Cortex string vector (<code>IECore.StringVectorData</code>)holding all of the preset names. Setting <code>presetValues</code> to a Cortex vector of some type, such as <code>IECoreStringVectorData</code> or <code>IECoreFloatVectorData</code>.

			Note that the <code>Settings</code> UI is built once and then reused for subsequent showings. This means after adding presets, you need to force Gaffer to refresh the <code>Settings</code> dialog. The last four lines of the following script show how to do that.

			The following script is an example of all of the above steps condensed into a reusable function for adding presets for a global context variable.<pre>
			#test
			</pre>

Ericmehl: Created page with "Global context variables can be useful for ensuring a context variable is always accessible and set for the entire script. Unless it is overridden by a [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariables.html ContextVariables] or [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariableTweaks.html ContextVariablesTweaks] node, all nodes will see the global context variable. There are some g..."

2024-07-16T21:34:07Z

Created page with "Global context variables can be useful for ensuring a context variable is always accessible and set for the entire script. Unless it is overridden by a [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariables.html ContextVariables] or [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariableTweaks.html ContextVariablesTweaks] node, all nodes will see the global context variable. There are some g..."

New page

Global context variables can be useful for ensuring a context variable is always accessible and set for the entire script. Unless it is overridden by a [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariables.html ContextVariables] or [https://www.gafferhq.org/documentation/1.4.8.0/Reference/NodeReference/Gaffer/ContextVariableTweaks.html ContextVariablesTweaks] node, all nodes will see the global context variable. There are some global context variables added by Gaffer by default when creating a new script. You can see these, and add your own, from the <code>Variables</code> tab in the <code>Settings</code> dialog accessed from the <code>File.Settings</code>menu item.