Each event sent to the handleEvent function will be one of the event types defined in the $HFS/houdini/python2.7libs/canvaseventtypes.py module.

Several of the events defined above make use of helper classes for describing interface components under the mouse, or the current state of mouse buttons. These classes are also defined in $HFS/houdini/python2.7libs/canvaseventtypes.py.

There are two coordinates systems used by the network editor. One is the “network” coordinates. This is the native coordinate system of a network. In this system, node tiles are generally about one unit wide. hou.Node.position returns the location of the lower left corner of the node in network coordinates.

The other coordinate system is the screen coordinate system. In this system, (0, 0) is the lower left corner of the network editor pane, and one unit is one pixel.

Almost all methods and data that don’t have “screen” or “mouse” in their name are expressed in network coordinates. And there are methods on hou.NetworkEditor to translate from one to the other. So hou.NetworkEditor.posToScreen() converts a position in network coordinates into the equivalent position in screen coordinates. hou.NetworkEditor.visibleBounds() returns the visible area of the network editor in network coordinates, and hou.NetworkEditor.screenBounds() returns the bounds in screen coordinates. When you pan around the network editor, your screen bounds are unchanged, but your visible bounds will change.

The first opportunity for customizing the behavior of the network editor is provided by the createEventHandler function. Before even looking at the event, the event will be sent to nodegraphhooks.createEventHandler(). The default implementation of this function returns a value indicating that the events should be processed normally. However you can create a new nodegraphhooks module in your python path such that it is found before the one in $HFS/houdini/python2.7libs. You then have the opportunity to intercept any event, as long as there is no user operation in progress (if an EventHandler is already active, you do not have the chance to intercept those events).

This function is passed an event object, and a pending_actions parameter which can generally be ignored. It must return a tuple consisting of a EventHandler object or None, followed by a bool value indicating whether the event was handled. In the case of events like keyboard key presses, where the user operation is completed by the single event, you will return (None,True) to indicate that there is no EventHandler set up, but that further processing of the event should not occur.

In addition to custom handling of hotkeys, another common use for hooking would be to modify the behavior of certain operations (such as dragging nodes with certain modifier keys to do something other than simply moving the nodes). In this case you want most of the node behaviors to remain intact, but you want to customize the user operation under certain circumstances. The best way to accomplish this is by creating a subclass of one of the many EventHandler subclasses that already exist in the network editor control modules. Within the handleEvent method of the subclass, most events can defer to the base class, but specific events can be intercepted to change the behavior as desired.

You may also define a createEventHandler function inside the PythonModule of an HDA. This function takes the same parameters and returns the same values as the global hook function, but is only called when the event from the user is a mouse event on some part of a node tile for an instance of your HDA. This allows you to provide specialized behaviors when interacting with your HDA (such as customizing the double click event to dive to a specific location within the node). Because the PythonModule is part of the HDA definition, these custom behaviors will show up anywhere that you install the HDA without having to modify the global hook function.

The following code will modify the behavior of the hotkey for diving into a node so that it dives into the node under the mouse instead of the current node. This code should be placed in $HOUDINI_USER_PREF_DIR/python2.7libs/nodegraphhooks.py:

import hou
from canvaseventtypes import *
import nodegraphdisplay as display
import nodegraphview as view

def createEventHandler(uievent, pending_actions):
    if isinstance(uievent, KeyboardEvent) and \
       uievent.eventtype == 'keyhit':
        # This is a key hit event. Check for the 'dive in' key.
        editor = uievent.editor
        key = uievent.key
        eventtype = uievent.eventtype
        if display.setKeyPrompt(editor, key, 'h.pane.wsheet.jump', eventtype):
            # Find the node under the mouse.
            pos = uievent.mousepos
            items = editor.networkItemsInBox(pos, pos, for_select = True)
            for (item, name, index) in items:
                if isinstance(item, hou.Node) and item.isNetwork():
                    view.diveIntoNode(editor, item)
                    break
            # We handled this event, but don't need to return an event handler
            # because this is a one-off event. We don't care what happens next.
            return None, True

    return None, False

The following code will intercept the ⌃ Ctrl + ⇧ Shift + H key to set the network editor to a fixed zoom level, with the current node positioned under the mouse. This code should be placed in $HOUDINI_USER_PREF_DIR/python2.7libs/nodegraphhooks.py:

from canvaseventtypes import *

def createEventHandler(uievent, pending_actions):
    if isinstance(uievent, KeyboardEvent) and \
       uievent.eventtype == 'keyhit' and \
       uievent.key == 'Ctrl+Shift+H':
        # Get the current bounds.
        screenbounds = uievent.editor.screenBounds()
        bounds = uievent.editor.visibleBounds()
        # Figure out how much we need to scale the current bounds to get to
        # a zoom level of 100 pixels per network editor unit.
        currentzoom = screenbounds.size().x() / bounds.size().x()
        desiredzoom = 100.0
        scale = currentzoom / desiredzoom

        # Get the current node.
        currentnode = uievent.editor.currentNode()
        if currentnode is not None:
            mousepos = uievent.mousepos
            mousepos = uievent.editor.posFromScreen(mousepos)
            noderect = uievent.editor.itemRect(currentnode)
            # Do the zoom centered at the mouse position.
            zoomcenter = mousepos
            bounds.translate(-zoomcenter)
            bounds.scale((scale, scale))
            bounds.translate(zoomcenter)
            # Move the view so the current node is under the mouse.
            bounds.translate(noderect.center() - mousepos)
            # Set the new bounds.
            uievent.editor.setVisibleBounds(bounds)

        # We handled this event, but don't need to return an event handler
        # because this is a one-off event. We don't care what happens next.
        return None, True

    return None, False

The following code demonstrates the creation of an EventHandler subclass to override the behavior of a double click event on a node. Instead of diving into the node, it does nothing. This is unlikely to be a desirable change as a global hook, but might be useful as part of a PythonModule in a specific HDA:

import hou
import nodegraph
from canvaseventtypes import *

class NoDiveNodeMouseHandler(nodegraph.NodeMouseHandler):
    def handleEvent(self, uievent, pending_actions):
        if isinstance(uievent, MouseEvent) and \
           uievent.eventtype == 'doubleclick':
            return None

        return nodegraph.NodeMouseHandler.handleEvent(
            self, uievent, pending_actions)

def createEventHandler(uievent, pending_actions):
    if isinstance(uievent, MouseEvent) and \
       uievent.eventtype == 'mousedown' and \
       isinstance(uievent.selected.item, hou.Node):
        return NoDiveNodeMouseHandler(uievent), True

    return None, False