Difference between revisions of "TDFunctions"

From TouchDesigner Documentation
Jump to: navigation, search
m
Line 1: Line 1:
=Summary=
+
{{lowercase}}
 +
{{#index:TDFunctions}}
 +
{{TDClassSummary|label=tdu|summary=The '''TDFunctions''' module provides a variety of Python utility functions for TouchDesigner. To use TDFunctions put the following line at the top of your Python script:
  
The '''TDFunctions''' module provides a variety of Python utility functions for TouchDesigner. To use TDFunctions put the following line at the top of your Python script:
+
<syntaxhighlight lang=python>TDF = op.TDModules.mod.TDFunctions</syntaxhighlight>
 
 
<code>TDF = op.TDModules.mod.TDFunctions</code>
 
  
 
You can now use any of the following functions by calling:
 
You can now use any of the following functions by calling:
  
<code>TDF.<function name>(...)</code>
+
<syntaxhighlight lang=python>TDF.<function name>(...)</syntaxhighlight>}}
 
+
<section begin=HELPBODY />
=Functions=
+
{{ClassMethodSection|empty=
 
+
|Sectionsummary=
<!--PYHMVK clamp-->
+
|items=
'''<code>clamp(value, inMin, inMax)</code>''' &rarr; '''<code>clamped value</code>'''
+
{{ClassMethod
:'''Deprecated:''' [[Tdu Module|tdu]].clamp works the same and is faster
+
    |class=TDF
:returns the value clamped between <code>inMin</code> and <code>inMax</code>.
+
    |name=clamp
:* <code>value</code> - the value to be clamped.
+
    |call=clamp(value, inMin, inMax)
:* <code>inMin</code> - the minimum value.
+
    |returns=float
:* <code>inMax</code> - the maximum value.
+
    |text=returns the value clamped between inMin and inMax.
<!--PYHEND-->
+
*value - The value to be clamped.
 
+
*inMin - The minimum value.
<!--PYHMVK parentLevel-->
+
*inMax - The maximum value.}}
'''<code>parentLevel(parentOp, childOp)</code>''' &rarr; '''<code>depth of parenthood or None</code>'''
+
{{ClassMethod
:determines if <code>parentOp</code> is a parent of <code>childOp</code> at any depth. Returns None or the depth of parenthood. i.e. <code>childOp.parent(<returnValue>)</code> will yield <code>parentOp</code>. This method returns <code>None</code> if <code>childOp</code> is not a child of <code>parentOp</code>. '''Note:''' <code>childOp.parent(<returnValue>)</code> will error in that case.
+
    |class=TDF
:* <code>parentOp</code> - the parent to be evaluated.
+
    |name=parentLevel
:* <code>childOp</code> - the child to be evaluated.
+
    |call=parentLevel(parentOp, childOp)
<!--PYHEND-->
+
    |returns=OP or None
 
+
    |text=determines if parentOp is a parent of childOp at any depth. Returns None or the depth of parenthood. i.e. childOp.parent(<returnValue>) will yield parentOp. This method returns None if childOp is not a child of parentOp.
<!--PYHMVK sharedParent-->
+
   
'''<code>sharedParent(op1, op2)</code>''' &rarr; '''<code>closest parent</code>'''
+
'''Note:'''' childOp.parent(<returnValue>) will error in that case.
:Returns the nearest shared parent of <code>op1</code> and <code>op2</code>. Returns <code>None</code> if root is result.
+
*parentOp - The parent to be evaluated.
:* <code>op1</code> - the first operator.
+
*childOp - The child to be evaluated.}}
:* <code>op2</code> - the second operator.
+
{{ClassMethod
<!--PYHEND-->
+
    |class=TDF
 
+
    |name=sharedParent
<!--PYHMVK getShortcutPath-->
+
    |call=sharedParent(op1, op2)
'''<code>getShortcutPath(fromOp, toOp)</code>''' &rarr; '''<code>path expression</code>'''
+
    |returns=OP or None
:Return a shortcut path expression from <code>fromOp</code> to <code>toOp</code>. This expression is suitable for use in any OP parameter expression on <code>fromOp</code>. The expression will incorporate [[Parent Shortcut| Parent Shortcuts]] and [[Global OP Shortcut|Global OP Shortcuts]]. '''Note:''' because there are multiple ways to create a shortcut expression, the result of this function will always be a best guess.
+
    |text=Returns the nearest shared parent of op1 and op2. Returns None if root is result.
 
+
*op1 - The first operator.
:* <code>fromOp</code> - the operator to generate expression from.
+
*op2 - The second operator.}}
:* <code>toOp</code> - the operator to generate expression to.
+
{{ClassMethod
<!--PYHEND-->
+
    |class=TDF
 
+
    |name=getShortcutPath
<!--PYHMVK panelParentShortcut-->
+
    |call=getShortcutPath(fromOp, toOp)
'''<code>panelParentShortcut(panel, parentShortcut)</code>''' &rarr; '''<code>Panel Comp</code>'''
+
    |returns=path expression
:Return the first <code>panelParent</code> of panel that has the provided [[Parent Shortcut|parentShortcut]]. Returns <code>None</code> if no <code>panelParent</code> with shortcut is found.
+
    |text=Return a shortcut path expression from fromOp to toOp. This expression is suitable for use in any OP parameter expression on fromOp. The expression will incorporate [[Parent Shortcut|Parent Shortcuts]] and [[Global OP Shortcut|Global OP Shortcuts]].
 
+
   
:* <code>panel</code> - the panel to start searching at.
+
'''Note:''' because there are multiple ways to create a shortcut expression, the result of this function will always be a best guess.
:* <code>parentShortut</code> - the parent shortcut to look for.
+
*fromOp - the operator to generate expression from.
<!--PYHEND-->
+
*toOp - the operator to generate expression to.}}
 
+
{{ClassMethod
<!--PYHMVK parMenu-->
+
    |class=TDF
'''<code>parMenu(menuNames, menuLabels=None)</code>''' &rarr; '''<code>menuSource object</code>'''
+
    |name=panelParentShortcut
:Returns an object suitable for menuSource property of [[Par Class|parameters]].
+
    |call=panelParentShortcut(panel, parentShortcut)
:* <code>menuNames</code> - a list of strings for menu values.
+
    |returns=Panel COMP or None
:* <code>menuLabels</code> - '''(Optional)''' a list of strings for menu labels. Defaults to menuNames.
+
    |text=Return the first panelParent of panel that has the provided [[Parent shortcut|parentShortcut]]. Returns None if no panelParent with shortcut is found.
<!--PYHEND-->
+
*panel - the panel to start searching at.
 
+
*parentShortcut - the parent shortcut to look for.}}
<!--PYHMVK incrementStringDigits-->
+
{{ClassMethod
'''<code>incrementStringDigits(string, min=1)</code>''' &rarr; '''<code>new string</code>'''
+
    |class=TDF
:Method for iterating a string with digits on the end, or adding digits if none are there. This simulates the automatic naming of duplicate operators.
+
    |name=parMenu
:* <code>string</code> - the string to add digits to.
+
    |call=parMenu(menuNames, menuLabels=None)
:* <code>min</code> - '''(Optional)''' the number to add if string doesn't have a number already.
+
    |returns=menuSource object
<!--PYHEND-->
+
    |text=Returns an object suitable for menuSource property of [[Par Class|parameters]].
 
+
*menuNames - A list of strings for menu values.
<!--PYHMVK findNetworkEdges-->
+
*menuLabels - (Optional) A list of strings for menu labels. Defaults to menuNames.}}
'''<code>findNetworkEdges(comp, ignoreNodes=None)</code>''' &rarr; '''<code>info dictionary</code>'''
+
{{ClassMethod
:A utility for placing nodes in a network. Returns a dictionary of 'nodes' and 'positions' at extremes of network. Returns None if no nodes found. Dictionary keys are 'top', 'left', 'right', 'bottom'.
+
    |class=TDF
:* <code>comp</code> - the network to analyze.
+
    |name=incrementStringDigits
:* <code>ignoreNodes</code> - '''(Optional)''' a list of nodes to ignore during analysis.
+
    |call=incrementStringDigits(string, min=1)
<!--PYHEND-->
+
    |returns=string
 
+
    |text=Method for iterating a string with digits on the end, or adding digits if none are there. This simulates the automatic naming of duplicate operators.
<!--PYHMVK arrangeNode-->
+
*string - The string to add digits to.
'''<code>arrangeNode(node, position='bottom', spacing=20)</code>'''
+
*min - (Optional) The number to add if string doesn't have a number already.}}
:Place a node according to the other nodes in the network.
+
{{ClassMethod
:* <code>node</code> - the node to move.
+
    |class=TDF
:* <code>position</code> - '''(Optional)''' can be 'bottom', 'top', 'left' or 'right'. left, right will be placed parallel with top nodes. top, bottom will be placed parallel with left nodes.
+
    |name=findNetworkEdges
:* <code>spacing</code> - '''(Optional)''' distance from network edge.
+
    |call=findNetworkEdges(comp, ignoreNodes=None)
<!--PYHEND-->
+
    |returns=dict or None
 
+
    |text=A utility for placing nodes in a network. Returns a dictionary of 'nodes' and 'positions' at extremes of network. Returns None if no nodes found. Dictionary keys are 'top', 'left', 'right', 'bottom'.
<!--PYHMVK createProperty-->
+
*comp - The network to analyze.
'''<code>createProperty(classInstance, name, value=None, attributeName=None, readOnly=False, dependable=False)</code>'''
+
*ignoreNodes - (Optional) A list of nodes to ignore during analysis.}}
:Use this method to add a property to a class. '''WARNING''': the property is added to the '''class''' of instance, so all objects of instance's class will now have this property.
+
{{ClassMethod
:* <code>classInstance</code> - an instance of the class to add a property to. This is usually 'self' in the __init__ method of the class.
+
    |class=TDF
:* <code>name</code> - the name of the property. Must be a valid Python object name.
+
    |name=arrangeNode
:* <code>value</code> - '''(Optional)''' the starting value of the property.
+
    |call=arrangeNode(node, position='bottom', spacing=20)
:* <code>attributeName</code> - '''(Optional)''' the attribute name used to store the value of the property. Defaults to <code>_<name></code>.
+
    |returns=float
:* <code>readOnly</code> - '''(Optional)''' if True, the property will be read only. A read only property can be changed via the attributeName. If the property is dependable, use attributeName.val.
+
    |text=Place a node according to the other nodes in the network.
:* <code>dependable</code> - '''(Optional)''' if True, the value will be dependable. If set to "deep", collections will be deeply dependable.
+
*node - The node to move.
<!--PYHEND-->
+
*position - (Optional) Can be 'bottom', 'top', 'left' or 'right'. left, right will be placed parallel with top nodes. top, bottom will be placed parallel with left nodes.
 
+
*spacing - (Optional) Distance from network edge.}}
<!--PYHMVK makeDeepDependable-->
+
{{ClassMethod
'''<code>makeDeepDependable(value)</code>''' &rarr; '''<code>dependency object</code>'''
+
    |class=TDF
:returns a [[TDStoreTools#Deeply_Dependable_Collections|deeply dependable]] object out of the provided python object. Deeply dependable collections will cause cooks when their contents change.
+
    |name=createProperty
:* <code>value</code> - the value of the deep dependable object.
+
    |call=createProperty(classInstance, name, value=None, attributeName=None, readOnly=False, dependable=False)
<!--PYHEND-->
+
    |returns=None
 
+
    |text=Use this method to add a property to a class.  
<!--PYHMVK forceCookNonDatOps-->
 
'''<code>forceCookNonDatOps(comp)</code>'''
 
:Recursively force cook op and all children of <code>comp</code>, unless they are DATs
 
<!--PYHEND-->
 
 
 
<!--PYHMVK showInPane-->
 
'''<code>showInPane(operator, pane='Floating', inside=False)</code>''' &rarr; '''<code>pane</code>'''
 
:Open an operator for viewing in a chosen editor pane. The pane will be focused on the chosen operator unless inside is True, in which case it will show the inside if possible.
 
:* <code>operator</code> - the operator to view.
 
:* <code>pane</code> - '''(Optional)''' a ui.pane or 'Floating' for a new floating pane.
 
:* <code>inside</code> - '''(Optional)''' if inside is True, try to show view inside comps.
 
<!--PYHEND-->
 
 
 
<!--PYHMVK tScript-->
 
'''<code>tScript(cmd)</code>'''
 
:Run a tscript command. This is slow because it creates and destroys an operator. If you need this to be faster, build an optimized network with its own tscript DAT.
 
:* <code>cmd</code> - tScript command to run.
 
<!--PYHEND-->
 
 
 
<!--PYHMVK parStringToIntList-->
 
'''<code>parStringToIntList(parString)</code>'''  &rarr; '''<code>int list</code>'''
 
:Convert a space delimited string to a list of ints.
 
:* <code>parString</code> - space delimited list of ints.
 
<!--PYHEND-->
 
 
 
<!--PYHMVK listToParString-->
 
'''<code>listToParString(l)</code>'''  &rarr; '''<code>space delimited string list</code>'''
 
:Convert a list to a space delimited string.
 
:* <code>l</code> - a python list.
 
<!--PYHEND-->
 
 
 
<!--PYHMVK replaceOp-->
 
'''<code>replaceOp(dest, source=None)</code>'''
 
:Replace <code>dest</code> with an exact copy of <code>source</code>. If <code>source</code> is <code>None</code> and <code>dest</code> is a comp, try to use <code>dest</code>'s clone parameter.
 
:* <code>dest</code> - the OP to be replaced.
 
:* <code>source</code> - '''(Optional)''' the OP to replace with. If <code>None</code>, use dest's clone source.
 
<!--PYHEND-->
 
 
 
<!--PYHMVK getParInfo-->
 
'''<code>getParInfo(sourceOp, pattern='*', names=None, includeCustom=True, includeNonCustom=True)</code>''' &rarr; '''<code>parInfo dict</code>'''
 
:Returns a parInfo dict for <code>sourceOp</code>. The format of a parInfo dict is <code>{<parName>:(parVal, parExpr, parMode)...}</code>
 
:* <code>sourceOp</code> - the operator to look for pars on.
 
:* <code>pattern</code> - '''(Optional)''' a pattern match string for par names.
 
:* <code>names</code> - '''(Optional)''' a list of specific names to include. None means include all.
 
:* <code>includeCustom</code> - '''(Optional)''' include custom parameters.
 
:* <code>includeNonCustom</code> - '''(Optional)''' include non-custom parameters.
 
<!--PYHEND-->
 
 
 
<!--PYHMVK applyParInfo-->
 
'''<code>applyParInfo(targetOp, parInfo)</code>'''
 
:Apply par values, expressions, and modes from <code>parInfo</code> dict to <code>targetOp</code>. The format of a parInfo dict is <code>{<parName>:(parVal, parExpr, parMode)...}</code>
 
:* <code>targetOp</code> - the operator to apply values to.
 
:* <code>parInfo</code> - the parInfo dict.
 
<!--PYHEND-->
 
  
<noinclude>[[Category:TD Python Modules]]</noinclude>
+
'''WARNING:''' the property is added to the class of instance, so all objects of instance's class will now have this property.
[[Category:TDPages]]
+
*classInstance - An instance of the class to add a property to. This is usually 'self' in the __init__ method of the class.
[[Category: Python‏‎]]
+
*name - The name of the property. Must be a valid Python object name.
 +
*value - (Optional) The starting value of the property.
 +
*attributeName - (Optional) The attribute name used to store the value of the property. Defaults to _<name>.
 +
*readOnly - (Optional) If True, the property will be read only. A read only property can be changed via the attributeName. If the property is dependable, use attributeName.val.
 +
*dependable - (Optional) If True, the value will be dependable. If set to "deep", collections will be deeply dependable.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=makeDeepDependable
 +
    |call=makeDeepDependable(value)
 +
    |returns=dependency object
 +
    |text=Returns a [[TDStoreTools#Deeply_Dependable_Collections|deeply dependable]] object out of the provided python object. Deeply dependable collections will cause cooks when their contents change.
 +
*value - The value of the deep dependable object.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=forceCookNonDatOps
 +
    |call=forceCookNonDatOps(comp)
 +
    |returns=None
 +
    |text=Recursively force cook op and all children of comp, unless they are DATs}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=showInPane
 +
    |call=showInPane(operator, pane='Floating', inside=False)
 +
    |returns=None
 +
    |text=Open an operator for viewing in a chosen editor pane. The pane will be focused on the chosen operator unless inside is True, in which case it will show the inside if possible.
 +
*operator - The operator to view.
 +
*pane - (Optional) A ui.pane or 'Floating' for a new floating pane.
 +
*inside - (Optional) If inside is True, try to show view inside comps.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=tScript
 +
    |call=tScript(cmd)
 +
    |returns=float
 +
    |text=Run a tscript command. This is slow because it creates and destroys an operator. If you need this to be faster, build an optimized network with its own tscript DAT.
 +
*cmd - tScript command to run.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=parStringToIntList
 +
    |call=parStringToIntList(parString)
 +
    |returns=list of ints
 +
    |text=Convert a space delimited string to a list of ints.
 +
*parString - Space delimited list of ints.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=listToParString
 +
    |call=listToParString(l)
 +
    |returns=space delimited string list
 +
    |text=Convert a list to a space delimited string.
 +
*l - A python list.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=replaceOp
 +
    |call=replaceOp(dest, source=None)
 +
    |returns=None
 +
    |text=Replace dest with an exact copy of source. If source is None and dest is a comp, try to use dest's clone parameter.
 +
*dest - The OP to be replaced.
 +
*source - (Optional) The OP to replace with. If None, use dest's clone source.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=getParInfo
 +
    |call=getParInfo(sourceOp, pattern='*', names=None, includeCustom=True, includeNonCustom=True)
 +
    |returns=dict
 +
    |text=Returns a parInfo dict for sourceOp. The format of a parInfo dict is {<parName>:(parVal, parExpr, parMode)...}
 +
*sourceOp - The operator to look for pars on.
 +
*pattern - (Optional) A pattern match string for par names.
 +
*names - (Optional) A list of specific names to include. None means include all.
 +
*includeCustom - (Optional) Include custom parameters.
 +
*includeNonCustom - (Optional) Include non-custom parameters.}}
 +
{{ClassMethod
 +
    |class=TDF
 +
    |name=applyParInfo
 +
    |call=applyParInfo(targetOp, parInfo)
 +
    |returns=float
 +
    |text=Apply par values, expressions, and modes from parInfo dict to targetOp. The format of a parInfo dict is {<parName>:(parVal, parExpr, parMode)...}
 +
*targetOp - The operator to apply values to.
 +
*parInfo - The parInfo dict.}}

Revision as of 16:30, 12 March 2019


The TDFunctions module provides a variety of Python utility functions for TouchDesigner. To use TDFunctions put the following line at the top of your Python script:

TDF = op.TDModules.mod.TDFunctions

You can now use any of the following functions by calling:

TDF.<function name>(...)


{{ClassMethodSection|empty= |Sectionsummary= |items=

clamp(value, inMin, inMax)float:

returns the value clamped between inMin and inMax.

  • value - The value to be clamped.
  • inMin - The minimum value.
  • inMax - The maximum value.

parentLevel(parentOp, childOp)OP or None:

determines if parentOp is a parent of childOp at any depth. Returns None or the depth of parenthood. i.e. childOp.parent(<returnValue>) will yield parentOp. This method returns None if childOp is not a child of parentOp.

Note:' childOp.parent(<returnValue>) will error in that case.

  • parentOp - The parent to be evaluated.
  • childOp - The child to be evaluated.

sharedParent(op1, op2)OP or None:

Returns the nearest shared parent of op1 and op2. Returns None if root is result.

  • op1 - The first operator.
  • op2 - The second operator.

getShortcutPath(fromOp, toOp)path expression:

Return a shortcut path expression from fromOp to toOp. This expression is suitable for use in any OP parameter expression on fromOp. The expression will incorporate Parent Shortcuts and Global OP Shortcuts.

Note: because there are multiple ways to create a shortcut expression, the result of this function will always be a best guess.

  • fromOp - the operator to generate expression from.
  • toOp - the operator to generate expression to.

panelParentShortcut(panel, parentShortcut)Panel COMP or None:

Return the first panelParent of panel that has the provided parentShortcut. Returns None if no panelParent with shortcut is found.

  • panel - the panel to start searching at.
  • parentShortcut - the parent shortcut to look for.

parMenu(menuNames, menuLabels=None)menuSource object:

Returns an object suitable for menuSource property of parameters.

  • menuNames - A list of strings for menu values.
  • menuLabels - (Optional) A list of strings for menu labels. Defaults to menuNames.

incrementStringDigits(string, min=1)string:

Method for iterating a string with digits on the end, or adding digits if none are there. This simulates the automatic naming of duplicate operators.

  • string - The string to add digits to.
  • min - (Optional) The number to add if string doesn't have a number already.

findNetworkEdges(comp, ignoreNodes=None)dict or None:

A utility for placing nodes in a network. Returns a dictionary of 'nodes' and 'positions' at extremes of network. Returns None if no nodes found. Dictionary keys are 'top', 'left', 'right', 'bottom'.

  • comp - The network to analyze.
  • ignoreNodes - (Optional) A list of nodes to ignore during analysis.

arrangeNode(node, position='bottom', spacing=20)float:

Place a node according to the other nodes in the network.

  • node - The node to move.
  • position - (Optional) Can be 'bottom', 'top', 'left' or 'right'. left, right will be placed parallel with top nodes. top, bottom will be placed parallel with left nodes.
  • spacing - (Optional) Distance from network edge.

createProperty(classInstance, name, value=None, attributeName=None, readOnly=False, dependable=False)None:

Use this method to add a property to a class.

WARNING: the property is added to the class of instance, so all objects of instance's class will now have this property.

  • classInstance - An instance of the class to add a property to. This is usually 'self' in the __init__ method of the class.
  • name - The name of the property. Must be a valid Python object name.
  • value - (Optional) The starting value of the property.
  • attributeName - (Optional) The attribute name used to store the value of the property. Defaults to _<name>.
  • readOnly - (Optional) If True, the property will be read only. A read only property can be changed via the attributeName. If the property is dependable, use attributeName.val.
  • dependable - (Optional) If True, the value will be dependable. If set to "deep", collections will be deeply dependable.

makeDeepDependable(value)dependency object:

Returns a deeply dependable object out of the provided python object. Deeply dependable collections will cause cooks when their contents change.

  • value - The value of the deep dependable object.

forceCookNonDatOps(comp)None:

Recursively force cook op and all children of comp, unless they are DATs

showInPane(operator, pane='Floating', inside=False)None:

Open an operator for viewing in a chosen editor pane. The pane will be focused on the chosen operator unless inside is True, in which case it will show the inside if possible.

  • operator - The operator to view.
  • pane - (Optional) A ui.pane or 'Floating' for a new floating pane.
  • inside - (Optional) If inside is True, try to show view inside comps.

tScript(cmd)float:

Run a tscript command. This is slow because it creates and destroys an operator. If you need this to be faster, build an optimized network with its own tscript DAT.

  • cmd - tScript command to run.

parStringToIntList(parString)list of ints:

Convert a space delimited string to a list of ints.

  • parString - Space delimited list of ints.

listToParString(l)space delimited string list:

Convert a list to a space delimited string.

  • l - A python list.

replaceOp(dest, source=None)None:

Replace dest with an exact copy of source. If source is None and dest is a comp, try to use dest's clone parameter.

  • dest - The OP to be replaced.
  • source - (Optional) The OP to replace with. If None, use dest's clone source.

getParInfo(sourceOp, pattern='*', names=None, includeCustom=True, includeNonCustom=True)dict:

Returns a parInfo dict for sourceOp. The format of a parInfo dict is {<parName>:(parVal, parExpr, parMode)...}

  • sourceOp - The operator to look for pars on.
  • pattern - (Optional) A pattern match string for par names.
  • names - (Optional) A list of specific names to include. None means include all.
  • includeCustom - (Optional) Include custom parameters.
  • includeNonCustom - (Optional) Include non-custom parameters.

applyParInfo(targetOp, parInfo)float:

Apply par values, expressions, and modes from parInfo dict to targetOp. The format of a parInfo dict is {<parName>:(parVal, parExpr, parMode)...}

  • targetOp - The operator to apply values to.
  • parInfo - The parInfo dict.

An Operator Family that contains its own Network inside. There are twelve 3D Object Component and eight 2D Panel Component types. See also Network Path.

An Operator Family that manipulates text strings: multi-line text or tables. Multi-line text is often a command Script, but can be any multi-line text. Tables are rows and columns of cells, each containing a text string.