Most key presses simply insert a character into the editor, such as a, 3, or (. Other keys and key combinations act as keyboard shortcuts that move the blinking caret, delete a line, copy the selection, etc. Keyboard shortcuts are usually trigger by key combinations using the Control, Meta, or Command key.
The keyboard shortcuts are displayed using the same string-encoded notation for modifier keys as map-function in keymap% and the Keybindings view;
s: — All platforms: Shift
c: — All platforms: Control
a: — Mac OS: Option
m: — Windows: Alt; Unix: Meta; Mac OS: Command, when map-command-as-meta-key produces #t
d: — Mac OS: Command
l: — All platforms: Caps Lock
g: — Windows: Control plus Alt as AltGr; see get-control+meta-is-altgr in key-event%
?: — All platforms: allow match to character produced by opposite use of Shift, AltGr/Option, and/or Caps Lock, when available; see get-other-shift-key-code in key-event%
If a modifier key is not specified, it matches whether that modifier is pressed or not pressed. A ~ prior to a modifier indicates the keybinding only activates if that modifier is not pressed.
A keyboard shortcut that begins with : only activates if the modifiers Shift, Control, Option, Alt, Meta, or Command are not pressed.
Many of the key-binding actions can also be performed with menu items.
c:‹key› means press the Control key, hold it down and then press ‹key› and then release them both. For example: c:e (Control-E) moves the blinking caret to the end of the current line.
m:‹key› is the same as c:‹key›, except with the Meta key. Depending on your keyboard, Meta may be called “Left,” “Right,” or have a diamond symbol, but it’s usually on the bottom row next to the space bar. m:‹key› can also be performed as a two-character sequence: first, strike and release the Escape key, then strike ‹key›. On Mac OS, Meta is, by default, available only through the Escape key. But the preferences dialog (in the General Editing sub-panel of the Editing panel) has check boxes that adjust the handling of the Alt key or the Command key to be meta.
delete is the Delete key.
space is the Space bar.
On most keyboards, “<” and “>” are shifted characters. So, to get m:>, you actually have to type Meta-Shift->. That is, press and hold down both the Meta and Shift keys, and then strike “>”.
On Windows (and sometimes under Unix) some of these keybindings are actually standard menu items. Those keybindings will behave according to the menus, unless the Enable keybindings in menus preference is unchecked. For example, the c:e keybinding mentioned above actually toggles the visibility of the interactions window.
If you are most familiar with Emacs-style key bindings (especially on windows or some linux installations where the control key is, by default, for the menu shortcuts), you should uncheck the Enable keybindings in menus preference. Many of the keybindings below are inspired by Emacs. See also Defining Custom Shortcuts for suggestions on how to bind keys to menu items on a selective basis.
Some keybindings are not available if Enable keybindings in menus is enabled.
And finally, the authoritative source for keybindings is the Edit menu’s Show Active Keybindings menu item. Keybindings in DrRacket are often sensitive to the window that has the keyboard focus, so the contents of the window that Show Active Keybindings opens will depend where the keyboard focus was when the menu was selected.
c:F6 : move the cursor between different windows (usually the interactions and definitions windows, but also the search window and other editable portions of DrRacket). Also, search for “shift-focus” in the Show Active Keybindings menu’s window for more, platform-specific keybindings that have this functionality
m:s:l : wrap selection in (lambda ()...) and put the insertion point in the argument list of the lambda
c:c;c:o : the sexpression following the insertion point is put in place of its containing sexpression
c:c;c:e : the first and last characters (usually parentheses) of the containing expression are removed
c:cc;:l : wraps a let around the sexpression following the insertion point and puts a printf in at that point (useful for debugging).
c:x;r;a : Adjust nearby ASCII art rectangles (that use +, -, or |) to use Unicode characters.
+-+
| |
+-+
╔═╗
║ ║
╚═╝
c:x;r;w : Widen the nearby ASCII art rectangles.
╔═╦══╗
║ ║ ║
╠═╬══╣
║ ║ ║
╚═╩══╝
╔══╦══╗
║ ║ ║
╠══╬══╣
║ ║ ║
╚══╩══╝
c:x;r;v : Make the nearby ASCII art rectangles taller.
╔══╦══╗
║ ║ ║
╠══╬══╣
║ ║ ║
║ ║ ║
╚══╩══╝
╔══╦══╗
║ ║ ║
║ ║ ║
╠══╬══╣
║ ║ ║
║ ║ ║
╚══╩══╝
c:x;r;c : Centers the contents of the current line inside the enclosing cell of the enclosing ASCII art rectangle.
Return and enter add a line to the enclosing rectangle and put the insertion point at the first column of the enclosing cell.
When in overwrite mode, if a key would overwrite one of the walls of the cell, the wall is first moved over to accomodate the new key
When not in overwrite mode, inserting a character will always widen the containing cell
The interactions window has all of the same keyboard shortcuts as the definitions window plus a few more:
m:p : bring the previously entered expression down to the prompt
m:n : bring the expression after the current expression in the expression history down to the prompt
m:h : Show the current expression history in a separate window
When shift-return is typed: the expression is not submitted and instead a new line is started
When alt-return or control return is typed: the expression is submitted for evaluation
When return with no modified is typed: the language is consulted to determine which of the two previous actions makes the most sense. Typically the language’s parser is consulted to see if the expression looks complete. If so, the expression is submitted and, if not, a new line is started. (See also 'drracket:submit-predicate.)
c:\ m:\ c:x;l : traces backwards from the insertion point, looking for a backslash followed by a LaTeX macro name or a prefix of such a name. If a macro name is found, it replaces the backslash and the name with the corresponding key in the table below; if a (proper) prefix p is found, it replaces p with the longest common prefix of all macro names that have p as a prefix (unless there is only one such name, in which case it behaves as if p were a complete macro name).
Additionally, all of the digits, lowercase letters, and uppercase letters can be turned into blackboard bold characters with the shortcut \b followed by the character. For example, \bN turns into ℕ and \bZ turns into ℤ.
The Add User-defined Keybindings... menu item in the Keybindings sub-menu of Edit selects a file containing Racket definitions of keybindings. The file must contain a module that uses a special keybindings language, framework/keybinding-lang. To do so, begin your file with this line:
The framework/keybinding-lang languages provides all of the bindings from racket, racket/class, and drracket/tool-lib, except that it adjusts #%module-begin to introduce a keybinding form:
(keybindingstring-exprproc-expr)Declares a keybinding, where string-expr must produce a suitable first argument for map-function in keymap% , and the proc-expr must produce a suitable second argument for add-function in keymap% .
For example, this remaps the key combination “control-a” key to “!”.
Since the file contains plain Racket code, you can write keybindings files that use DrRacket’s Extension API. For example, the following file binds “control-t” and “control-=” to a execute the program and open a new tab respectively, as they were used before version 5.2.
[(ctl)"c:"][(cmd)"d:"][(altmeta)"~c:m:"][(shift)"s:"][(option)"a:"]))(keybinding;note: fr could be #f(frame-key"t"execute-callback)(frame-key"="create-new-tab)
Another example, this file rebinds “control-w” to delete the word behind the insertion point, but it does it by setting a new key to be an existing keyboard shortcut. If you see a key in the Show Active Keybindings dialog (in the Keybindings submenu of the Edit menu), then you can use its name with the new keystroke you want, like this:
(keybindingkeycommandedevt#t))))(rebind"c:w""backward-kill-word")
This example shows how to bind a menu item (based on its name) to a particular key. The call at the end of the example binds “control-a” to the Run menu item.
(keybindingkey[event-type'menu][time-stamp(cond(condo)](loopi))](menu-bind"c:a""Run")
Note that DrRacket does not reload keybindings files automatically when you make changes, so you’ll need to restart DrRacket to see changes to the file.
Users comfortable with Emacs and the conventional Lisp/Scheme-style of interaction with an “inferior process” commonly request keybindings in DrRacket that send program fragments to be evaluated at the prompt. This style of interaction is fraught with difficulty, especially for beginners, and so DrRacket, by default, does not support it. Instead, clicking DrRacket’s “Run” button starts with a clean slate and sends the entire contents of the definitions window, ensuring that the state in the REPL matches what you would expect by reading the source code of the program.
Based on years of experience with Emacs modes, some of the authors consider this mode of interaction also appropriate for experienced programmers. Indeed, they go through great effort to mimic this behavior in Emacs.
That said, some people may wish to use such incremental keystroke modes anyway. Therefore the remainder of this section illustrates how to add such an incremental mode for your personal use with an example keybindings file. Specifically, the file shows how to add the ability to send expressions piecemeal to the interactions window. It also demonstrates how to pull together a bunch of pieces of DrRacket’s implementation and its libraries to implement keystrokes.
(cond;;weareinsidesometop-levelexpression;;;findtheenclosingexpression(cond[next-up(loopnext-up)][else(send-range-to-repldefsposshift-focus?)]))][else;;weareatthetop-level(cond;;noexpressionsinthefile,giveup;;noexpressionaftertheinsertionpoint;;;sendtheonebeforeit(send-range-to-repldefsbwshift-focus?)][else;;sendtheexpressionaftertheinsertionpoint(send-range-to-repldefsfwshift-focus?)])]))))(send-range-to-repldefsshift-focus?)))any );;copytheexpressionovertotheinteractionswindowintsstartend#:try-to-move?#f);;eraseanytrailingwhitespace(loop))));;putbackasinglenewline"\n";;makesuretheinteractionsisvisible;;andrunthesubmittedexpression
Others may wish to use the above example to invent other keystrokes for making work in DrRacket convenient.