Mac Hacks (18 page)

Keybindings
let you create keyboard shortcuts that are available in
almost any program where you can edit text.

Text input is a huge part of using any computer. Typing emails,
writing notes, even putting together books—it’s all part of every user’s
digital life. Fortunately, you can hack your system to make text-entry
easier. One of the most interesting and powerful of those is the
keyboard-shortcut system that OS X calls
keybindings
.
Keybindings assign keyboard shortcuts to commands. (If you’ve ever used
Command-C to copy or Command-S to save, you’ve used keybindings.) What few
people know is that you can create your own bindings. (One exception: you
can’t create keybindings for Microsoft programs like Word.)

On
your Mac, you can create a text file in
~/Library/KeyBindings
called
DefaultKeyBinding.dict
to which you can add
your own custom tricks. If you’re working in Finder, the easiest way to
get to this directory is to press Command-Shift-G, then type
~/Library
and press Return. If you see a folder
called KeyBindings, open it; if you don’t, use Command-Shift-N to create
it (make sure to capitalize it the way I’ve written it here). Next, open
up TextEdit (or your text editor of choice) and create a new file. Save it
as
DefaultKeyBinding.dict
in the
KeyBindings folder you just located or created (you can get to this folder
from a Save dialog box using the exact same procedure as above: press
Command-Shift-G, and then type
~/Library/KeyBindings
). Now you’re ready to
start adding your own bindings.

These bindings can include shortcuts for cursor movement; text
selection; and deleting, copying, pasting, and inserting text. You can
even combine the shortcuts in sequences, which provides a wide variety of
possibilities. The
DefaultKeyBinding.dict
file is in a plain-text
PLIST format (see
[Hack #6]
), so it’s easy to
modify in any text editor.

You can see my custom keybindings file at
http://ttscoff.github.com/KeyBindings
to get some ideas.
You’ll probably want to start with a fresh one, though, and only add the
bindings that you need. It’s easy to lose track of what you’ve created if
you don’t use them often, and using bindings that another application has
assigned can lead to confusing behavior in that app. It’s best to create
bindings one or two at a time and get used to them before getting too
crazy. An empty
DefaultKeyBinding.dict
file simply looks like
this:

{
}

You
add bindings between the curly brackets. Here’s an example
binding:

"^T" = (capitalizeWord:, moveWordForward:, moveWordBackward:);

The first part of any keybinding—the bit before the equal sign—is
the key combination that will trigger the action. Here are the symbols you
use in this part of the keybinding to represent
modifier keys:

These can be used in combination with other modifier keys and
regular characters to create shortcuts that won’t conflict with default
system ones.

The next part—the bit after the equal sign—is what happens when you
type the specified key combination in a text field. It consists of a
sequence of commands that will be performed in order. There
are quite a few commands available, including cursor
movement, text insertion/deletion, and copy-and-paste functions. Jacob Rus
has a helpful
list of
available commands
. The sample binding above (the one triggered by
pressing Control-Shift-T) capitalizes the word that your insertion point
is currently within and then moves the insertion point to the next word
when you type. It allows you to put your insertion point at the beginning
of a title and then press the key combination repeatedly to capitalize all
the words in the title.

One of my favorite and most useful keybindings is a replication of
the Command-Return keybinding found in the text editor TextMate. In
TextMate, this keybinding allows you to type Command-Return when your
insertion point is anywhere within a line to add a blank line below the
current paragraph, and your insertion point will jump to the new line
without breaking the text in the current line. The keybinding definition
looks like this:

// TextMate Command-Return (Command Enter)
"@\U000D" = (moveToEndOfParagraph:, insertNewline:);

Lines
beginning with
//
are
comments and are ignored by the system, but they’re useful for reminding
you what this keybinding is for. The
\U000D
part is the code you need to use for
Return, as there’s no character representation of it. The command
sequence, as you can probably tell, just moves the cursor to the end of
the paragraph and inserts a blank line. Simply placing these lines of code
between the curly brackets in your
DefaultKeyBinding.dict
file will create this
shortcut on your system, and it will be available to
any
application the next time you start it.
(Applications that are running when you save the file will need to be
restarted for it to take effect.)

Along the same lines, here’s a keybinding that does the opposite.
Pressing Command-Shift-Return will insert a new line
above
the current paragraph and jump to it .

// Insert blank line above paragraph (Command Shift Return)
"@$\U000D" = (moveToBeginningOfParagraph:, moveLeft:, insertNewline:);

Lastly, you can also nest commands to create sequences. For example,
I use nested commands to create
Markdown
links
using my clipboard contents. (Markdown is a plain-text syntax created by
John Gruber that lets you rapidly create HTML and rich-text documents.)
The following code creates a sequence that allows me to copy a URL to my
clipboard, select some text, and then type Control-Command-W, then l
(that’s a lowercase L, not the number one), then c to reformat the
selected text as “[selected text](URL from clipboard),” which becomes an
HTML link when the Markdown is converted:

"^@w" = { // Multi-stroke Markdown command
"l" = { // Markdown link
"c" = (setMark:, breakUndoCoalescing:, moveRight:, insertText:, " ", deleteToMark:, insertText:, " [", moveLeft:, deleteBackward:, moveRight:, yank:, moveLeft:, insertText:, "](", setMark:, pasteAsPlainText:, insertText:, ")", moveRight:, deleteBackward:, moveLeft:, selectToMark:); // link with clipboard
};
};

As you can see, following a keybinding definition with another set
of curly brackets creates the sequence. Every nested set of curly brackets
adds another keyboard shortcut that can be pressed after the parent
shortcut. This allows you to add a set of commands that only fire after
pressing the parent command, helping to prevent overlap with system
shortcuts and other custom shortcuts. The possibilities are vast. You can
find out more at
my blog
and at
the aforementioned GitHub URL. Also, see
“Customizing
the Cocoa Text System”
for more details on creating your own
commands.

—
Brett Terpstra

You
don’t have to sacrifice iTunes library size if you’re using
a MacBook. Learn how to quit iTunes
and
eject the
external drive you store your iTunes content on all at once.

I’m going to venture a guess that most of you reading this use a
MacBook as your primary Mac, and that your iTunes library has grown too
big for its britches. You moved it to an external drive, didn’t you? And
now you wish there were an easy way to quit iTunes and eject your drive at
the same time to bring back that good ol’ fashioned “grab and go” feeling
that got you using a MacBook to begin with, right? I think I can help.

With
a little Automator and a dash of Terminal, you can create a
utility that does exactly what I just described, which can make your
portable life just a little easier. You can put this utility in your Dock
or give it a shortcut with a productivity utility like Alfred or
LaunchBar—whatever lets you work the fastest. Let’s get started.