If you have been reading bindpose for a while and have seen my marking menu posts you probably know that I am very keen on getting my workflow as optimized as possible. I am a big fan of handy shelfs, marking menus, hotkeys, custom widgets, etc. The way I see it, the closer and easier our tools are to access the quicker we can push the rig through. That is why today we are having a look at using PySide to install a global hotkey in Maya (one that would work in all windows and panels) in a way where we do not break any of the existing functionality of that hotkey (hopefully).
If you have not used PySide before, do not worry, our interaction with it will be brief and pretty straightforward. I myself am very new to it. That being said, I think it is a great library to learn and much nicer and more flexible than the native maya UI toolset.
Disclaimer: The way I do this is very hacky and dirty and I am sure there must be a nicer way of doing this, so if you have suggestions please do let me know, so I can add it both to my workflow and to this post.
What we want to achieve
So, essentially, all I want to do here is install a global hotkey (PySide calls them shortcuts) on the CTRL + H combination that would work in all Maya’s windows and panels as you would expect it to – Hide selected, but if we are inside the Script editor it would clear the history.
Some of you might think that we can easily do this without PySide, just using maya’s hotkeys, but the tricky bit comes in from the fact that maya’s hotkeys are not functioning when your last click was inside the Script editor’s text field or history field. That means, that only if you click somewhere on the frames of the Script editor would that hotkey get triggered, which obviously is not nice at all.
So, let us have a look at the full code first and then we will break it apart.
from functools import partial from maya import OpenMayaUI as omui, cmds as mc try: from PySide2.QtCore import * from PySide2.QtGui import * from PySide2.QtWidgets import * from shiboken2 import wrapInstance except ImportError: from PySide.QtCore import * from PySide.QtGui import * from shiboken import wrapInstance def _getMainMayaWindow(): mayaMainWindowPtr = omui.MQtUtil.mainWindow() mayaMainWindow = wrapInstance(long(mayaMainWindowPtr), QWidget) return mayaMainWindow def shortcutActivated(shortcut): if "scriptEditor" in mc.getPanel(wf=1): mc.scriptEditorInfo(clearHistory=1) else: shortcut.setEnabled(0) e = QKeyEvent(QEvent.KeyPress, Qt.Key_H, Qt.CTRL) QCoreApplication.postEvent(_getMainMayaWindow(), e) mc.evalDeferred(partial(shortcut.setEnabled, 1)) def initShortcut(): shortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_H), _getMainMayaWindow()) shortcut.setContext(Qt.ApplicationShortcut) shortcut.activated.connect(partial(shortcutActivated, shortcut)) initShortcut()
Okay, let us go through it bit by bit.
We start with a simple import of partial which is used to create a callable reference to a function including arguments. Then from maya we the usual
cmds, but also
OpenMayaUI which we use to get a PySide reference to maya’s window.
Then the PySide import might look a bit confusing with that try and except block, but the only reason it is there is because between maya 2016 and maya 2017 they switched PySide versions, and the imports had to change as well. So, what we do is we try to import from PySide2 (Maya 2017) and if it cannot be found we do the imports from PySide (Maya 2016).
Getting Maya’s main window
Even though, Maya’s UI is built entirely by Qt (PySide is a wrapper around Qt), the native elements are not usable with PySide functions. In order to be able to interact with these native bits we need to find a PySide reference to them. In the example for hotkeys we need only the main window, but depending on what you are trying to do you might have to iterate through children in order to find the UI element you are looking for. Therefore this
_getMainMayaWindow function has become a boilerplate code and I always copy and paste it together with the imports.
The way it works is, using Maya’s API we get a pointer to the memory address where Maya’s main window is stored in memory. That’s the
omui.MQtUtil.mainWindow() function. Then what we do is, using that pointer and the
wrapInstance function we create a PySide
QWidget instance of our window. That means that we can run any
QWidget functions on Maya’s main window. In our hotkey example, though, we only need it to bind the hotkey to it.
The logic of the hotkey
shortcutActivated function is the one that is going to get called every time we press the hotkey. It takes a
QShortcut object as an argument, but we will not worry about it just yet. All we need to know is that this object is what calls our
It is worth mentioning that this function is going to get called without giving Maya a chance to handle the event itself. So, that means that if we have nothing inside this function, pressing CTRL + H will do nothing. Therefore, we need to make sure we implement whatever functionality we want inside of this function.
So, having a look at the if statement, you can see that we are just checking if the current panel with focus –
mc.getPanel(wf=1) – is the Script editor. That will return
True if we have last clicked either on the frames of the Script editor windows or anywhere inside of it.
Then, obviously, if that is the case we just clear the Script editor history.
If it returns
False, though, it means that we are outside of the Script editor so we need to let Maya handle the key combination as there might be something bound to it (In the case of CTRL+H we have the hiding functionality which we want to maintain). So, let us pass it to Maya then.
As I said earlier, Maya does not get a chance to handle this hotkey at all, it is entirely handled by PySide’s shortcut. So in order to pass it back to Maya, what we do is we disable our shortcut and we simulate the key combination again, so Maya can do it’s thing. Once that is done, we re-enable our shortcut so it is ready for next time we press the key combination. That is what the following snippet does.
shortcut.setEnabled(0) e = QKeyEvent(QEvent.KeyPress, Qt.Key_H, Qt.CTRL) QCoreApplication.postEvent(_getMainMayaWindow(), e) mc.evalDeferred(partial(shortcut.setEnabled, 1))
Notice we are using
evalDeferred as we are updating a shortcut from within itself.
Binding the function to the hotkey
Now that we have all the functionality ready, we need to bind it all to the key combination of our choice – CTRL + H in our example. So, we create a new
QShortcut instance, which receives a
QKeySequence and parent
QWidget as arguments. Essentially, we are saying we want this key combination to exist as a shortcut in this widget. The widget we are using is the main maya window we talked about earlier.
Then, we use the
setContext method of the shortcut to extend it’s functionality across the whole application, using
Qt.ApplicationShortcut as an argument. Now the shortcut is activated whenever we press the key combination while we have our focus in any of the maya windows.
Lastly, we just need to specify what we want to happen when the user has activated the shortcut. That is where we use the activated signal of the shortcut (more info on signals and slots) and we connect it to our own
shortcutActivated function. Notice that we are using
partial to create a callable version of our function with the shortcut itself passed in as an argument.
And that’s it!
Hotkeys, marking menus, shelves, custom widgets and everything else of the sort is always a great way to boost your workflow and be a bit more efficient. Spending some time to build them for yourself in a way where you can easily reproduce them in the next version of Maya or on your next machine is going to pay off in the long run.
I hope this post has shown you how you can override maya’s default hotkeys in some cases where it would be useful, while still maintaining the default functionality in the rest of the UI.
If you know of a nicer way of doing this, please do share it!