The info window displays information about a node. For example, the info window for a geometry (SOP) node shows the attributes and groups on the geometry generated by the node, and other information. You can display the info window for a node by hovering over the node and then clicking the “i” button in the node ring, or by holding on the node.

It can sometimes be useful to add extra custom information to the info window for a certain node type or for all nodes. For example:

• The author of a digital asset might want to display information specific to the asset when the user shows the info window for an instance of the asset.

• Studios with complex asset management pipelines can display information about each asset specific to their workflow.

There are a few different places you can display custom information in the window:

• You can add a “tag” at the top of the window, just below the node heading. This is a bit of text inside a pill shape. It is useful for displaying a single bit of information, for example whether an asset is “out of date”.

  

• You can add information near the top of the window (under the node header), in the middle (above the general info grid), or near the bottom (above the node comment editor).

  

1. Create a $HOUDINI_USER_PREFS/config/CustomNodeInfo directory.

2. In the CustomNodeInfo directory, create an index.json file with the following contents:

   index.json

   {
       "node_scripts": {
           "Sop/sphere": "test.py"
       }
   }
   

3. Then create the test.py file in the same directory with the following contents:

   test.py

   addLabeledText("Custom Message", "This is some custom text for the info window.")
   

4. Run Houdini. Create a Geo object and dive inside. Then create a Sphere node.

5. Hovering over the node and click the “i” button in the node ring, or hold on the node.

   You should see the custom message in the info window.

See writing a customization script below for more information.

You can store a customization script in a section (“Extra File”) inside an asset. If an asset has a section called custom_node_info.py, Houdini will automatically run the script when the user shows the info window for an instance of the asset, allowing it to add custom info.

1. In the network editor, right click the asset and choose Edit Type Properties.

2. In the Type Properties dialog, click the Extra Files tab.

3. In the Section Name field, enter custom_node_info.py, then click Add Empty Section.

4. Use the editor on the right side to enter (or paste) the script. See writing a customization script below.

Houdini looks for any config/CustomNodeInfo/index.json files on the Houdini path. In this file you can specify customization scripts to run for specific node types, or for all nodes.

Here’s an example of an index.json file:

{
    "node_scripts": {
        "Sop/lsystem": "lsystem.py"
    },
    "general_scripts": [
        "every_node.py"
    ]
}

The JSON can have two optional keys:

>>> hou.node('/obj/copnet1/custom_test1').type().nameWithCategory()
'matt::Cop/custom_test::1.0'

• node_scripts does not support patterns. Instead, create a general script and have it only add information for certain nodes. For example, to add custom info to any nodes in the acme namespace, create a general_script and have the script only add the information if namespace == "acme".

• Usually the values of the node_scripts object are path strings. However, you can use an array of path strings if for some reason you want to run multiple scripts for a certain node type.

  {
      "node_scripts": {
          "Sop/lsystem": "lsystem.py",
          "Sop/sphere": ["sphere.py", "shape.py"]
      }
  }
  

• Relative paths are resolved from the directory containing the index.json file.

For arguments that take a color, you can use any of the following values:

• A hex color string (for example, "#ffcc00") or a CSS color name (for example, "rebeccapurple").

• The string "transparent" to not draw anything.

• A QtCore.QColor object.

• Any of the following UI color values (for example, addTag("Oops!", color=theme.error)):

  • theme.success (a shade of green)

  • theme.warning (a shade of yellow)

  • theme.error (a shade of red)

  • theme.primary (the UI accent color)

  • theme.secondary (a desaturated versoin of the accent color)

  • theme.red, theme.orange, theme.amber, theme.yellow, theme.lime, theme.green, theme.emerald, theme.teal, theme.cyan, theme.sky, theme.blue, theme.indigo, theme.violet, theme.purple, theme.fuchsia, theme.pink, theme.rose, theme.stone, theme.gray, theme.zinc, theme.steel, theme.slate, theme.heather

Houdini runs all customization scripts serially before the info window becomes available. You should try to make the scripts run as fast as possible so users don’t have to wait for the info window. If gathering the information to display could be slow (for example, getting information across the network), there are a few things you can try to speed it up.

import requests
import threading

# Create a text item and set its initial text to a placeholder
status_item = addLabeledText("Status", "--")

# Get information through an HTTP request in a thread
def threaded_fn():
    response = requests.get("api.example.com/status")
    # Once the information is available, update the item with the new text
    status_item.update(text=response.text)
threading.Thread(target=fn).start()

def get_status_callback(button):
    response = requests.get("api.example.com/status")
    # Get references to the button and text by their IDs
    button = findByID("status_button")
    text_item = findByID("status_text")
    # Hide the button
    button.update(visible=False)
    # Set the new text and show it
    text_item.update(text=response.text, visible=True)

# Create a labeled column to hold the button and status readout
column = addLabeledColumn("Status")
# Add the button and readout to the column
column.addButton("Get", get_status_callback, id="status_button")
# The text readout is hidden until the user clicks the button and the
# callback function loads the information
column.addText("", id="status_text", visible=False)

If you have multiple customization scripts adding information (for example, a studio-wide script, a node-type specific script, and a general script in the user’s prefs), you may want to have different scripts add items to the same container.

To share containers between scripts, add an id argument to methods that create a new container, such as addGrid() or addLabeledColumn(). Use the same ID in different scripts to get the same container.

For example, if two scripts have the following code:

c1 = addLabeledColumn("Comments", id="comments")
c1.addText("Comment from script1")

c2 = addLabeledColumn("Comments", id="comments")
c2.addText("Comment from script2")

…the result will be a single Comments column containing two items (Comment from script1 and Comment from script2`).

If you didn’t have the id argument, the two scripts would create two separate columns, both labeled Comments, with one item in each.

You can also use the following utility functions in customization scripts if necessary to work with containers.

• You can use node object in the script to access parameter values and user data stored on the node. See the hou.Node object reference.

• The info window checks the modification times of the index files and scripts and reloads them if they've changed. You don’t need to restart Houdini to pick up changes to the files.

• If you don’t see the results of your script when you open the info window, do the following:

  • Check the console for error messages.

  • If the script is in a file on disk, double-check that it’s listed in an config/CustomNodeInfo/index.json file on the Houdini path.

  • If it’s a node-specific script, make sure the key in the index.json file matches the “internal name with category” of the node type exactly.

• Customization scripts should run quickly so the info window isn’t slow to open. If you want to get information from the network to display in the info window, consider strategies such as using async or threading, or getting the information in the background and caching it until the user displays the info window.

• If you just want to display some HTML, you can use addText() and pass a string of HTML as the “text”. It uses Qt’s “rich text” widget which supports a subset of HTML 4 and CSS 2 but is definitely not as capable as a real browser.

• Avoid only displaying information through color (for example, a tag that always says “Status” but is green for normal status and red for error status). Use color to reinforce information displayed as text and/or symbols.

• Try to avoid building a lot of interaction into the info window. It is really meant to let the user quickly check information about a node, not serve as a “command interface”. Remember that when the user displays it by holding , they can’t interact with the info window at all.