Return the current desktop.

Return the desktop with the specified name. Return None if no such desktop exists.

Return all the desktops.

See hou.Desktop.setAsCurrent for an example.

Returns a hou.RadialMenu object representing the named menu, or None if the menu does not exist.

Returns a tuple of hou.RadialMenu objects representing existing menus.

Creates a new radial menu object with the given name and label.

Creates a temporary radial menu item.

Injects a temporary radial menu item into the current menu.

Injects a registered menu and override the current menu.

Forces label expressions to be re-evaluated for the main Houdini menu bar. These top level menu items are never automatically refreshed, so it is up to the creator of these menus to also install handlers that detect when a condition has changed that might affect the menu, and call this method to force a refresh.

Return a tuple of all visible panes, including those in all floating windows.

See also hou.Desktop.panes.

Return a tuple of all visible pane tabs, including those in all floating windows.

See also hou.Desktop.paneTabs.

Return a tuple of all visible pane tabs that are selected in their containing panes, including those in all floating windows.

See also hou.Desktop.currentPaneTabs.

Return all the pane tabs in floating panels.

See also hou.Desktop.floatingPaneTabs.

Find and return the pane tab with the desired type. If no such tab exists, return None.

See also hou.Desktop.paneTabOfType.

Return the pane with the given unique id, or None if no such pane exists.

See also hou.Desktop.findPane.

Return the pane tab with the given name, or None if no such tab exists.

The name may optionally be prefixed by the desktop name and a period.

See also hou.Desktop.findPaneTab.

Return all the visible floating panels.

See also hou.Desktop.floatingPanels.

Return the hou.Pane object located under the mouse cursor. Return None if no pane is located under the mouse cursor.

This method searches all visible panes including panes not attached to the current desktop.

Similar to hou.ui.paneUnderCursor but return the hou.PaneTab object instead located under the mouse cursor. Return None if no pane tab is located under the mouse cursor.

This method searches all visible pane tabs including pane tabs not attached to the current desktop.

Return the value of a global flag that hides all the minimized stowbars and split panes.

Set the value of a global flag that hides all the minimized stowbars and split panes. When the flag is on, the minimized stowbars of all pane tabs ,menus , the shelf dock or toolbars will be hidden. It also affect the split bars of split panes, in which case, the split is rendered using a single pixel line.

Pop up a window with a message, OK and Cancel buttons, and wait for the user to press a button.

'''Prompt the user if they want to overwrite a file, and save it if they choose OK.'''
if hou.ui.displayConfirmation("Overwrite the current hip file?", suppress=hou.confirmType.OverwriteFile):
    hou.hipFile.save()

This method is the same as displayConfirmation, except it also accepts a list of custom button labels and returns the selected button index instead of a boolean value. The button index corresponds to the entry in the label array that was selected in the pop up dialog. If fewer than two button labels are specified, the default labels “OK” and “Cancel” will be added as necessary to achieve the required length of at least two labels.

'''Before cooking the TOP network, prompts the user to either save the .hip
file, cook without saving the file, or cancel the cook operation completely.'''

def save_and_cook(top_network):
    buttons = ("Save and Continue", "Continue Without Saving", "Cancel")
    selected_button = hou.ui.displayCustomConfirmation("Save before cooking?", suppress=hou.confirmType.TopCookSave, buttons=buttons)

    if selected_button == 0:
        hou.hipFile.save()

    if selected_button != 2:
        top_network.cookWorkItems(block=True)

Pop up a small window with a message and one or more buttons and wait for the user to press a button. Return the index of the button the user pressed.

def saveIfNeeded():
        '''Prompt the user if they want to save, and save the hip file if they choose Yes.'''
        if hou.ui.displayMessage("Save the current hip file?", buttons=("Yes", "No")) == 0:
            hou.hipFile.save()

Pop up a small window with a textbox and wait for the user to enter a line of text. Return a tuple containing an integer and the text they entered. The integer is the index of the pressed button. If close_choice is not None and the user closed the dialog by clicking on its close button or by pressing Escape, then the returned integer is set to close_choice.

See also hou.ui.readMultiInput

Pop up a small window with a textbox and wait for the user to enter a text into several input fields. Return a tuple containing an integer and the tuple of strings they entered, one for each input field. The integer is the index of the pressed button. If close_choice is not -1 and the user closed the dialog by clicking on its close button or by pressing Escape, then the returned integer is set to close_choice.

The initial_contents values must be strings. If you use another type (for example, integers), the function will raise a TypeError. If you want to prompt the user for integers, convert the initial values into strings, and convert the results back into integers. For example:

start_int, end_int = hou.playbar.frameRange()
button_idx, values = hou.ui.readMultiInput(
    "Set the new frame range", ("Start Frame", "End Frame"),
    initial_contents=(str(start_int), str(end_int)),
    title="Frame Range",
    buttons=("OK", "Cancel"),
    default_choice=0, close_choice=1,
)
new_start_int = int(values[0])
new_end_int = int(values[1])

See also hou.ui.readInput

Pop up a window with a file chooser dialog and wait for the user to choose a file name. Returns the path to the file that was selected.

To restrict the type of file the user can choose, pass a hou.fileType value to the file_type keyword argument. To allow multiple different types, you can pass a set of hou.fileType values to the file_types keyword argument instead.

If you want the user to select a directory instead of a file, use hou.fileType.Directory as the file_type. If you want to allow the user to choose either a file or a directory, pass a file type and hom.fileType.Directory to the file_types argument:

# Allow the user to choose a file or a directory
path = hou.ui.selectFile(
    title="Choose the file or directory to save the scene to",
    file_type=[hou.fileType.Usd, hou.fileType.Directory],
    chooser_mode=hou.fileChooserMode.Write,
)

Pop up a window with a set of choices in a list box and prompt the user to choose zero or more of them. If selection is accepted then the list of selected row indices are returned. If selection is canceled then the initial selection (default choices) is returned.

Pop up a window with a set of choices in a tree chooser and prompt the user to choose zero or more of them. The choices are arranged into a tree using a forward slash as a path separator. If selection is accepted then the list of selected paths are returned. If selection is canceled then the initial selection (picked) is returned.

Pop up a window with a node tree view and prompt the user to choose a node.

If the user selects a node, returns a string containing the path to the node. If the user presses clear, returns None. If the user presses cancel, returns None. If the user sets multiple_select to True, returns a list of strings containing the selected paths, or None if clear or cancel were pressed.

The following function takes a hou.Parm, prompts the user to choose a node, and sets the value of the parameter as long as the user does not click cancel.

def setParmOnNode(parm, node_type_filter=None):
    path = hou.ui.selectNode(relative_to_node=parm.node(), node_type_filter=node_type_filter)
    if path is not None:
        parm.set(path)

You might call this function as follows:

>>> setParmOnNode(hou.parm("/obj/geo1/channel1/choppath"), hou.nodeTypeFilter.Chop)

Here is an example of specifying a custom node filter:

# Define the callback for filtering nodes.
def nameStartsWithFoo(node):
    return node.name().startswith("foo_")
# Prompt the user to select node data.
node_path = hou.ui.selectNode(custom_node_filter_callback=hasNumberInName)
# Output the selected data.
print(node_path)

This method is deprecated in favor of hou.ui.selectNode. Same behavior as selectNode however if the user holds 'Ctrl' they can select multiple nodes which are returned as a list of paths.

Pop up a chooser dialog that prompts the user to select a geometry attribute in the scene. Return a tuple of the selected attributes represented as pairs of hou.Attrib and integer values. Return an empty tuple if the selection operation was canceled.

Example:

# Pre-select the 2nd component of the 'myAttr' point attribute on the
# /obj/geo1/OUT Sop node.
attrib = hou.node("/obj/geo1/OUT").geometry().findPointAttrib("myAttr")
attrib_component_index = 1
preselected_attribs=((attrib, attrib_component_index), )

# Prompt the user to select an attribute.
selected_attribs = hou.ui.selectAttrib(
    initial_selection=preselected_attribs)

# Output the selected attribute.
print selected_attribs

Example with expand_components set to False:

# Pre-select the 'myAttr' point attribute on the
# /obj/geo1/OUT Sop node.
attrib = hou.node("/obj/geo1/OUT").geometry().findPointAttrib("myAttr")
attrib_component_index = -1
preselected_attribs=((attrib, attrib_component_index), )

# Prompt the user to select an attribute.
selected_attribs = hou.ui.selectAttrib(
    initial_selection=preselected_attribs,
    expand_components=False)

# Output the selected attribute.
print selected_attribs

Pop up a chooser dialog that prompts the user to select data from a node. The data can be a parameter, a component from an object node’s transform, a geometry node’s bounding box property, a geometry attribute, or even custom data defined by the custom_data_callback argument. Return a dictionary of selected data organized by the following keys :

• Parameters

  Contains a tuple of selected parameters. The elements in the tuple are hou.Parm objects. If expand_components is False then the elements are hou.ParmTuple objects.

• Transforms

  Contains a tuple of selected object node transforms or transform components. The elements in the tuple are 3-tuples of the form (node, transform_type, transform_component) where node is the hou.OpNode object that the selected transform is pulled from, transform_type is the type of transform (either Local or World), and transform_component is the specific component selected from the transform (i.e. Rotate[X]). If the whole transform is selected instead of a component then transform_component is None.

• Bounding Boxes

  Contains a tuple of selected geometry node bounding box properties. The elements in the tuple are 2-tuples of the form (node, bbox_property) where node is the hou.OpNode object that the selected bounding box property is pulled from, and bbox_property is the specific bounding box property (i.e. Size[X]).

• Attributes

  Contains a tuple of selected geometry attributes or attribute components. The elements in the tuple are 2-tuples of the form (attrib, attrib_index) where attrib is the selected hou.Attrib object and attrib_index is the index of the selected attribute component. If expand_components is False then attrib_index is always -1.

• Custom

  Contains a tuple of selected custom data as specified by the custom_data_callback argument. The elements in the tuple are 2-tuples of the form (node, custom_data) where node is the selected hou.OpNode object that the custom data is attached to and custom_data is the actual data.

Basic Example:

# Prompt to select node data.  Show all types of data.
selected_data = hou.ui.selectNodeData()

# Print out selected parameters (if any).
if "Parameters" in selected_data:
    for parm in selected_data["Parameters"]:
        print "Selected Parm: ", parm

# Print out selected object transforms (if any).
if "Transforms" in selected_data:
    for xform_info in selected_data["Transforms"]:
        print "Selected Node: ", xform_info[0]
        print "Selected Transform Type: ", xform_info[1]
        print "Selected Transform Component: ", xform_info[2]

# Print out selected geometry bounding boxes (if any).
if "Bounding Boxes" in selected_data:
    for bbox_info in selected_data["Bounding Boxes"]:
        print "Selected Node: ", bbox_info[0]
        print "Selected Bounding Box Property: ", bbox_info[1]

# Print out selected geometry attributes (if any).
if "Attributes" in selected_data:
    for attr_info in selected_data["Attributes"]:
        print "Selected Attribute: ", attr_info[0]
        print "Selected Attribute Index: ", attr_info[1]

Here is an example of setting an initial selection:

# Pre-select the 'tx', 'ty' and 'tz' parameters on /obj/geo1.
preselected_parms = (
    hou.parm("/obj/geo1/tx"), hou.parm("/obj/geo1/ty"), 
    hou.parm("/obj/geo1/tz"))

# Pre-select the scale z world transform component on /obj/geo1.
preselected_xforms = (
    (hou.node("/obj/geo1"), "World", "Scale[Z]"),
)

# Pre-select the centroid y bounding box property on /obj/geo1/OUT.
preselected_bboxes = (
    (hou.node("/obj/geo1/OUT"), "Centroid[Y]"),
)

# Pre-select the 2nd component of the 'myAttr' point attribute on the
# /obj/geo1/OUT Sop node.
attrib = hou.node("/obj/geo1/OUT").geometry().findPointAttrib("myAttr")
attrib_component_index = 1
preselected_attribs=((attrib, attrib_component_index), )

# Build up the initial selection dictionary.
initial_selection = {
    "Parameters" : preselected_parms,
    "Transforms" : preselected_xforms,
    "Bounding Boxes" : preselected_bboxes,
    "Attributes" : preselected_attribs,
}

# Prompt the user to select node data.
selected_data = hou.ui.selectNodeData(
    initial_selection=initial_selection,
    multiple_select=True)

# Output the selected data.
print selected_data

Here is an example of specifying custom data:

# Define the callback for returning custom data.
def getCustomData(node):
    # Add custom data only on Object nodes.
    if node.type().category().name() == "Object":
        return ["Fruits/Apples", "Fruits/Bananas", "Fruits/Oranges"]

    # Don't add custom data on all other nodes.
    return []

# Prompt the user to select node data.
selected_data = hou.ui.selectNodeData(custom_data_callback=getCustomData)

# Output the selected data.
print selected_data

Here is an example of specifying a custom node filter:

# Define the callback for filtering nodes.
def hasNumberInName(node):
    # Only show nodes with numbers in the name.
    for letter in node.name():
        if letter in "1234567890":
            return True

    # Don't show nodes without a number in the name.
    return False

# Prompt the user to select node data.
selected_data = hou.ui.selectNodeData(custom_node_filter_callback=hasNumberInName)

# Output the selected data.
print selected_data

Pop up a window with a tree view of recognized parameter tags and prompt the user to choose a tag. Parameter tags are metadata that can be attached to a parameter template with hou.ParmTemplate.setTags and queried with hou.ParmTemplate.tags.

Tags listed in the window are recognized by Houdini. For example, choosing the GL Diffuse tag and assigning it to a parameter template causes the viewport to recognize the parameter as the diffuse color.

This method returns a 2-tuple where the first element is the selected tag name and the second element is the selected tag value. If no tag is selected or if the selection operation is canceled, then a 2-tuple of empty strings is returned.

Pop up a window with a parameter tree view and prompts the user to select parameters, populated initially with initial_parms. If selection is accepted then a list of selected parameter paths are returned. If selection is canceled then the initial selection (initial parameters) is returned.

category: A hou.NodeTypeCategory if filtering by node type, otherwise None if all parameters should be shown

bound_parms_only: True if the dialog should only display parameters that are bound to a default handle. False is all parameters should be shown.

relative_to_node: A hou.OpNode that you want the selected parameters paths to be relative to.

message: The message to display in the dialog.

title: The title of the dialog.

multiple_select: Whether the user may select multiple parameters.

width: The chooser dialog’s width. If 0, then the chooser dialog uses a default width.

height: The chooser dialog’s height. If 0, then the chooser dialog uses a default height.

Pop up a window with a parameter tree view and prompts the user to select parameter tuples, populated initially with initial_parm_tuples.

See hou.ui.selectParm for documentation on the arguments.

Pop up a window with a color chooser, and waits for the user to choose a color and hit the OK or Cancel button. If the user hits the OK button, this method returns the color chosen in the dialog. If the user hits Cancel, this method returns None.

The initial_color parameter specifies a hou.Color that will appear in the dialog when it first opens. If not set, the initial color will be white.

Open the Houdini Bookmark Edit Dialog and return immediately.

The bookmark parameter should be a hou.Bookmark object, returned by hou.anim.bookmarks() or hou.anim.bookmark().

Open the Houdini color editor and return immediately.

When a change is made in the editor then the color_change_callback function is invoked and passed the editor’s current color and alpha value.

If include_alpha is True then the color editor shows controls for editing the color’s alpha value.

The initial_color parameter specifies a hou.Color that will appear in the editor when it first opens. If not set, the initial color will be white.

The initial_alpha parameter specifies an alpha value to use when the editor first opens. If not set, the initial alpha will be 1.0. Note that the initial_alpha parameter only applies if include_alpha is set to True.

The color_change_callback argument must be a function that accepts two parameters – a hou.Color object and an alpha value.

Here is an example:

def handleColorChange(color, alpha):
    print "Current color in editor:", color, ", alpha=", alpha

hou.ui.openColorEditor(handleColorChange)

Displays a “value ladder” control, the UI that typically appears when you press on a field in Houdini. This lets you display ladder controls on your own custom UI, such as Qt edit fields.

The typical workflow is:

1. You should listen for press and release events on your field.

2. When the user presses on the field, call this function to show the ladder. The function returns immediately but the ladder stays visible.

3. As the user moves the mouse with pressed down, you must call hou.ui.updateValueLadder with the mouse pointer coordinates.

4. The ladder calls the value_changed_callback function you supplied as the user changes the value.

5. When the user releases , call hou.ui.closeValueLadder.

Only one value ladder window can be open at a time. This function raises hou.OperationFailed if another ladder window is currently open.

This examples demonstrates how to add value ladder window support to an input field class that derives from Qt’s QLineEdit class:

from PySide2 import QtWidgets
from PySide2.QtCore import Qt
import hou


class LineEditWithValueLadder(QtWidgets.QLineEdit):
    def __init__(self, parent=None):
        super(LineEditWithValueLadder, self).__init__(parent)
        self._pressed = False

    def mousePressEvent(self, event):
        # Show the value ladder window if MMB was pressed.
        if event.button() == Qt.MiddleButton:
            try:
                hou.ui.openValueLadder(
                    float(self.text()),
                    self._ladderchange,
                    data_type=hou.valueLadderDataType.Float
                )
            except hou.OperationFailed:
                # A ladder is already open somewhere
                return
            else:
                self._pressed = True

    def mouseMoveEvent(self, event):
        if self._pressed:
            hou.ui.updateValueLadder(
                event.globalX(),
                event.globalY(),
                bool(event.modifiers() & Qt.AltModifier),
                bool(event.modifiers() & Qt.ShiftModifier)
            )

    def mouseReleaseEvent(self, event):
        if event.button() == Qt.MiddleButton and self._pressed:
            hou.ui.closeValueLadder()
            self._pressed = False

    def _ladderchange(self, new_value):
        self.setText(str(new_value))

Updates the value in the currently opened ladder value window based on the given cursor position and boolean arguments.

This function only works if hou.ui.openValueLadder was previously called. Raises hou.OperationFailed if no value ladder window is currently open.

See hou.ui.openValueLadder for more information.

Closes the current value ladder window that was open by a previous call to hou.ui.openValueLadder.

Raises hou.OperationFailed if no value ladder window is open.

See hou.ui.openValueLadder for more information.

Open the expression editor to edit the expression of the given parameter.

Open the preferences dialog and show the given page.

Display the help for the specified node type. If no help browser is open, this function will create a new one.

If you want to display the help for a node instance, it is easy to access the hou.NodeType from the node, as illustrated in this example:

def displayHelpForNode(node):
'''Given a hou.OpNode, display its help.'''
hou.ui.displayNodeHelp(node.type())

Given a hou.OpNode or hou.OpNodeType instance, open the type properties dialog.

Given a hou.OpNode, open the parameter interface editor dialog. This dialog is can be used to add or remove spare parameters, or rearrange the parameter layout for a node.

Given a hou.RopNode instance, open the render control dialog for the node. This dialog can be used to override certain render parameters, and launch a render.

Given a hou.OpNode which contains other nodes, open a dialog for renaming all selected children of the node. The dialog uses pattern matching to rename all the selected nodes in one operation.

Open a dialog displaying the file dependencies in the current .hip file.

Return a 2-tuple where the first element in the tuple is True if the dialog was closed with the OK button and False otherwise, and the second element is a tuple of the selected file patterns. Each selected file pattern is represented as a <hou.Parm, string> pair which stores the source parameter that contains the file pattern and the file pattern itself.

Return parameter editors displaying a given node. You can also choose to include node editors with a displayed embedded parameter editor.

Given a list or a single instance of hou.Parm or hou.ParmTuple adjust the matching parameter editor scroll bars to make the parameters visible in the parameter editor scroll region. Returns True if valid parameter editors were found.

Given a hou.Parm representing a multi parameter parent, set the multi parameter tab index in the parameter editor dialogs. The tab index doesn’t map to a node parameter. Returns True if the parameter was found in opened parameter editors.

Given a hou.Parm switch all the parent tabs folder to show the parameter in the opened parameter editors. Returns True if the parameter was found in opened parameter editors.

Given a node and a list of comma separated parameter names apply a search filter on the corresponding parameter editors. The string can also include wildcards. Returns True if valid parameter editors were found.

Show a floating hou.ParameterEditor for a given hou.OpNode.

Given an instance of a hou.SopNode that is a captureoverride type, open the edit capture weight spreadsheet for the node. If a string is passed for pattern, then only the points specified by the pattern will be shown, otherwise all the points for the node will be displayed in the spreadsheet.

Open a window for editing and saving a text file.

The editor buttons:

• Apply: Save the file only if the source has changed.

• Accept: Save the file if the source has changed and close the window.

• Cancel: Close the window without saving the file and prompting the user.

An optional callback and a dictionary of user-defined parameters can be specified to customize the Apply and Accept operations.

def myApplyAction( **kwargs )

Example:

def myAction(**kwargs):
    hou.ui.printResourceMessage(kwargs['msg'] + ' saved.', kwargs['msg_type'])

file_path = '/var/tmp/main.py'
hou.ui.openFileEditor( 'My Editor Title', file_path, action_callback=myAction, 
    params={ 'msg' : file_path, 'msg_type' : hou.severityType.Message })

Launch the system’s file browser, navigating to the parent directory of the specified file and selecting it.

# Launch the browser in /home/me/myDocs and select doc1.txt
hou.ui.showInFileBrowser('/home/me/myDocs/doc1.txt')

# Launch the browser in /home/me/myDocs and select nothing
hou.ui.showInFileBrowser('/home/me/myDocs/')

# Launch the browser in /home/me and select myDocs
hou.ui.showInFileBrowser('/home/me/myDocs')

Open a modal dialog window for generating a template implementation and registration code for a python viewer state. The input name of the viewer state is mandatory for generating the code. Other fields such as the state label and icon name are optional.

The dialog Sample options can be selected to generate the viewer state code with predefined handlers and bindings. The Handler options can also be selected to generate the viewer state code with empty handlers.

The dialog buttons:

• Accept: Generate the code template with the input fields and selected options.

• Cancel: Close the dialog and abort the code template generation.

This dialog is used by the Viewer State Browser panel and the Digital Asset Viewer State editor.

def myAcceptAction( **kwargs )

Display a message in Houdini’s status bar.

To clear the status bar, call hou.ui.setStatusMessage("").

Return the current message and severity from the status bar. This may not match the value most recently passed to setStatusMessage because Houdini itself often changes the message in the status bar.

Register a Python callback to be called whenever Houdini’s event loop is idle. This callback is called approximately every 50ms, unless Houdini is busy processing events.

def checkForAndProcessEvents():
    # Here is where you would check for and process any events.
    pass

hou.ui.addEventLoopCallback(checkForAndProcessEvents)

You might use this function to integrate another user interface toolkit into Houdini’s event loop. See the PyQt and wxPython cookbook examples for example usages.

Register a Python callback to be called next in Houdini’s event loop. This will be called only once.

Remove a posted event callback from the queue if it is still there.

If the callback is not present, nothing is done.

Add a callback to be run when the Update Once button is clicked in Houdini, or the hou.ui.triggerUpdate method is called. This callback will only be called when in the Manual update mode.

Remove a callback previously added with the hou.ui.addTriggerUpdateCallback method.

Register a Python callback to be called whenever Houdini’s global network item selection changes.

def selectionCallback(selection):
    # Here is where you would respond to the selection change.
    pass
hou.ui.addSelectionCallback(selectionCallback)

Keep calling the supplied callback until it returns True. In the meantime, Houdini will continue to be responsive, allowing you to continue to interact with it.

For example, start a blank Houdini session and put the following in a shelf tool. It will wait until you create an object node before finishing running the tool.

print "waiting until you create an object..."
hou.ui.waitUntil(lambda: len(hou.node("/obj").children()) > 0)
print "you created", hou.node("/obj").children()

If you find that your callback function is too slow to be run frequently, you can try only making it do work every so often:

import time

def throttle(callback, delay=2.0):
    # Returns a wrapper function around `callback`, which only calls
    # `callback` every `delay` seconds (default 2.0), no matter
    # how often the wrapper function is called.

    # This can be useful if the condition function is expensive to run,
    # so you want to limit how often it is called.

    # Store in a list, since Python 2.x doesn't have full nonlocal keyword
    last_check = [0.0]

    def wrapper():
        now = time.time()
        if now < last_check[0] + delay:
            # Since we return False when we're inside the delay, Houdini
            # will continue to call the condition function
            return False
        else:
            last_check[0] = now
            return callback()

    return wrapper


# Then you could use this with hou.ui.waitUntil like this:

def my_callback():
    return len(hou.node("/obj").children()) > 0

hou.ui.waitUntil(throttle(my_callback, delay=0.5))

Return a tuple of all the Python callbacks that have been registered with hou.ui.addEventLoopCallback.

Remove a Python callback that was previously registered with hou.ui.addEventLoopCallback. See hou.ui.addEventLoopCallback for more information.

Raises hou.OperationFailed if the callback was not previously registered.

Remove all Python callbacks previously registered with hou.ui.addSelectionCallback. See hou.ui.addSelectionCallback for more information.

Remove a Python callback that was previously registered with hou.ui.addSelectionCallback. See hou.ui.addSelectionCallback for more information.

Return a tuple of all the Python callbacks that have been registered with hou.ui.addSelectionCallback.

Force the viewports to update and perform any cooks necessary. You might call this function when Houdini’s Auto Update mode is on Manual.

Reloads all 3DSceneColors configuration files (in $HFS/houdini/config). You must cause the viewport to redraw (for example, by tumbling) to see the new colors.

This function may be useful if you are implementing a new color scheme: you can map to a hotkey or call it in the Python console so you can check your changes.

This method is deprecated in favor of hou.updateModeSetting().

This method is deprecated in favor of hou.setUpdateMode().

Returns if auto-key is currently enabled (changing an animated parameter will create a key at the current frame if it doesn’t exist).

Return the currently applied Houdini color scheme name.

Reloads all Houdini UI color settings from the configuration files (by default, in $HFS/houdini/config and $HOUDINI_USER_PREF_DIR/houdini/config).

This function may be useful if you are implementing a new color scheme: you can map to a hotkey or call it in the Python console so you can check your changes.

Return a string value from a symbolic resource name. The resource name should correspond to one of the entries in the $HH/config/*.hcs file for the currently selected color scheme.

Raises: hou.ValueError if the provided symbolic name doesn’t exist.

Return a color value from a symbolic color name. The color name should correspond to one of the entries in the $HH/config/*.hcs file for the currently selected color scheme.

Raises: hou.ValueError if the provided symbolic name doesn’t exist.

For example:

>>> hou.ui.colorFromName("DisplayOnColor")
<hou.Color r=0.3, g=0.5, b=1>

Return a hou.orientUpAxis indicating the current orientation mode’s up axis.

Return a hou.handleOrientToNormalAxis indicating the handle axis that is to be aligned to component normals when orienting.

Return the supplied inches argument, expressing a distance on the screen, converted to a number of pixels. This calculation combines the number of dots per inch reported by the operating system, the Global UI Size setting accessible from Edit ▸ Preferences ▸ General User Interface, and the HOUDINI_UISCALE environment variable, if it has been set. As such, this value may not be accurate, but is consistent with the way the rest of Houdini converts distances from inches to pixels.

Return the supplied pixels argument, expressing a number of pixels on the screen, converted to a distance in inches. This calculation combines the number of dots per inch reported by the operating system, the Global UI Size setting accessible from Edit ▸ Preferences ▸ General User Interface, and the HOUDINI_UISCALE environment variable, if it has been set. As such, this value may not be accurate, but is consistent with the way the rest of Houdini converts distances from pixels to inches.

Return the scale factor that is set by Houdini’s Global UI Size preference. For example, this function returns 1.0 when Houdini is set to the Normal UI size.

The scale factor can be used to scale components in a PySide or PyQt built UI where hou.ui.scaledSize cannot be called. For example, the scale factor can be used to set the zoom factor of a QWebEngineView object so that the web contents match the Global UI Size:

web_view = QWebEngineWidgets.QWebEngineView()
web_view.setZoomFactor(hou.ui.globalScaleFactor())

Scale the specified size by the global UI scale factor and return the scaled size. The scale factor is determined by Houdini’s Global UI Size preference. For example, the factor is 1.0 when Houdini is set to the Normal UI size.

This function is useful for scaling hard-coded sizes in PySide or PyQt code. Here is an example of using scaled sizes when setting a widget to a fixed size that is 640×480 with the Normal UI size:

widget = QtWidgets.QWidget()
widget.resize(hou.ui.scaledSize(640), hou.ui.scaledSize(480))

Here is another example of creating a scaled icon using the hou.qt.createIcon function:

icon = hou.qt.createIcon(hou.ui.scaledSize(32), hou.ui.scaledSize(32))

Load a palette file and return the colors listed in the palette. The file parameter can be a full path, or just a file name. In the latter case, the Houdini path is searched for the first instance of the named file under the config subdirectory.

Save a palette file with the contents of the colors parameter, a tuple of hou.Color objects. The file parameter must be a full path to the file where the palette should be saved.

Raises hou.OperationFailed if the file could not be written.

Sets the supplied text into the system clipboard.

Returns any text currently copied into the system clipboard. If the clipboard is empty or contains non-text data, an empty string is returned.

Save the command history from the current Python Shell to disk. If filename is None, then the history is written to $HOME/houdiniX.Y/pyshell.history. If this function is invoked outside of a Python Shell, then the history is taken from the last active shell (i.e. the last shell that was opened or accepted input).

Raises hou.OperationFailed if no Python Shell has been opened. Raises hou.OperationFailed if filename cannot be created.

Load the contents from the specified file into the command history of the Python Shell. If filename is None, then the history is read from $HOME/houdiniX.Y/pyshell.history. If this function is invoked outside of a Python Shell, then the history is loaded into the the last active shell (i.e. the last shell that was opened or accepted input).

Raises hou.OperationFailed if no Python Shell has been opened. Raises hou.OperationFailed if filename does not exist or cannot be read.

Return the hou.ShellIO object used to implement Houdini’s graphical Python shell. This function is used internally by Houdini, and you shouldn’t need to access the ShellIO directly.

Query the current drag source to determine if the specified data type is available.

Raises hou.NotAvailable if no drag operation is currently active.

Query the current drag source to obtain the dragged data. Returns None when the specified data in unavailable (or unsupported by HOM).

Raises hou.NotAvailable if no drag operation is currently active.

This method is deprecated. Call hou.qt.mainWindow instead.

This method is deprecated. Call hou.qt.Icon instead.

This method is deprecated. Call hou.qt.styleSheet instead.

Parse the given .ui file and return the dialog defined in the file.

The dialog must be written with Houdini’s User Interface Script Language. An overview of the language can be found in the Houdini Development Kit (HDK) documentation, specifically in the “Houdini User Interface → The .ui Script Language” section.

ui_file_name is the basename of the .ui file. The file must be located in a directory registered with the HOUDINI_UI_APP_PATH search path. For a list of HOUDINI_UI_APP_PATH search directories, run hconfig -ap from a terminal.

Raises hou.OperationFailed if the .ui file contains errors and the dialog could not be created. Raises TypeError if ui_file_name is None.

Return the dialog defined by the given .ui file name and created by hou.ui.createDialog.

Return None if no dialog has been created with hou.ui.createDialog for the specified .ui file.

Raises TypeError if ui_file_name is None.

Return all dialogs created by hou.ui.createDialog.

Return True if the user is currently interacting with the UI in a way that is likely to cause a stream of node or parameter changes. This includes scrubbing the playbar, and dragging a handle in the viewport. Testing this value can be useful to avoid performing expensive updates to UI components that can wait until the user interaction is complete before performing their update.

Sets a flag checked by isUserInteracting(). That function will return True after setUserInteracting(True) is called, until you call setUserInteracting(False) to reset that flag.

This can be used in python viewer states, or python panels to stop certain UI updates during viewport interaction or when using UI widgets.

Set this to True when the interaction starts and False when it finishes.

Registers a hou.ViewerStateTemplate object representing a custom viewer state. See installing viewer states for how to use this function.

Raises hou.NameConflict if the registration fails because a state with the same name is already registered. Raises hou.OperationFailed if the registration fails (for example, the state to register has no factory).

Registers a viewer state type implemented in a given python file. Any viewer state previously registered by this file will be unregistered first.

See installing viewer states for more details about python state files.

Raises hou.OperationFailed if the registration fails (for example, the state to register has no factory).

Scans the viewer state folders ($HH/viewer_states and $HOUDINI_USER_PREF_DIR/viewer_states) to register all viewer states they both contain. Viewer states already registered in Houdini are simply updated with the version on disk.

Unregisters an existing viewer state type.

See installing viewer states for how to use this function.

Raises hou.OperationFailed if the unregistration fails (for example, if no state with the given name is registered).

Unregisters a viewer state previously registered with a given python file. See installing viewer states for more details about python state files.

Raises hou.OperationFailed if the unregistration fails (for example, if no state was registered with this file).

Returns True if state_name has previously been registered with hou.ui.registerViewerState. Returns False if not.

Update a registered viewer state by reloading its python module file from a viewer_states folder. This method works with self-installed states only. Embedded states can be updated simply by editing the code and re-saving the HDA. See installing states in Houdini for more details.

Raises hou.OperationFailed if the reload fails (for example, if no state with the given name is registered).

Reload multiple viewer states as specified in the state_names array. If the array is empty, all registered self-installed states in Houdini are reloaded. See hou.ui.reloadViewerState for more details on reloading a state.

Raises hou.OperationFailed if the reload fails (for example, if no state with a given name is registered).

Return a JSON dictionary string describing all registered viewer states keyed by state type.

import json

info_str = hou.ui.viewerStateInfo(["sidefx_stroke"])
info_dict = json.loads(info_str)
info = json.dumps(info_dict["sidefx_stroke"], indent=3)
print(info)

{
   "Type": "sidefx_stroke",
   "Label": "Stroke",
   "Icon": "$HFS/houdini/pic/minimizedicon.pic",
   "Category": "Sop",
   "Source": "$HFS/houdini/viewer_states/sidefx_stroke.py",
   "Contexts": [
      "SOP"
   ],
   "Handles": {},
   "Gadgets": {},
   "Selectors": {
      "sidefx_default_selector": {
         "Name": "sidefx_default_selector",
         "Auto start": false,
         "Hotkey": {
            "Path": "",
            "Label": "",
            "Description": "",
            "Keys": []
         },
         "Secure selection": "obey",
         "Prompt": "default geometry selector",
         "Allow drag": false,
         "Quick select": true,
         "Use existing selection": true,
         "Initial selection": "",
         "Initial selection type": "",
         "Ordered": false,
         "Geometry types": [],
         "Allow other sops": true
      }
   },
   "Menus": {
      "Stroke": {
         "Type": "Menu",
         "Handle": "stroke_menu",
         "Draw realtime": {
            "Type": "Toggle",
            "Handle": "realtime_mode",
            "Hotkey": {
               "Path": "h.pane.gview.state.sop.sidefx_stroke.realtime_mode",
               "Label": "realtime",
               "Description": "Enable realtime mode",
               "Keys": [
                  48
               ]
            }
         },
         "Brush settings...": {
            "Type": "Menu",
            "Handle": "brush_menu",
            "Cycle brushes": {
               "Type": "Action",
               "Handle": "cycle_brushes",
               "Hotkey": {
                  "Path": "h.pane.gview.state.sop.sidefx_stroke.cycle_brushes",
                  "Label": "Cycle brushes",
                  "Description": "Cycle stroke tools",
                  "Keys": [
                     49
                  ]
               }
            },
            "Brush display mode": {
               "Type": "Radio strip",
               "Handle": "brush_display_mode",
               "Default": "brush_viewport_display",
               "Wireframe": {
                  "Type": "Radio strip item",
                  "Handle": "brush_wireframe_display",
                  "Hotkey": {
                     "Path": "h.pane.gview.state.sop.sidefx_stroke.set_wireframe_brush",
                     "Label": "Set wireframe brush",
                     "Description": "Set wireframe brush",
                     "Keys": [
                        50
                     ]
                  }
               },
               "Viewport": {
                  "Type": "Radio strip item",
                  "Handle": "brush_viewport_display",
                  "Hotkey": {
                     "Path": "h.pane.gview.state.sop.sidefx_stroke.set_viewport_brush",
                     "Label": "Set viewport brush",
                     "Description": "Set viewport brush",
                     "Keys": [
                        51
                     ]
                  }
               }
            }
         }
      }
   }
}

Returns the viewer state information for a given python state file. The information is returned as a tuple containing the python state type name and a JSON dictionary string describing the registered viewer state information.

import json

(state_type, info_str) = hou.ui.viewerStateInfoFromFile(
    "$HFS/packages/viewer_state_demo/viewer_states/drawable_selector_sop.py"
)
info_dict = json.loads(info_str)
info = json.dumps(info_dict[state_type], indent=3)
print(info)

{
   "Type": "drawable_selector_sop",
   "Label": "State Drawable Selector Demo",
   "Icon": "DESKTOP_application_mac",
   "Category": "Sop",
   "Source": "$HFS/packages/viewer_state_demo/viewer_states/drawable_selector_sop.py",
   "Contexts": [
      "SOP"
   ],
   "Handles": {},
   "Gadgets": {},
   "Selectors": {
      "drawable_selector": {
         "Name": "drawable_selector",
         "Auto start": true,
         "Hotkey": {
            "Path": "h.pane.gview.state.sop.drawable_selector_sop.drawable selector",
            "Label": "drawable selector",
            "Description": "drawable selector",
            "Keys": [
               49
            ]
         },
         "Secure selection": "ignore",
         "Prompt": "Select a drawable component",
         "Allow drag": false,
         "Quick select": true,
         "Use existing selection": true,
         "Initial selection": "",
         "Initial selection type": "",
         "Ordered": false,
         "Geometry types": [
            "point",
            "edge",
            "prim"
         ],
         "Allow other sops": false
      },
      "primitive_selector": {
         "Name": "primitive_selector",
         "Auto start": false,
         "Hotkey": {
            "Path": "h.pane.gview.state.sop.drawable_selector_sop.primitive selector",
            "Label": "primitive selector",
            "Description": "primitive selector",
            "Keys": [
               50
            ]
         },
         "Secure selection": "ignore",
         "Prompt": "Select a primitive component",
         "Allow drag": true,
         "Quick select": true,
         "Use existing selection": true,
         "Initial selection": "",
         "Initial selection type": "",
         "Ordered": false,
         "Geometry types": [
            "prim"
         ],
         "Allow other sops": false
      },
      "sidefx_default_selector": {
         "Name": "sidefx_default_selector",
         "Auto start": false,
         "Hotkey": {
            "Path": "",
            "Label": "",
            "Description": "",
            "Keys": []
         },
         "Secure selection": "obey",
         "Prompt": "default geometry selector",
         "Allow drag": false,
         "Quick select": true,
         "Use existing selection": true,
         "Initial selection": "",
         "Initial selection type": "",
         "Ordered": false,
         "Geometry types": [],
         "Allow other sops": true
      }
   },
   "Menus": {
      "Drawable Selector Demo": {
         "Type": "Menu",
         "Handle": "drawable_selector_menu",
         "Log Info": {
            "Type": "Toggle",
            "Handle": "log_info",
            "Hotkey": {
               "Path": "",
               "Label": "",
               "Description": "",
               "Keys": []
            }
         },
         "Clear Console": {
            "Type": "Action",
            "Handle": "clear_console",
            "Hotkey": {
               "Path": "",
               "Label": "",
               "Description": "",
               "Keys": []
            }
         }
      }
   }
}

Registers a hou.ViewerHandleTemplate object representing a custom viewer handle. See installing viewer handle for how to use this function.

Raises these exceptions if the registration fails:

• hou.NameConflict if a handle with the same name is already registered.

• hou.OperationFailed if the registration fails (for example, the handle to register has no factory).

Scans the viewer handle folders (e.g. $HH/viewer_handles and $HOUDINI_USER_PREF_DIR/viewer_handles) to register all viewer handles they both contain. Viewer handles already registered in Houdini are simply updated with the version on disk.

Registers a viewer handle type implemented in a given python file. Any viewer handle previously registered by this file will be unregistered first.

See installing viewer handles for more details about python handle files.

Raises hou.OperationFailed if the registration fails (for example, the handle to register has no factory).

Unregisters a viewer handle previously registered with a given python file. See installing viewer handles for more details about python handle files.

Raises hou.OperationFailed if the unregistration fails (for example, if no handle was registered with this file).

Unregisters an existing viewer handle type.

See installing viewer handles for how to use this function.

Raises hou.OperationFailed if the unregistration fails (for example, if no handle with the given name is registered).

Update a registered viewer handle by reloading its python module file from a viewer_handle folder. See installing handles in Houdini for more details.

Raises hou.OperationFailed if the reload fails (for example, if no state with the given name is registered).

Returns True if handle_name has previously been registered with hou.ui.registerViewerHandle. Returns False if not.

Return a JSON dictionary string describing all registered viewer handles in Houdini. The viewer handles can be queried by type name.

    >>> import ast
    >>> viewer_handles = ast.literal_eval(hou.ui.viewerHandleInfo())
    >>> viewer_handles["move_tool_handle"]
{
   "Gadgets":{
      "zdisc":{
         "Drawable":"Line",
         "Name":"zdisc",
         "Label":"Z"
      },
      "yscale":{
         "Drawable":"Face",
         "Name":"yscale",
         "Label":"Y"
      },
      "yaxis":{
         "Drawable":"Line",
         "Name":"yaxis",
         "Label":"Y"
      },
      "zscale":{
         "Drawable":"Face",
         "Name":"zscale",
         "Label":"Z"
      },
      "zaxis":{
         "Drawable":"Line",
         "Name":"zaxis",
         "Label":"Z"
      },
      "xaxis":{
         "Drawable":"Line",
         "Name":"xaxis",
         "Label":"X"
      },
      "xscale":{
         "Drawable":"Face",
         "Name":"xscale",
         "Label":"X"
      },
      "pivot":{
         "Drawable":"Face",
         "Name":"pivot",
         "Label":"XYZ"
      },
      "xdisc":{
         "Drawable":"Line",
         "Name":"xdisc",
         "Label":"X"
      },
      "ydisc":{
         "Drawable":"Line",
         "Name":"ydisc",
         "Label":"Y"
      }
   },
   "Parameters":{
      "Sz":{
         "Default":1,
         "Range":"(0.1, 10)",
         "Type":"Float",
         "Name":"sz",
         "Label":"Sz"
      },
      "Sy":{
         "Default":1,
         "Range":"(0.1, 10)",
         "Type":"Float",
         "Name":"sy",
         "Label":"Sy"
      },
      "Sx":{
         "Default":1,
         "Range":"(0.1, 10)",
         "Type":"Float",
         "Name":"sx",
         "Label":"Sx"
      },
      "Tz":{
         "Default":0,
         "Range":"(-10, 10)",
         "Type":"Float",
         "Name":"tz",
         "Label":"Tz"
      },
      "Tx":{
         "Default":0,
         "Range":"(-10, 10)",
         "Type":"Float",
         "Name":"tx",
         "Label":"Tx"
      },
      "Ty":{
         "Default":0,
         "Range":"(-10, 10)",
         "Type":"Float",
         "Name":"ty",
         "Label":"Ty"
      },
      "Rx":{
         "Default":0,
         "Range":"(0, 360)",
         "Type":"Float",
         "Name":"rx",
         "Label":"Rx"
      },
      "Ry":{
         "Default":0,
         "Range":"(0, 360)",
         "Type":"Float",
         "Name":"ry",
         "Label":"Ry"
      },
      "Rz":{
         "Default":0,
         "Range":"(0, 360)",
         "Type":"Float",
         "Name":"rz",
         "Label":"Rz"
      }
   },
   "Settings":{
      "":{
         "Type":"Separator",
         "Name":"separator0",
         "Label":""
      },
      "Drag Along Plane":{
         "Default":"XZ",
         "Menu Items":[
            "(XZ, XZ)",
            "(XY, XY)",
            "(ZY, ZY)",
            "(XYZ, XYZ)"
         ],
         "Type":"Menu",
         "Name":"planes",
         "Label":"Drag Along Plane"
      },
      "Draw dimension lines":{
         "Default":1,
         "Type":"Toggle",
         "Name":"dimensions",
         "Label":"Draw dimension lines"
      }
   },
   "Menus":{
      "Move Tool Handle":{
         "Cycle Gadgets":{
            "Hotkey":{
               "Keys":[
                  89
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.cycle",
               "Description":"cycle",
               "Label":"cycle"
            },
            "Handle":"cycle",
            "Type":"Action"
         },
         "Handle":"move_tool_handle_menu",
         "Trace":{
            "Hotkey":{
               "Keys":[
                  51
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.trace_handle",
               "Description":"Enable handle trace",
               "Label":"Trace"
            },
            "Handle":"trace_handle",
            "Type":"Toggle"
         },
         "Edit":{
            "Hotkey":{
               "Keys":[
                  53
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.edit_handle",
               "Description":"Edit Handle",
               "Label":"Edit"
            },
            "Handle":"edit_handle",
            "Type":"Action"
         },
         "XYZ":{
            "Hotkey":{
               "Keys":[
                  65
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.XYZ",
               "Description":"XYZ",
               "Label":"XYZ"
            },
            "Handle":"XYZ",
            "Type":"Action"
         },
         "Inspect":{
            "Hotkey":{
               "Keys":[
                  50
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.inspect_handle",
               "Description":"Inspect Handle",
               "Label":"Inspect"
            },
            "Handle":"inspect_handle",
            "Type":"Action"
         },
         "XZ":{
            "Hotkey":{
               "Keys":[
                  70
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.XZ",
               "Description":"XZ",
               "Label":"XZ"
            },
            "Handle":"XZ",
            "Type":"Action"
         },
         "Reload":{
            "Hotkey":{
               "Keys":[
                  54
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.reload_handle",
               "Description":"Reload Handle",
               "Label":"Reload"
            },
            "Handle":"reload_handle",
            "Type":"Action"
         },
         "XY":{
            "Hotkey":{
               "Keys":[
                  71
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.XY",
               "Description":"XY",
               "Label":"XY"
            },
            "Handle":"XY",
            "Type":"Action"
         },
         "ZY":{
            "Hotkey":{
               "Keys":[
                  66
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.ZY",
               "Description":"ZY",
               "Label":"ZY"
            },
            "Handle":"ZY",
            "Type":"Action"
         },
         "Clear console":{
            "Hotkey":{
               "Keys":[
                  49
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.clear_console",
               "Description":"Clear console",
               "Label":"Clear"
            },
            "Handle":"clear_console",
            "Type":"Action"
         },
         "Marker":{
            "Hotkey":{
               "Keys":[
                  52
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.add_marker",
               "Description":"Add Marker",
               "Label":"Marker"
            },
            "Handle":"add_marker",
            "Type":"Action"
         },
         "Logging":{
            "Hotkey":{
               "Keys":[
                  48
               ],
               "Path":"h.pane.gview.handle.move_tool_handle.console_logging",
               "Description":"Enable or disable console logging",
               "Label":"Logging"
            },
            "Handle":"console_logging",
            "Type":"Toggle"
         },
         "Type":"Menu"
      }
   },
   "Label":"Move Tool Handle",
   "Exported Parameters":[
      "tx",
      "ty",
      "tz",
      "rx",
      "ry",
      "rz",
      "sx",
      "sy",
      "sz"
   ],
   "Source":"C:/Users/marcb/DEV/HOUDINI/dev/hfs/packages/viewer_handle_demo/viewer_handles/move_tool_handle.py",
   "Type":"move_tool_handle",
   "Categories":[
      "Sop"
   ],
   "Icon":"$HFS/houdini/pic/Mandril.pic"
}      

Open a modal dialog window for generating a template implementation and registration code for a python viewer handle. The input name of the viewer handle is mandatory for generating the code. Other fields such as the handle label and icon name are optional.

The dialog Sample options can be selected to generate the viewer handle code with predefined handlers and bindings. The Handler options can also be selected to generate the viewer handle code with empty handlers.

The dialog buttons:

• Accept: Generate the code template with the input fields and selected options.

• Cancel: Close the dialog and abort the code template generation.

This dialog is available from Viewer Handle Browser panel under the File|New... menu.

def myAcceptAction( **kwargs )

Register a Python callback to be called whenever a hou.resourceEventMessage event occurs.

Remove a specific Python callback previously registered with hou.ui.addResourceEventCallback.

This function triggers a custom resource event which can be used for implementing specific workflows. Client callbacks registered with hou.ui.addResourceEventCallback will get notified with the input user_data argument. The event can be processed immediately or later when Houdini is idle, see the queue argument for details.

Here’s how a custom event can be used.

# Register a callback for viewer state events
hou.ui.addResourceEventCallback(myEventHandler)

def myEventHandler(**kwargs):
    import json
    if kwargs['event_type'] == hou.resourceEventMessage.OnCustomEvent:
        if 'load_file' in kwargs:
            # load a json file and store results 
            with open(kwargs['load_file']) as file:
                json_values = json.load(file)                
        elif 'save_file' in kwargs:
            # save json_values to a json file
            with open(kwargs['save_file'], 'w') as file:
                json.dump(json_values, file, indent=3)

    # process other non-custom viewer state events
    elif kwargs['event_type'] == hou.resourceEventMessage.OnEnter:        
        pass

...
# load a json file via a custom event
hou.ui.fireResourceCustomEvent( hou.resourceType.ViewerState, { 'load_file': '/var/tmp/somefile.json'} )

Print a user message in the message window of a Viewer State Browser or Viewer Handle Browser. The hou.resourceEventMessage.OnPrintMessage event is sent when calling this function.

Packages are normally loaded on startup by Houdini, this API loads packages at runtime. loadPackage loads regular package files to setup the Houdini environment variables but can also be used for loading resource files installed in a plugin folder. This can be achieved with a simple package file to set HOUDINI_PATH with the plugin folder path containing the plugin resource files. loadPackage will load and install the resources found in HOUDINI_PATH.

See the Package Browser to learn about the structure of a package plugin folder and how to create a plugin folder.

Extracts the content of a package archive file on disk and load the embedded plugin resources and installation package. Package archives are typically used for packaging and installing plugins in Houdini. An exception is raised if the archive installation directory is read-only. The loaded package files installed from the archive are returned in a list.

See the Package Browser to learn more about package archives.

Unloads the plugin resources previously loaded with hou.ui.loadPackage.

Update a package previously loaded. The package is first unloaded to uninstall the current resources and loaded back.

The API is typically used by the Package Browser to activate a loaded package previously deactivated with hou.ui.deactivatePackage. Activating a package will reload the package environment variables and resources.

Deactivates a loaded package. Used by the Package Browser to unload a package while keeping the package listed in the browser tree. hou.ui.activatePackage can be used to activate the package again.

Return a JSON dictionary string describing one or multiple package plugins previously loaded in Houdini.

This shows the content of the viewer handle demo package.

>>> import json
>>> print( json.loads(hou.ui.packageInfo()) )
{
    'viewer_handle_demo': {
        'File path': '$HFS/houdini/viewer_handles/viewer_handle_demo.json',
        'Load only once': False,
        'Name': 'viewer_handle_demo',
        'Resources': {
            'Shelf': [
                '$HFS/packages/viewer_handle_demo/toolbar/viewer_handle_demo.shelf'],
            'Viewer Handle': [
                '$HFS/packages/viewer_handle_demo/viewer_handles/move_tool_handle.py',
                '$HFS/packages/viewer_handle_demo/viewer_handles/viewer_handle_intro1.py',
                '$HFS/packages/viewer_handle_demo/viewer_handles/viewer_handle_intro2.py',
                '$HFS/packages/viewer_handle_demo/viewer_handles/viewer_handle_intro3.py']
        },
        'Variables': {
            'HOUDINI_PATH': [
                '$HFS/packages/viewer_handle_demo']
         }
    }
}      

Return a tuple of strings that represent the hotkeys currently assigned to the action associated with the hotkey symbol. The hotkey symbols can be found in the $HH/config/Hotkeys directory.

Raises: hou.ValueError if the provided hotkey symbol doesn’t exist.

For example:

>>> hou.ui.hotkeys("h.copy")
('Alt+C', 'Ctrl+C')
>>> hou.ui.hotkeys("h.pane.copytab")
('Ctrl+T',)

Return a string that contains a description of the action associated with the hotkey symbol. The hotkey symbols can be found in the $HH/config/Hotkeys directory.

Raises: hou.ValueError if the provided hotkey symbol doesn’t exist.

For example:

>>> hou.ui.hotkeyDescription("h.pane.copytab")
'Copy Tab'

Return True if the key described by the string key matches one of the hotkeys assigned to the provided hotkey symbol. The hotkey symbols can be found in the $HH/config/Hotkeys directory.

Raises: hou.ValueError if the provided hotkey symbol doesn’t exist, or the key string doesn’t represent a valid hotkey.

For example:

>>> hou.ui.isKeyMatch("Ctrl+C", "h.copy")
True
>>> hou.ui.isKeyMatch("Ctrl+C", "h.pane.copytab")
False

Return the hou.AssetGalleryDataSource object that is currently being used to populate the asset gallery browsers in all Layout LOP nodes.

This method is deprecated in favor of hou.ui.sharedAssetGalleryDataSource.

Set the hou.AssetGalleryDataSource object that should be used to populate the asset gallery browsers in all Layout LOP nodes.

This method is deprecated in favor of hou.ui.setSharedAssetGalleryDataSource.

Forces all Layout LOP asset gallery browsers to reload from the underlying shared hou.AssetGalleryDataSource. Call this method after manipulating the data source returned by hou.ui.sharedLayoutDataSource() to refresh the layout asset browsers.

This method is deprecated in favor of hou.ui.reloadSharedAssetGalleryDataSource.

Return the hou.AssetGalleryDataSource object that is currently being used to populate the asset gallery browsers spcified by gallery_name. The built in shared galleries are 'layout' for Layout LOP and 'material' for Material LOP .

Set the hou.AssetGalleryDataSource object that should be used to populate the asset gallery browsers spcified by gallery_name. The built in shared galleries are 'layout' for Layout LOP and 'material' for Material LOP .

Forces all asset gallery browsers spcified by gallery_name to reload from the underlying shared hou.AssetGalleryDataSource. Call this method after manipulating the data source returned by hou.ui.sharedAssetGalleryDataSource to refresh the asset browsers.