I just spent the last couple of days refactoring keyboard input handling in MacVim and thought I’d write down some of my findings here for posterity. I’ve read Apple’s documentation on the Cocoa text system over and over again, but it assumes that you are writing a new Cocoa application from scratch and it doesn’t really cover the case when you are porting an app which already has its own way of dealing with keyboard input. If you are in the latter situation, these notes may be of use to you.
My expectations in MacVim are these: I want to enable the use of different input sources (different keyboard layouts as well as more complex input sources such as Kotoeri) but at the same time I need to pass raw key events (which key was pressed and which modifiers were held?) on to Vim since it does its own processing.
Keyboard input arrives in an NSView derived subclass as follows (by “Cmd keys” I mean keys pressed at the same time as Cmd is held and similarly for Ctrl/Alt/Shift):
- Cmd and Ctrl keys are sent to
performKeyEquivalent: before being passed on to the app menus for key equivalent handling. Note: on Tiger Ctrl keys go directly to
keyDown: and (more importantly) if you don’t handle a Cmd key here it will never reach
keyDown:. In Leopard Apple fixed this problem: unhandled Cmd key presses (i.e. ones that did not have a menu item bound to them) are sent to
keyDown:.The way MacVim handles Cmd key presses on Tiger is to call
[[NSApp mainMenu] performKeyEquivalent:event] inside
performKeyEquivalent: and if that returns
NO send the Cmd key on to Vim and return
YES. This way it is possible to bind menu items to key equivalents and let Vim deal with unbound Cmd keys.
keyDown: is called. Ideally at this stage I’d like to inspect the
NSEvent and pass it on to Vim, but doing so would disable input sources like Kotoeri. To give these a chance to respond to the key event you must call
interpretKeyEvents:. When this is done, one of the following will happen:
insertText: is called with text to insert (in the form of a
NSString or a
doCommandBySelector: is called with a selector whose name indicates what should happen (e.g.
insertNewline:) but the selector name can also be
noop: (which is meaningless)
- the current input source swallows the event and tells us to add marked text (e.g. this happens when you press Alt+i on a US keyboard)
- the input manager swallows the event and nothing happens (e.g. you press Cmd+Alt and some key which was not bound to a menu item)
If this looks complicated, well, that’s because it is! Lets discuss in more detail the things that can happen as a result of calling
insertText: is called with the text to insert, e.g. when you hit a key by itself or with Shift held. This is also the case with most Alt keys (on a US keyboard layout) except for some “dead keys” such as Alt+i and Alt+e. Be careful with the parameter to
insertText: — it may be either a
NSString or a
NSAttributedString. In MacVim I explicitly check for the latter case and extract the string from it (since I can’t support the attributes anyway) as follows:
if ([string isKindOfClass:[NSAttributedString class]])
string = [string string];
insertText: may be called with more than one character, e.g. when inserting previously marked text. Typically this happens when you use complex input sources such as Kotoeri. Also,
insertText: may be called without any keys being pressed at all. For example, the “Special Characters” palette may be used to insert text (this palette can usually be found on the “Edit” menu) so don’t rely on the current event being a key event inside
Keys that have a key binding on the other hand will cause
doCommandBySelector: to be called, e.g. Ctrl+[ is by default bound to
cancelOperation:. In this situation it is a bit tricky to figure out what to do. One possibility is to do nothing and then back in
keyDown: look at the
NSEvent object to figure out what to do (e.g. by calling
characters on the event) and this may work in most cases. However, there are several cases I know of where it does not work so well.
For example, if you press "Alt+i, Return" then the first press (Alt+i) causes marked text to be added, and the second (Return) will first cause the input manager to call
insertText: with the marked text (^) and then
doCommandBySelector: is called with the selector
insertNewline:. If you inspect the
[NSEvent characters] in
keyDown: for the event generated by the Return press, it will return
^\x0d and not
\x0d as you would expect (i.e. the event contains the result of the Alt+i press as well!). In MacVim I check for certain selectors (e.g.
doCommandBySelector: and pass an appropriate key on to Vim, but most selectors I ignore and deal with it in
Swallowed key events
The problem with the input manager swallowing events is hard to deal with. It can be solved by adding appropriate key bindings but currently there is no public API to modify the key bindings at run time.
For example, Cmd+Alt keys will be blocked, but if you add an entry to the key bindings dictionary with the key "@~" and value
noop: (@=Cmd, ~=Alt) then the input manager will pass any Cmd+Alt presses on to
doCommandBySelector: with selector
noop:. One way to deal with this via Private APIs is to set your own key binding dictionary when initializing your app and make sure your own dictionary contains entries such as "@~" to let key presses through. This is the API you can use to do so:
@interface NSKeyBindingManager : NSObject
And here is how to set your own dictionary (assuming
dict has been populated with your own key bindings already):
NSKeyBindingManager *mgr =
I have yet to find any problems caused by this, but try it at your own risk. One thing to note is that your custom key bindings dictionary should contain most (if not all) of the bindings found in the system default key bindings dictionary
else keyboard navigation may not work in dialogs since they rely on these standard bindings (e.g. forget to bind Return to
insertNewline: and you won't be able to use Return to dismiss dialogs).
The unexpected Ctrl+q
Another gotcha I came across in my investigations was that Ctrl+q always seemed to be swallowed by the input manager and then the next keystroke would get mangled in one way or another. The problem turned out to be a User Default called NSQuotedKeystrokeBinding. By default this is set to "^q" (Ctrl+q) and is used to literally enter keys that would otherwise be interpreted by the input manager. Hence, if you ever want to receive any Ctrl+q presses this needs to be disabled, which fortunately is easy using a little bit of Core Foundation:
This should be called in the initialization of your application.
Apple is a bit vague on how to support marked text handling in custom views. Basically, they say you should implement the
NSTextInput protocol but then they don't exactly explain how this is done.
One method that seems to work well is to keep a
NSString and a
NSRange in your custom view and whenever
setMarkedText:selectedRange: is called you update your marked text and range variables. Occasionally the input manager will ask if there is any marked text and what the selected range is by calling
markedRange. When the user finishes entering marked text (e.g. by hitting Enter in Kotoeri manager), the input manager calls
insertText: to let you know that it is finished with the current marked text entry. As a result you should always clear you local marked text and range variables. Note that the input manager almost never explicitly calls
unmarkText to unmark the text, which is why you need to do the unmarking manually in
When a Cmd key press reaches
keyDown: I ideally would like to know which key was pressed and which modifiers were held but there is a problem here in that Cocoa sometimes will add the modifiers into the key and sometimes not. This turns into a game as to whether to extract
charactersIgnoringModifiers from the
NSEvent and trying to guess which of the flags in
modifierFlags have already been included in the event.
This is already turning into one massive post so let me just summarize the heuristic I finally settled on:
- If Shift and/or Alt is held, then use
charactersIgnoringModifiers, otherwise use
- The Shift flag is always included in the key so clear it from
modifierFlags. The Alt flag should only be cleared if the Ctrl flag is set as well.
Note that I could not find any (reasonably easy) way of extracting which unmodified key on the physical keyboard was pressed. Even though the method is called
charactersIgnoringModifiers it will some times include the modifier flags (e.g. Shift, Alt) and sometimes it won't.