Return a copy of this parm template.

This method can be called on an instance of a ParmTemplate subclass and an instance of the subclass is properly returned.

Return the internal name of the parm template. This is the name that hou.ParmTuple objects created from this parm template will have.

Tha names of hou.ParmTemplate objects inside a multiparm block will have a “#” at the end of their name which will be replaced by the multiparm instance number when an the hou.ParmTuple object is instantiated.

Note that the names of hou.Parm objects inside ParmTuples based off this ParmTemplate are determined by this name, the number of components in this parm template, and the naming scheme. See the namingScheme method for more information.

Change the internal name of this parm template. Remember that ParmTemplates just store data, so the name change will not have any effect unless this parm template is later used to modify a parameter layout in Houdini.

Parameters inside a multiparm block must have a “#” at the end of their name which will be replaced by the multiparm’s instance number.

Return the name of the parameter tuple that is displayed in the parameter pane.

Change the name of the label that is displayed in the parameter pane.

Return the enumerated value identifying the type of this parameter.

Remember that ParmTemplate objects are always instances of a subclass of this class. The following table shows the mapping between hou.parmTemplateType enumeration values and ParmTemplate subclasses:

Return the data type stored in hou.Parm instances inside hou.ParmTuple instances corresponding to this ParmTemplate.

For example, suppose this parm tuple is a hou.FloatParmTemplate with 3 components. The corresponding hou.ParmTuple will have 3 hou.Parm objects inside it, and each will store a floating point value. In this example, this method would return hou.parmData.Float.

Return the number of values stored inside hou.ParmTuple instances of this ParmTemplate.

For example, if this parm template has 3 components, there will be 3 parameter fields displayed in the parameter pane and there will be 3 hou.Parm objects inside a hou.ParmTuple based off this parm template.

Set the number of values stored inside hou.ParmTuple instances of this ParmTemplate.

Note that some ParmTemplate subclasses only support one component, so calling this method with a value other than 1 may raise a hou.OperationFailed exception. Also, changing the number of components may automatically change the size of the tuple of default values for some ParmTemplate subclasses.

Return the naming scheme used to name parameters inside the parm tuple for this ParmTemplate.

For example, if the naming scheme is hou.parmNamingScheme.XYZW and the parm template is named "foo" and has 3 components, the parameters will be named "foox", "fooy", and "fooz". On the other hand, if the naming scheme was hou.parmNamingScheme.Base1, the parameters would be named "foo1", "foo2", and "foo3".

Note that when the parm template only has 1 component, the parm name is the same as the parm tuple name.

See hou.parmNamingScheme for more information.

Set the naming scheme used to name parameters inside the parm tuple for this ParmTemplate to a hou.parmNamingScheme enum value.

See the namingScheme method for more information.

Return the look of this parameter in the parameter pane. For example, a tuple of 3 floats can be displayed as a 3D vector or as an RGB color.

See hou.parmLook for more information.

Set the look of this parameter to a hou.parmLook enum value.

See the look method for more information.

Return the help that Houdini displays when you hover over the parameter label in the parameter pane.

Set the help that Houdini displays when you hover over the parameter label in the parameter pane.

Return whether this parameter is hidden in the parameter pane.

Marks this parameter as visible or invisible in the parameter pane.

Note that hidden parameters still exist, and can be evaluated, channel-referenced, etc. They simply will not be displayed in the parameter pane.

Return whether the label for this parameter is hidden in the parameter pane.

Hide or show the label for this parameter in the parameter pane.

Return whether this parameter is displayed on the same line as the next parameter in the parameter pane.

This method is deprecated in favor of the joinsWithNext method.

Sets whether this parameter is displayed on the same line as the next parameter in the parameter pane.

This method is deprecated in favor of the conditionals method.

This method is deprecated in favor of the setConditional method.

Returns the set of conditionals currently affecting this parameter.

See the Conditionals section of the Operator Type Properties window help for more information on this string.

Set a conditional string of the given hou.parmCondType type for this parameter. This string consists of rules on how this parameter’s display behaves when other parameters change.

See the Conditionals section of the Operator Type Properties window help for more information on this string.

Return a dictionary of extra data stored in the parm template.

Houdini uses this dictionary to attach arbitrary data to parm templates. The keys in this dictionary vary depending on the ParmTemplate type and its use.

Return the contents of the script that Houdini runs when this parameter changes. This script is most commonly used in hou.ButtonParmTemplate objects to respond to the button being pressed.

Note that Houdini uses the tags dictionary to store the script callback information.

Set the callback script to the given string. This script runs in response to a parameter change.

See the scriptCallback method for more information.

Return the language of the script that Houdini runs when this parameter changes.

Note that Houdini uses the tags dictionary to store the script callback information.

See also the scriptCallback method.

Set the script callback language to a hou.scriptLanguage enum value.

See the scriptCallbackLanguage method for more information.

Set the dictionary of extra data stored in this parm template.

See the tags method for more information.

Return a string containing Python statements that can be executed to recreate the parameter template. To run the string, use Python’s compile, or execfile functions or the exec statement.

Here is an example of saving the output to a file and then loading it back into Houdini:

# Get a reference to the target parameter template.
node = hou.node("/obj/geo1")
parm_template = node.parm("tx").parmTemplate()

# Execute asCode and write the output script to a file.
code = parm_template.asCode()
source_file = open("create_parm_template.py", "w")
source_file.write(code)
source_file.close()

# Execute the script.  The new parameter template will be stored 
# in the 'hou_parm_template' variable.
execfile("create_parm_template.py")

# Add a spare parameter to the node using the saved parameter
# template.
node.addSpareParmTuple(hou_parm_template)

Here is an example of saving the output into a function in a file and then calling it from Houdini:

# Get a reference to the target parameter template.
node = hou.node("/obj/geo1")
parm_template = node.parm("tx").parmTemplate()

# Execute asCode and write the function definition to a file.
code = parm_template.asCode(function_name="createParmTemplate")
source_file = open("parmtemplatelib.py", "w")
source_file.write(code)
source_file.close()

# Call the function definition.
import parmtemplatelib
hou_parm_template = parmtemplatelib.createParmTemplate()

# Add a spare parameter to the node using the saved parameter
# template.
node.addSpareParmTuple(hou_parm_template)