This method is deprecated. Use hou.hotkeys.installDefinitions instead.

Registers a new configurable hotkey command with Houdini. The context it belongs to should already exist, see hou.hotkeys.addContext.

A hotkey symbol represents an action, for example deleting the selected geometry when a certain tool is active. The user can change the actual key assigned to the action using the hotkey editor. After registering the symbol you can programmatically assign a default key using hou.hotkeys.addAssignment.

To add a delete action to the demo python state, you would do something like this:

# Add a hotkey context for the demo python state
demo_context = "h.pane.gview.state.sop.demo"
hou.hotkeys.addContext(demo_context, "demo Operation", "These keys apply to the demo operations")

# Add hotkeys to the "demo" state
delete_symbol = demo_context + ".delete"
hou.hotkeys.addCommand(
    delete_symbol,
    "Delete Selected",
    "Delete the selected geometry"
)
commit_symbol = demo_context + ".commit"
hou.hotkeys.addCommand(
    commit_symbol,
    "Commit Changes",
    "Save changes to parameters and start a new cache"
)
cancel_symbol = demo_context + ".cancel"
hou.hotkeys.addCommand(
    cancel_symbol,
    "Cancel Changes",
    "Discard any  changes and return to an empty cache"
)

This method is deprecated. Use hou.hotkeys.installDefinitions instead.

Registers a new hotkey context with Houdini. A context should be created before creating contexts or commands within that context.

Currently this is only useful for adding hotkeys to Python states.

h.pane.gview.state.sop

This method is deprecated. Use hou.hotkeys.uninstallDefinitions instead.

Removes an existing hotkey previously created with /hom/hou/hotkeys.html#addCommand.

hou.hotkeys.removeHotkeySymbol("h.pane.gview.state.sop.demo.delete")

Installs any command categories, commands, binding contexts and default bindings used by a plugin.

Though python states install their hotkey definitions through their hou.ViewerStateTemplate and should not call this method, they are still a good example of how to populate to populate a hou.PluginHotkeyDefinitions object. For instance, for adding several hotkey actions to the demo python state, you would do something like this:

definitions = hou.PluginHotkeyDefinitions()

# Add a command category the demo python state
demo_category = "h.pane.gview.state.sop.demo"
definitions.addCommandCategory(demo_category, "demo Operation", "These actions apply to the demo operation")

# Add commands under the command category for the demo python state
delete_symbol = demo_category + ".delete"
definitions.addCommand(
    delete_symbol,
    "Delete Selected",
    "Delete the selected geometry"
)
commit_symbol = demo_category + ".commit"
definitions.addCommand(
    commit_symbol,
    "Commit Changes",
    "Save changes to parameters and start a new cache"
)
cancel_symbol = demo_category + ".cancel"
definitions.addCommand(
    cancel_symbol,
    "Cancel Changes",
    "Discard any  changes and return to an empty cache"
)

# Add a context for the demo python state to hold the state's key bindings
demo_context = "h.pane.gview.state.sop.demo"
definitions.addContext(demo_context, "demo Operation", "These keys apply to the demo operation")

# Add any default key bindings for the commands to the context.
definitions.addDefaultBinding(demo_context, delete_symbol, ("Del",))
definitions.addDefaultBinding(demo_context, commit_symbol, ())
definitions.addDefaultBinding(demo_context, cancel_symbol, ())

Uninstalls any command categories, commands, binding contexts and default bindings used by a plugin.

Does a “reverse-lookup” to retrieve the hotkey symbol given the human-readable context label(s). If you supply only a context label, the function returns the context’s prefix symbol. If you also supply a command label, the function returns the command’s hotkey symbol.

hou.hotkeys.hotkeySymbol("/Houdini/Panes/Geometry Viewers", "Box Selection")
# "h.pane.gview.selectstylebox"

Adds a binding for command in context so that it appears in the hotkey manager for key assignment if one does not already exist. Keys can then be assigned to this binding via hou.hotkeys.addAssignment. It is not necessary to do this prior to adding assignments, but if you want to create an empty binding without any assigned keys, use this.

Removes the binding for command from context. Note that in most cases you probably want remove all key assignments from the binding, leaving the binding itself in place. See hou.hotkeys.clearAssignments.

Assigns a key (or key combination) to a hotkey symbol in the given context.

hou.hotkeys.addAssignment("h.pane.gview.state.sop.demo", "h.pane.gview.state.sop.demo.delete", "alt+k")
hou.hotkeys.addAssignment("h.pane.gview.state.sop.demo", "h.pane.gview.state.sop.demo.delete", "shift+del")

Returns True if the assignment succeeds, or False if the symbol is unknown or the key string is not valid.

This function also has a deprecated signature without the context argument. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable.

Removes any keys assigned to a hotkey symbol in the given context.

hou.hotkeys.clearAssignments("h.pane.gview.state.sop.demo", "h.pane.gview.state.sop.demo.delete")

This function also has a deprecated signature without the context argument. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable.

• hou.hotkeys.addCommand

Removes a key (or key combination) from a hotkey symbol in a given context.

hou.hotkeys.removeAssignment("h.pane.gview.state.sop.demo", "h.pane.gview.state.sop.demo.delete", "alt+k")

This function also has a deprecated signature without the context argument. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable.

Returns a sequence of symbol strings in ancestor and/or descendant contexts relative to the given context (including the symbol you passed in itself) that use the given key. This lets you see existing or potential conflicts. The returned strings are encoded as <context>?<symbol>.

This function also has a deprecated signature without the context argument. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable. Under the old hotkey system, the returned strings are simply the symbols.

An example of a conflict would be if a high level action (for example, h.copy, in the h context) has hotkey ⌃ Ctrl + C, and a lower-level action (for example, h.panes.gview.state.sop.demo.duplicate in the h.panes.gview.state.sop.demo context) also uses ⌃ Ctrl + C, then where you're in that state, the higher-level Copy key won’t be available because it’s overridden by the lower-level key.

# Find potential conflicts with K on the top-level Add Keyframe command
symbols = hou.hotkeys.findConflicts("h", "h.add_key", "k")
# Returns ('h.pane.gview.state.sop.topobuild?h.pane.gview.state.sop.topobuild.bridge', 'h?h.add_key'),
# meaning K is assigned to both h.add_key and
# h.pane.gview.state.sop.topobuild.bridge
# in the same hierarchy

# Find potential conflicts with Ctrl + C on the top-level Copy command
symbols = hou.hotkeys.findConflicts("h.copy", "ctrl+c")  # (Use cmd+c on Mac)
# Returns ("h.copy",) meaning there are no conflicts (the symbol
# you checked is the only symbol in that hierarchy using that key)

Return the monotonically increasing change index from the hotkey manager. This number increases by one whenever any change is made to the hotkey manager. If a module is caching any information from the hotkey manager it should check this change index to see if any changes have been made and thus the cache should be refreshed.

Return a list of shortcuts assigned to the specified hotkey symbol in a context.

This function also has a deprecated signature without the context and resolve_refs arguments. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable.

Return the human-readable label for a symbol string.

label = hou.hotkeys.hotkeyLabel("h.open")
# "Open"

Returns the long description/help for a the given symbol string.

desc = hou.hotkeys.hotkeyDescription("h.open")
# "Open a file"

Return True is key is a match for the given hotkey symbol. If key is a keyvoard shortcut string then it must match one of the keyboard shortcuts assigned to the hotkey. If key is a hotkey symbol then it must be a string match to hotkey_symbol.

Return True is keycode is a match for the given hotkey symbol.

This method is deprecated under the new hotkey system. Use either hou.hotkeys.commandsInCategory or hou.hotkeys.commandBindingsInContext instead.

Return all hotkey commands at the given parent hotkey context.

Each command is a dict with the following keys: “symbol”, “label”, and “help”.

Return all hotkey contexts at the given parent hotkey context.

Each command is a dict with the following keys: “symbol”, “label”, and “help”.

Return all hotkey command categories under the given parent hotkey category.

Each category is a dict with the following keys: “symbol”, “label”, and “help”.

Return all hotkey commands under the given parent category.

Each command is a dict with the following keys: “symbol”, “label”, and “help”.

Return all commands bound in the given hotkey context.

Each command is a dict with the following keys: “symbol”, “label”, and “help”.

Revert the specified hotkey to its defaults from the keymap.

This function also has a deprecated signature without the context argument. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable.

Save changes to the hotkeys as overrides to the current keymap. Changes are things that are different from their default value e.g. modifying a shortcut key assignment. Note that adding a new hotkey command with addHotkey will treat it as a new default so that it won’t be saved unless a change is made to it after it is added.

Save the currently defined hotkeys as a keymap. This combines the loaded keymap with all of the defined overrides into a single new keymap. Returns True upon successful save.

Save the currently defined hotkeys as a keymap. This combines the loaded keymap with all of the defined overrides into a single new keymap. Returns True upon successful load.

Copy the specified keymap into the user preferences directory and save it with an appropriate name. Returns True upon successful import.

Return a list of tuples of all the keymaps found. The tuple has the keymap’s name and path.

Return the name of the currently loaded keymap.

Return all available shortcut keycodes with their conflict status bits set w.r.t. the specified hotkey symbol. A keycode is considered available if it isn’t assigned to another hotkey within the given context.

This function also has a deprecated signature without the context argument. The deprecated signature should not be used unless use of the old hotkey system has been forced with an environment variable.

Convert a keystring to a hotkeymanager keycode.

Convert a hotkeymanager keycode to a key string.

Return a tuple of strings that represent the hotkeys that will invoke each action from a tuple of hotkey symbols when resolved against a specific list of hotkey contexts. The key strings are of the form returned by the hou.ui.hotkeys method, which is a combination of the symbol on the key, and any modifier keys involved, such as "Ctrl+Shift+G".